| |
|
|
| import json |
| import logging |
| import os |
| from concurrent.futures import ThreadPoolExecutor |
| from dataclasses import dataclass, field |
| from pathlib import Path |
|
|
| import awkward as ak |
| import numpy as np |
| import pyarrow.parquet as pq |
| import torch |
|
|
| from . import common |
|
|
| log = logging.getLogger(__name__) |
|
|
| CACHE_NAMES = ("cache", "mask", "l1bit") |
|
|
|
|
| @dataclass |
| class L1DataAwkward2Torch: |
| """Pad every object to a fixed size and stack them along the constituent axis. |
| |
| Objects are stacked in the alphabetical order of their files and features within an |
| object in the alphabetical order of their names, so that a model trained on one split |
| reads every other split the same way. ``object_feature_map`` records where each one |
| landed and is written beside the tensors. |
| |
| :param nconst: ``{object: constituents kept}``. An object missing from it keeps as |
| many as the split holds. |
| """ |
|
|
| workers: int = 8 |
| nconst: dict = field(default_factory=dict) |
| verbose: bool = False |
|
|
| def __post_init__(self): |
| self.object_feature_map = None |
|
|
| def load_folder(self, folder_path) -> tuple: |
| """One cached split as ``(data, mask, l1bit)``. |
| |
| ``data`` is (events, constituents, features) float32 and ``mask`` marks the slots |
| that hold a real object rather than padding. |
| """ |
| folder_path = Path(folder_path) |
| cached = self._read_cache(folder_path) |
| if cached is not None: |
| return cached |
|
|
| parts = self._process_folder(folder_path) |
| data = torch.from_numpy( |
| np.concatenate([values for _, _, values, _ in parts], axis=1) |
| ) |
| mask = torch.from_numpy( |
| np.concatenate([flags for _, _, _, flags in parts], axis=1) |
| ) |
|
|
| return self._write_cache( |
| folder_path, parts, (data, mask, _l1bit(folder_path, len(data))) |
| ) |
|
|
| def _process_folder(self, folder_path: Path) -> list[tuple]: |
| """Every object of one split, padded, in the order they are stacked in.""" |
| paths = _object_paths(folder_path) |
| if not paths: |
| raise FileNotFoundError(f"No ml-ready object files in {folder_path}.") |
|
|
| with ThreadPoolExecutor( |
| max_workers=min(self.workers, os.cpu_count() or 4) |
| ) as pool: |
| return list(pool.map(self._object_tensor, paths)) |
|
|
| def _object_tensor(self, path: Path) -> tuple: |
| """One object file as (name, features, values, mask), padded to its size.""" |
| data = ak.from_parquet(path) |
| nconst = common.as_dict(self.nconst).get(path.stem) or _max_constituents(data) |
| padded = ak.pad_none(data, nconst, axis=-1, clip=True) |
| mask = ak.Array({f: ~ak.is_none(padded[f], axis=-1) for f in padded.fields}) |
| padded = ak.values_astype(ak.fill_none(padded, 0.0), np.float32) |
|
|
| return ( |
| path.stem, |
| sorted(data.fields), |
| _rectangular(padded), |
| _rectangular(mask, bool), |
| ) |
|
|
| def _read_cache(self, folder_path: Path) -> tuple | None: |
| """The cached tensors, or None when they are absent or describe other columns.""" |
| paths = [folder_path / f"torch_{name}.pt" for name in CACHE_NAMES] |
| listing = folder_path / "cached_objects.json" |
| if not (listing.is_file() and all(path.is_file() for path in paths)): |
| return None |
| if json.loads(listing.read_text()) != self._listing(folder_path): |
| log.warning( |
| "Cached tensors in %s were built otherwise, rebuilding.", folder_path |
| ) |
| return None |
|
|
| self._read_feature_map(folder_path) |
|
|
| return tuple(torch.load(path) for path in paths) |
|
|
| def _write_cache( |
| self, folder_path: Path, parts: list[tuple], tensors: tuple |
| ) -> tuple: |
| """Keep the tensors and the metadata a later run needs to trust them.""" |
| for name, tensor in zip(CACHE_NAMES, tensors): |
| torch.save(tensor, folder_path / f"torch_{name}.pt") |
| (folder_path / "cached_objects.json").write_text( |
| json.dumps(self._listing(folder_path)) |
| ) |
| self.object_feature_map = _feature_map(parts) |
| _map_path(folder_path).write_text(json.dumps(self.object_feature_map, indent=4)) |
|
|
| return tensors |
|
|
| def _read_feature_map(self, folder_path: Path) -> None: |
| """Where each feature sits in the flattened tensor, for undoing the normalisation.""" |
| if self.object_feature_map is None and _map_path(folder_path).is_file(): |
| self.object_feature_map = json.loads(_map_path(folder_path).read_text()) |
|
|
| def _listing(self, folder_path: Path) -> dict: |
| """What a cached tensor is valid for: the columns read and the sizes asked of them. |
| |
| The ml-ready directory is named after the earlier stages but not after this one, |
| so without the sizes a rerun with other constituent counts would be handed the |
| tensor of the run before it. |
| """ |
| nconst = common.as_dict(self.nconst) |
| objects = { |
| path.stem: sorted(pq.read_schema(path).names) |
| for path in _object_paths(folder_path) |
| } |
|
|
| return { |
| "columns": objects, |
| "nconst": {name: nconst.get(name) for name in objects}, |
| } |
|
|
|
|
| def _object_paths(folder_path: Path) -> list[Path]: |
| """The object files of one split. L1bit is a per-event verdict, not an object.""" |
| return sorted(p for p in folder_path.glob("*.parquet") if p.stem != "L1bit") |
|
|
|
|
| def _map_path(folder_path: Path) -> Path: |
| """The feature map sits one level up, being the same for every split of a data set.""" |
| return folder_path.parent / "object_feature_map.json" |
|
|
|
|
| def _max_constituents(data: ak.Array) -> int: |
| """The largest number of entries any event holds, for an object with no set size.""" |
| return max(1, *(int(ak.max(ak.num(data[f]), initial=0)) for f in data.fields)) |
|
|
|
|
| def _rectangular(data: ak.Array, dtype=np.float32) -> np.ndarray: |
| """(events, constituents, features), the features in alphabetical order.""" |
| columns = [ak.to_numpy(data[f], allow_missing=False) for f in sorted(data.fields)] |
|
|
| return np.stack(columns, axis=-1).astype(dtype, copy=False) |
|
|
|
|
| def _feature_map(parts: list[tuple]) -> dict: |
| """Where each object's features land once the tensor is flattened.""" |
| mapping, offset = {}, 0 |
| for name, feats, values, _ in parts: |
| nconst, nfeats = values.shape[-2:] |
| mapping[name] = { |
| feat: [offset + c * nfeats + i for c in range(nconst)] |
| for i, feat in enumerate(feats) |
| } |
| offset += nconst * nfeats |
|
|
| return mapping |
|
|
|
|
| def _l1bit(folder_path: Path, nevents: int) -> torch.Tensor: |
| """The trigger's verdict per event, all true for a split that carries none.""" |
| path = folder_path / "L1bit.parquet" |
| if not path.is_file(): |
| log.warning("No L1bit in %s, taking every event as accepted.", folder_path) |
| return torch.ones(nevents, dtype=torch.bool) |
|
|
| |
| |
| return torch.from_numpy(ak.to_numpy(ak.ravel(ak.from_parquet(path)["L1bit"]))) |
|
|
