| |
| """Compare an existing cache with its deterministic source transformation. |
| |
| No docking, learned-model fitting, embedding inference, or cache replacement. |
| Requires NumPy. PyTorch/PyG objects are NOT deserialized: an allowlisted pickle |
| reader replaces their classes/functions with inert metadata records. Only the |
| referenced numeric ZIP storage is read. Unrecognized classes fail closed. |
| """ |
| import argparse |
| from collections import OrderedDict |
| import csv |
| import hashlib |
| import io |
| import json |
| import math |
| from pathlib import Path |
| import pickle |
| import time |
| import zipfile |
|
|
| import numpy as np |
|
|
|
|
| class InertRecord: |
| def __setstate__(self, state): |
| self.state = state |
|
|
|
|
| class TensorMetadata: |
| def __init__(self, storage, offset, size, stride, *_): |
| self.storage = storage |
| self.offset = int(offset) |
| self.size = tuple(int(x) for x in size) |
| self.stride = tuple(int(x) for x in stride) |
|
|
|
|
| class MetadataReader(pickle.Unpickler): |
| def find_class(self, module, name): |
| if module == 'torch_geometric.data.data' and name in ('Data', 'DataEdgeAttr', 'DataTensorAttr'): |
| return InertRecord |
| if module == 'torch_geometric.data.storage' and name == 'GlobalStorage': |
| return InertRecord |
| if module == 'torch._utils' and name == '_rebuild_tensor_v2': |
| return TensorMetadata |
| if module == 'torch' and name in ('FloatStorage', 'LongStorage', 'DoubleStorage'): |
| return {'FloatStorage': 'f4', 'LongStorage': 'i8', 'DoubleStorage': 'f8'}[name] |
| if module == 'collections' and name == 'OrderedDict': |
| return OrderedDict |
| raise pickle.UnpicklingError(f'Disallowed global: {module}.{name}') |
|
|
| def persistent_load(self, reference): |
| assert isinstance(reference, tuple) and len(reference) == 5 and reference[0] == 'storage' |
| _, dtype, key, location, count = reference |
| assert dtype in ('f4', 'i8', 'f8') and isinstance(key, str) and key.isdigit() |
| assert isinstance(count, int) and 0 <= count <= 500_000_000 |
| return {'dtype': dtype, 'key': key, 'count': count} |
|
|
|
|
| def decode(path): |
| archive = zipfile.ZipFile(path) |
| pickle_names = [x for x in archive.namelist() if x.endswith('/data.pkl')] |
| assert len(pickle_names) == 1 |
| name = pickle_names[0] |
| assert archive.getinfo(name).file_size < 2_000_000 |
| metadata = MetadataReader(io.BytesIO(archive.read(name))).load() |
| prefix = name.rsplit('/', 1)[0] |
| byteorder = archive.read(prefix + '/byteorder').decode().strip() |
| assert byteorder in ('little', 'big') |
| return archive, prefix, byteorder, metadata |
|
|
|
|
| def numeric_tensor(archive, prefix, byteorder, metadata): |
| assert isinstance(metadata, TensorMetadata) |
| storage = metadata.storage |
| dtype = np.dtype(('<' if byteorder == 'little' else '>') + storage['dtype']) |
| payload = archive.read(prefix + '/data/' + storage['key']) |
| values = np.frombuffer(payload, dtype=dtype) |
| assert len(values) == storage['count'] |
| assert metadata.offset >= 0 and all(x >= 0 for x in metadata.size + metadata.stride) |
| last = metadata.offset + sum((n - 1) * s for n, s in zip(metadata.size, metadata.stride)) |
| assert 0 <= last < len(values) |
| view = np.ndarray(metadata.size, dtype=dtype, buffer=payload, |
| offset=metadata.offset * dtype.itemsize, |
| strides=tuple(x * dtype.itemsize for x in metadata.stride)) |
| return np.asarray(view, dtype=np.float32) |
|
|
|
|
| def pooled_protein(path): |
| archive, prefix, byteorder, obj = decode(path) |
| try: |
| if isinstance(obj, dict): |
| candidates = list(obj.values()) |
| else: |
| mapping = obj.state['_store'].state['_mapping'] |
| candidates = [mapping[k] for k in ('x', 'node_s', 'node_features', 'esm', 'emb', 'features') if k in mapping] |
| numeric = [] |
| for candidate in candidates: |
| if not isinstance(candidate, TensorMetadata): |
| continue |
| arr = numeric_tensor(archive, prefix, byteorder, candidate) |
| if arr.ndim == 1: |
| numeric.append(arr) |
| elif arr.ndim >= 2: |
| numeric.append(arr.reshape(arr.shape[0], -1).mean(axis=0, dtype=np.float32)) |
| assert numeric, f'No feature tensor: {path}' |
| |
| return max(numeric, key=lambda x: x.size) |
| finally: |
| archive.close() |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--root', type=Path, default=Path(__file__).resolve().parents[1]) |
| parser.add_argument('--write-ids', action='store_true', help='Write an ID index only after every cache row passes comparison') |
| parser.add_argument('--report', type=Path) |
| args = parser.parse_args() |
| root = args.root.resolve() |
| with (root / 'data/ordered_complex_ids.csv').open(newline='') as handle: |
| ids = [x['PDB_CCD_ID'] for x in csv.DictReader(handle)] |
| cache_path = root / 'data/features/complex_features_ligand_protein_d256_seed0.npy' |
| cache = np.load(cache_path, allow_pickle=False) |
| assert cache.shape == (3179, 256) and cache.dtype == np.float32 |
| ligand_path = root / 'data/features/ligand_chemberta_moad3179.pt' |
| archive, prefix, byteorder, ligand_meta = decode(ligand_path) |
| try: |
| embedded_ids = ligand_meta['ligand_ids'] |
| ligand = numeric_tensor(archive, prefix, byteorder, ligand_meta['embeddings']) |
| assert embedded_ids == ids and ligand.shape == (3179, 384) |
| finally: |
| archive.close() |
| graph_dir = root / 'data/external/protein_graphs_esmc_600m' |
| proteins = [] |
| started = time.time() |
| for index, identifier in enumerate(ids): |
| proteins.append(pooled_protein(graph_dir / f'pyg_graph_{identifier}_esmc_600m.pt')) |
| if (index + 1) % 400 == 0: |
| print(f'Checked existing graph storage {index + 1}/{len(ids)} ({time.time()-started:.1f}s)', flush=True) |
| protein = np.stack(proteins).astype(np.float32) |
| assert protein.shape == (3179, 1152) |
| |
| features = np.asarray(np.concatenate([ligand, protein], axis=1), dtype=np.float32) |
| mean = np.nanmean(features, axis=0, keepdims=True) |
| std = np.nanstd(features, axis=0, keepdims=True) |
| std[std < 1e-8] = 1.0 |
| normalized = np.nan_to_num((features - mean) / std).astype(np.float32) |
| projection = np.random.default_rng(0).normal(0.0, 1.0 / math.sqrt(256), size=(features.shape[1], 256)).astype(np.float32) |
| expected = (normalized @ projection).astype(np.float32) |
| |
| atol = rtol = 2e-5 |
| matching = np.isclose(cache, expected, atol=atol, rtol=rtol) |
| difference = np.abs(cache.astype(np.float64) - expected.astype(np.float64)) |
| passed = bool(matching.all()) |
| report = {'scope': 'deterministic integrity comparison of existing data; no AL, docking, model training, or cache replacement', |
| 'cache_sha256': hashlib.sha256(cache_path.read_bytes()).hexdigest(), |
| 'raw_id_index_sha256': hashlib.sha256((root / 'data/ordered_complex_ids.csv').read_bytes()).hexdigest(), |
| 'ligand_sha256': hashlib.sha256(ligand_path.read_bytes()).hexdigest(), |
| 'producer_reference': 'dal_toolbox_design2/run_dal_toolbox_design2.py functions normalize_features, random_project, load_ligand_features, pooled_graph_feature, build_complex_features', |
| 'packaged_producer_excerpt': 'provenance/historical_acquisition_source/feature_builder_excerpt.py.txt', |
| 'packaged_producer_provenance': 'provenance/historical_acquisition_source/feature_builder_provenance.json', |
| 'shape': list(cache.shape), 'numpy_version': np.__version__, 'projection_seed': 0, |
| 'absolute_tolerance': atol, 'relative_tolerance': rtol, |
| 'maximum_absolute_difference': float(difference.max()), |
| 'root_mean_square_difference': float(np.sqrt(np.mean(difference ** 2))), |
| 'matching_values': int(matching.sum()), 'total_values': int(matching.size), |
| 'matching_rows': int(matching.all(axis=1).sum()), 'total_rows': len(ids), |
| 'bitwise_numeric_equal': bool(np.array_equal(cache, expected)), 'passed': passed, |
| 'note': 'NumPy float32 node pooling can differ in rounding from original PyTorch pooling; all comparisons are explicitly quantified.', |
| 'elapsed_seconds': round(time.time() - started, 2)} |
| if args.report: |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| args.report.write_text(json.dumps(report, indent=2) + '\n') |
| print(json.dumps(report, indent=2), flush=True) |
| if passed and args.write_ids: |
| id_path = root / 'data/features/complex_feature_ids.csv' |
| with id_path.open('w', newline='') as handle: |
| writer = csv.writer(handle) |
| writer.writerow(['PDB_CCD_ID']) |
| writer.writerows((identifier,) for identifier in ids) |
| evidence = {'producer_verified': True, |
| 'verification_kind': 'existing producer transformation independently checked against every cached row', |
| 'evidence': 'data/provenance/feature_cache_comparison.json', |
| 'cache_sha256': report['cache_sha256'], |
| 'feature_ids_sha256': hashlib.sha256(id_path.read_bytes()).hexdigest(), |
| 'absolute_tolerance': atol, 'relative_tolerance': rtol, |
| 'verified_rows': len(ids), 'verified_values': int(matching.size), |
| 'not_a_claim_of_byte_identical_regeneration': not report['bitwise_numeric_equal']} |
| (root / 'data/provenance/combined_feature_alignment.json').write_text(json.dumps(evidence, indent=2) + '\n') |
| return 0 if passed else 2 |
|
|
|
|
| if __name__ == '__main__': |
| raise SystemExit(main()) |
|
|
