| """Exact upstream splitting, lossless Parquet, and validated graph caches.""" |
| import argparse |
| import gc |
| import hashlib |
| import json |
| from pathlib import Path |
| import pickle |
| import sys |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT)) |
| import awkward as ak |
| import numpy as np |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| import torch |
| from config import CONFIG |
| from data.preprocess_events import preprocess_and_split_events |
| from dataset import PhyGHTDataset |
| from download_data import digest |
|
|
| RUN = ROOT / 'runs/release-20261112' |
| PACKAGE = ROOT / 'release/artifacts/dataset' |
| SCHEMA = pa.schema([ |
| ('event_id', pa.int64()), ('pileup', pa.int32()), |
| ('jets', pa.list_(pa.list_(pa.float64()))), |
| ('trks', pa.list_(pa.list_(pa.float64()))), |
| ('jet_trk_IDs', pa.list_(pa.list_(pa.int64()))), |
| ]) |
|
|
|
|
| def assert_equal(a, b): |
| |
| |
| |
| assert len(a) == len(b) and a.ndim == b.ndim, 'Changed event/list dimensions' |
| for axis in range(1, a.ndim): |
| assert ak.to_list(ak.num(a, axis=axis)) == ak.to_list(ak.num(b, axis=axis)), 'Changed list boundaries' |
| av = ak.to_numpy(ak.flatten(a, axis=None)) |
| bv = ak.to_numpy(ak.flatten(b, axis=None)) |
| assert av.dtype == bv.dtype and av.shape == bv.shape and av.tobytes() == bv.tobytes(), 'Changed numeric bits' |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser() |
| p.add_argument('variant', choices=['mu200', 'mu60']) |
| args = p.parse_args() |
| variant = args.variant |
| status_path = RUN / f'{variant}_data_validated.json' |
| raw_report = json.loads((RUN / f'{variant}_raw_verified.json').read_text()) |
| path = Path(raw_report['path']) |
| assert path.stat().st_size == raw_report['bytes'] |
| assert digest(path, 'md5') == raw_report['md5'], 'Raw file changed since verification' |
| with open(path, 'rb') as stream: |
| raw = pickle.load(stream) |
| assert {'jets', 'trks', 'jet_trk_IDs'} == set(raw), set(raw) |
| assert all(len(x) == 10000 for x in raw.values()) |
| assert bool(ak.all(ak.num(raw['jets'], axis=2) == 6)) |
| assert bool(ak.all(ak.num(raw['trks'], axis=2) == 8)) |
| assert bool(ak.all(ak.num(raw['jets'], axis=1) == ak.num(raw['jet_trk_IDs'], axis=1))) |
| for name in ['jets', 'trks']: |
| assert np.isfinite(ak.to_numpy(ak.flatten(raw[name], axis=None))).all(), name |
| tracks_per_event = ak.to_numpy(ak.num(raw['trks'], axis=1)) |
| jets_per_event = ak.to_numpy(ak.num(raw['jets'], axis=1)) |
| assert tracks_per_event.min() >= CONFIG['K_NEIGHBORS'] |
| assert jets_per_event.min() > 0 |
| shuffled = np.random.RandomState(42).permutation(10000) |
| indices = {'train': shuffled[:8000], 'validation': shuffled[8000:9000], 'test': shuffled[9000:]} |
| assert len(np.unique(np.concatenate(list(indices.values())))) == 10000 |
| report = { |
| 'variant': variant, 'raw': raw_report, 'seed': 42, |
| 'split_algorithm': 'numpy.random.RandomState(42).permutation(10000); 80/10/10', |
| 'counts': {k: len(v) for k, v in indices.items()}, |
| 'tracks_min_median_max': [int(tracks_per_event.min()), float(np.median(tracks_per_event)), int(tracks_per_event.max())], |
| 'jets_min_median_max': [int(jets_per_event.min()), float(np.median(jets_per_event)), int(jets_per_event.max())], |
| 'raw_awkward_types': {k: str(v.type) for k, v in raw.items()}, |
| 'parquet_files': [], 'equivalent_model_inputs': 0, |
| 'missing_association_ids': 0, 'duplicate_track_ids': 0, |
| } |
| split_dir = RUN / 'processed_data' |
| split_dir.mkdir(exist_ok=True) |
| np.savez(split_dir / f'{variant}_event_indices_seed42.npz', **indices) |
| json_indices = PACKAGE / 'splits' / f'{variant}_seed42.json' |
| json_indices.parent.mkdir(parents=True, exist_ok=True) |
| json_indices.write_text(json.dumps({k: v.tolist() for k, v in indices.items()})) |
| preprocess_and_split_events(str(path), str(split_dir), f'{variant}_10k_events', seed=42) |
| CONFIG.update(DATASET_NAME=f'{variant}_10k_events', PROCESSED_DATA_DIR=str(split_dir)) |
| graph_dir = RUN / 'graphs' / variant |
| graph_dir.mkdir(parents=True, exist_ok=True) |
| for split, event_ids in indices.items(): |
| ds = PhyGHTDataset(split) |
| graphs = [] |
| for i, original_id in enumerate(event_ids): |
| |
| for name, actual in [('jets', ds.jets_ak[i]), ('trks', ds.tracks_ak[i]), ('jet_trk_IDs', ds.jet_trk_ids_ak[i])]: |
| assert_equal(raw[name][original_id], actual) |
| track_ids = ak.to_numpy(ds.tracks_ak[i][:, 6]) |
| assert np.array_equal(track_ids, track_ids.astype(np.int64)) |
| report['duplicate_track_ids'] += len(track_ids) - len(np.unique(track_ids)) |
| assoc_ids = ak.to_numpy(ak.flatten(ds.jet_trk_ids_ak[i], axis=None)) |
| report['missing_association_ids'] += int((~np.isin(assoc_ids, track_ids)).sum()) |
| graph = ds[i] |
| graph.event_id = int(original_id) |
| graphs.append(graph) |
| graph_path = graph_dir / f'{split}.pt' |
| torch.save(graphs, graph_path) |
| for shard, start in enumerate(range(0, len(event_ids), 250)): |
| ids = event_ids[start:start + 250] |
| arrays = [pa.array(ids), pa.array(np.full(len(ids), int(variant[2:]), dtype=np.int32))] |
| arrays += [ak.to_arrow(raw[key][ids], extensionarray=False) for key in ['jets', 'trks', 'jet_trk_IDs']] |
| table = pa.Table.from_arrays(arrays, names=SCHEMA.names).cast(SCHEMA) |
| out = PACKAGE / variant / f'{split}-{shard:05d}.parquet' |
| out.parent.mkdir(parents=True, exist_ok=True) |
| pq.write_table(table, out, compression='zstd', row_group_size=25) |
| restored = pq.read_table(out) |
| assert restored.schema == SCHEMA |
| assert restored.column('event_id').to_pylist() == ids.tolist() |
| for key in ['jets', 'trks', 'jet_trk_IDs']: |
| assert_equal(raw[key][ids], ak.from_arrow(restored[key])) |
| |
| converted = PhyGHTDataset.__new__(PhyGHTDataset) |
| converted.jets_ak = ak.from_arrow(restored['jets']) |
| converted.tracks_ak = ak.from_arrow(restored['trks']) |
| converted.jet_trk_ids_ak = ak.from_arrow(restored['jet_trk_IDs']) |
| for local_id in range(len(ids)): |
| original_graph = graphs[start + local_id] |
| converted_graph = converted[local_id] |
| for node, attrs in [('track', ['x', 'label']), ('jet', ['x', 'y'])]: |
| for attr in attrs: |
| assert torch.equal(original_graph[node][attr], converted_graph[node][attr]) |
| edge = ('jet', 'contains', 'track') |
| assert torch.equal(original_graph[edge].edge_index, converted_graph[edge].edge_index) |
| report['equivalent_model_inputs'] += 1 |
| report['parquet_files'].append({'path': str(out.relative_to(PACKAGE)), 'sha256': digest(out), 'rows': len(ids)}) |
| print(f'{variant} {split}: {len(graphs)} graphs and lossless Parquet verified', flush=True) |
| del ds, graphs |
| gc.collect() |
| assert report['duplicate_track_ids'] == 0, 'Ambiguous track identifiers' |
| assert report['equivalent_model_inputs'] == 10000 |
| report['status'] = 'validated' |
| status_path.write_text(json.dumps(report, indent=2)) |
| (PACKAGE / f'{variant}_validation.json').write_text(json.dumps(report, indent=2)) |
| print(json.dumps({k:v for k,v in report.items() if k != 'parquet_files'}), flush=True) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
