| |
|
|
| import logging |
| from dataclasses import dataclass |
| from functools import partial |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
|
|
| from . import physics, reading |
|
|
| log = logging.getLogger(__name__) |
|
|
| |
| |
| SPLITS = ("train", "validation", "test") |
|
|
| CACHE_FILES = ( |
| *(f"x_{split}.npy" for split in SPLITS), |
| *(f"y_{split}.npy" for split in SPLITS), |
| "norm_params.npz", |
| ) |
|
|
|
|
| @dataclass(frozen=True) |
| class SplitTensors: |
| """One split as a model sees it: the constituents and the one-hot flavour label.""" |
|
|
| x: torch.Tensor |
| y: torch.Tensor |
|
|
|
|
| @dataclass |
| class JetData: |
| """Restrict, normalise and cache the published jets, then hand back their tensors. |
| |
| The normalisation is fitted on the training split alone and applied unchanged to |
| validation and to test, which is what the study does. |
| |
| :param data_dir: The record's ``data/``, holding the parquet shards. |
| :param cache_root_dir: Where the caches are built. They are written to and roughly |
| the size of the record, so they stay outside the downloaded copy. |
| :param constituent_features: The 16 columns, in the order the h5 files carry them. |
| :param nconstituents: How many leading constituents by pT to keep; 0 or less keeps |
| all ``max_constituents``. |
| """ |
|
|
| data_dir: str |
| cache_root_dir: str |
| constituent_features: list[str] |
| nconstituents: int = 32 |
| max_constituents: int = 150 |
| n_classes: int = 5 |
|
|
| @property |
| def cache_folder(self) -> Path: |
| """One directory per constituent count, so two of them never share a cache.""" |
| if self.nconstituents <= 0: |
| return Path(self.cache_root_dir) / "full" |
|
|
| return Path(self.cache_root_dir) / f"nconst_{self.nconstituents}" |
|
|
| @property |
| def feature_names(self) -> list[str]: |
| return list(self.constituent_features) |
|
|
| @property |
| def pt_idx(self) -> int: |
| return self.feature_names.index("j1_pt") |
|
|
| @property |
| def norm_params(self) -> dict[str, tuple[str, float]] | None: |
| """The fitted scales, once prepare() has written them.""" |
| path = self.cache_folder / "norm_params.npz" |
|
|
| return physics.load_norm_params(path) if path.is_file() else None |
|
|
| def prepare(self) -> None: |
| """Build the cache. Cached, so reruns are cheap.""" |
| if all((self.cache_folder / name).is_file() for name in CACHE_FILES): |
| log.info(f"Cache already built in {self.cache_folder}") |
| return |
|
|
| self.cache_folder.mkdir(parents=True, exist_ok=True) |
| params = self._prepare_train() |
| for split in SPLITS[1:]: |
| self._prepare_split(split, params) |
|
|
| def load(self, split: str) -> SplitTensors: |
| """One cached split, x as (jets, constituents, features) and y one-hot.""" |
| if split not in SPLITS: |
| raise ValueError(f"Unknown split '{split}', expected one of {SPLITS}") |
|
|
| return SplitTensors(x=self._tensor(f"x_{split}"), y=self._tensor(f"y_{split}")) |
|
|
| def _prepare_train(self) -> dict[str, tuple[str, float]]: |
| """The training split, which is also where the normalisation is fitted.""" |
| x, y = self._read("train") |
| params = physics.fit_physics_norm(x, self.feature_names) |
| physics.save_norm_params(self.cache_folder / "norm_params.npz", params) |
| self._save("train", physics.apply_physics_norm(x, self.feature_names, params), y) |
|
|
| return params |
|
|
| def _prepare_split(self, split: str, params: dict[str, tuple[str, float]]) -> None: |
| x, y = self._read(split) |
| self._save(split, physics.apply_physics_norm(x, self.feature_names, params), y) |
|
|
| def _read(self, split: str) -> tuple[np.ndarray, np.ndarray]: |
| """The shards of one split, each restricted to the leading constituents.""" |
| transform = partial( |
| physics.restrict_and_sort_by_pt, |
| pt_idx=self.pt_idx, |
| nconstituents=self.nconstituents, |
| ) |
|
|
| return reading.read_split( |
| self.data_dir, |
| split, |
| self.feature_names, |
| self.max_constituents, |
| self.n_classes, |
| transform, |
| ) |
|
|
| def _save(self, split: str, x: np.ndarray, y: np.ndarray) -> None: |
| """float32 on disk: the pipeline runs in float64, the models train in float32.""" |
| np.save(self.cache_folder / f"x_{split}.npy", x.astype(np.float32)) |
| np.save(self.cache_folder / f"y_{split}.npy", y.astype(np.float32)) |
|
|
| def _tensor(self, name: str) -> torch.Tensor: |
| return torch.from_numpy(np.load(self.cache_folder / f"{name}.npy")).float() |
|
|
