hls4ml LHC jets (150p): one row per jet, train/validation/test, shipped loader

LICENSE

@@ -0,0 +1,18 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+This dataset is a mirror of
+
+    Pierini, Maurizio; Duarte, Javier; Tran, Nhan; Freytsis, Marat
+    HLS4ML LHC Jet dataset (150 particles)
+    Zenodo, 2020
+    https://doi.org/10.5281/zenodo.3602260
+
+which is published under the Creative Commons Attribution 4.0 International
+licence. The mirror is published under the same licence.
+
+You are free to share and adapt the material for any purpose, including
+commercially, provided you give appropriate credit to the original authors,
+link to the licence, and indicate whether changes were made. The rows here are
+the rows of the original HDF5 files, reshaped; no values were recomputed.
+
+Licence: https://creativecommons.org/licenses/by/4.0/

README.md

@@ -0,0 +1,196 @@
+---
+license: cc-by-4.0
+language:
+- en
+task_categories:
+- tabular-classification
+pretty_name: hls4ml LHC jet dataset (150 particles)
+size_categories:
+- 100K<n<1M
+tags:
+- physics
+- particle-physics
+- jet-tagging
+- hls4ml
+- lhc
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: validation
+    path: data/validation-*.parquet
+  - split: test
+    path: data/test-*.parquet
+---
+
+# hls4ml LHC jet dataset (150 particles)
+
+*A mirror of the Zenodo record
+[10.5281/zenodo.3602260](https://doi.org/10.5281/zenodo.3602260), reshaped to one row
+per jet.*
+
+The data are simulated high transverse-momentum (~1 TeV) jets from proton-proton
+collisions at the Large Hadron Collider, labelled by what produced them: a light quark,
+a gluon, a W boson, a Z boson or a top quark. Each jet is constituted of up to 150
+constituents together with a set of jet-level observables, and the set was prepared for
+the hls4ml jet-tagging studies. The mirror holds 880,000 jets.
+
+Every value is the value of the original HDF5 files. The jet images from the original
+data files are dropped.
+
+## One row is one jet
+
+| column | type | holds |
+|---|---|---|
+| the 16 `j1_*` columns | `list<float32>` | one entry per constituent of that jet, so the lists of one row all have the same length |
+| the 53 `j_*` columns | `float32` | jet-level observables, one value per jet |
+| `label` | `int8` | 0 gluon, 1 light quark, 2 W boson, 3 Z boson, 4 top quark |
+| `source_file` | `string` | the HDF5 file the jet was read from, without its extension |
+| `source_row` | `int32` | the jet's row within that file |
+
+The constituent features, in the order the original files list them, are `j1_px`,
+`j1_py`, `j1_pz`, `j1_e`, `j1_erel`, `j1_pt`, `j1_ptrel`, `j1_eta`, `j1_etarel`,
+`j1_etarot`, `j1_phi`, `j1_phirel`, `j1_phirot`, `j1_deltaR`, `j1_costheta` and
+`j1_costhetarel`. The jet-level features are `j_ptfrac`, `j_pt`, `j_eta`, `j_mass`,
+`j_tau1_b1`, `j_tau2_b1`, `j_tau3_b1`, `j_tau1_b2`, `j_tau2_b2`, `j_tau3_b2`,
+`j_tau32_b1`, `j_tau32_b2`, `j_zlogz`, `j_c1_b0`, `j_c1_b1`, `j_c1_b2`, `j_c2_b1`,
+`j_c2_b2`, `j_d2_b1`, `j_d2_b2`, `j_d2_a1_b1`, `j_d2_a1_b2`, `j_m2_b1`, `j_m2_b2`,
+`j_n2_b1`, `j_n2_b2`, `j_tau1_b1_mmdt`, `j_tau2_b1_mmdt`, `j_tau3_b1_mmdt`,
+`j_tau1_b2_mmdt`, `j_tau2_b2_mmdt`, `j_tau3_b2_mmdt`, `j_tau32_b1_mmdt`,
+`j_tau32_b2_mmdt`, `j_c1_b0_mmdt`, `j_c1_b1_mmdt`, `j_c1_b2_mmdt`, `j_c2_b1_mmdt`,
+`j_c2_b2_mmdt`, `j_d2_b1_mmdt`, `j_d2_b2_mmdt`, `j_d2_a1_b1_mmdt`, `j_d2_a1_b2_mmdt`,
+`j_m2_b1_mmdt`, `j_m2_b2_mmdt`, `j_n2_b1_mmdt`, `j_n2_b2_mmdt`, `j_mass_trim`,
+`j_mass_mmdt`, `j_mass_prun`, `j_mass_sdb2`, `j_mass_sdm1` and `j_multiplicity`. The
+label is the argmax over the five one-hot columns `j_g`, `j_q`, `j_w`, `j_z`, `j_t` that
+the original `jets` array ends with. The one-hot columns and the always-zero `j_undef`
+beside them are not mirrored, but are replaced by `label`.
+
+## Splits
+
+`train` and `validation` come from the Zenodo *train* archive. Its files are
+concatenated in sorted-filename order and cut with
+
+```python
+train_idx, validation_idx = train_test_split(np.arange(n), test_size=0.2, random_state=42)
+```
+
+`test` is the Zenodo *val* archive, in sorted-filename order.
+
+| split | jets | gluon | light quark | W boson | Z boson | top quark |
+|---|---|---|---|---|---|---|
+| `train` | 496,000 | 100,051 | 96,079 | 99,834 | 99,591 | 100,445 |
+| `validation` | 124,000 | 24,797 | 24,132 | 25,103 | 25,063 | 24,905 |
+| `test` | 260,000 | 52,404 | 50,468 | 52,235 | 52,298 | 52,595 |
+
+## Layout
+
+```
+data/train-NNNNN-of-NNNNN.parquet
+data/validation-NNNNN-of-NNNNN.parquet
+data/test-NNNNN-of-NNNNN.parquet
+loader/            the pipeline described below
+configs/           the Hydra tree that drives it
+requirements.txt   what that pipeline needs
+```
+
+## Loading
+
+The tables need only the `datasets` package:
+
+```python
+from datasets import load_dataset
+jets = load_dataset("fastmachinelearning/hls4ml_lhc_jets_150p", split="train")
+jets[0]["j1_pt"]    # the transverse momenta of that jet's constituents
+```
+
+This data record also contains a data processing pipeline that implements a few basic
+recommended processing steps. It reads the parquet files, keeps the leading constituents
+by transverse momentum, normalises each feature by a scale fitted on the training split
+alone, caches the result as `.npy`, and hands back torch tensors:
+
+```python
+import sys
+from huggingface_hub import snapshot_download
+from hydra import compose, initialize_config_dir
+from hydra.utils import instantiate
+record = snapshot_download("fastmachinelearning/hls4ml_lhc_jets_150p", repo_type="dataset")
+sys.path.insert(0, record)  # the configs name loader.*, so the record has to be importable
+with initialize_config_dir(config_dir=record + "/configs", version_base=None):
+    cfg = compose("config", overrides=["paths.root_dir=" + record, "data.nconstituents=32"])
+data = instantiate(cfg.data)
+data.prepare()
+train = data.load("train")
+```
+
+The `train.x` object is a `(jets, 32, 16)` float32 tensor of normalised constituents and
+`train.y` a `(jets, 5)` float32 one-hot tensor of the labels. The
+`data.load("validation")` and the `data.load("test")` objects return the other two
+splits, normalised with the scales fitted on `train`. The `data.nconstituents` is used
+to set the maximum number of constituents per jet; `0` or less keeps all 150. Again,
+these are ordered by descending transverse momentum by the data loader. Data that is
+processed in different ways using the record's dataloader are cached on disk in
+different ways; hence, there's no duplicate preprocessing.
+
+The `prepare` method writes the caches under the `./cache` folder. Please set the
+`HLS4ML_JETS_CACHE` environment to move this elsewhere. Additionally, `prepare` reads
+the shards from `HLS4ML_JETS_ROOT` when the overrides above are left out. Allow the
+cache a few times the record's size on disk. The pipeline needs python 3.11 or newer
+with `numpy`, `pyarrow`, `torch`, `omegaconf` and `hydra-core`, which `pip install -r
+requirements.txt` at the record's root installs. **If you only want the raw tables, you
+need none of the dataloader functionality. Just call `load_dataset`.**
+
+## Caveats
+
+**Constituents are stored in descending transverse momentum, the order they sit in the
+original files.** Every jet of all three splits was checked: no list holds a constituent
+with a higher `j1_pt` than the one before it. The loader in this record still
+stable-sorts each jet by descending `j1_pt` before it truncates to `nconstituents` or
+pads up to it, because the reference pipeline does. The sort of the dataloader acts as a
+double-check that constiutents are stored in descending order. Truncating the lists as
+they come therefore keeps the same leading constituents.
+
+**The lists have no padding or fixed length.** A jet holds as many entries as it has
+constituents, up to 150. The original files pad every jet to 150 slots with rows of
+zeros; those slots are dropped here and rebuilt by the loader.
+
+**The jet images are not mirrored.** The original files carry `jetImage`, `jetImageECAL`
+and `jetImageHCAL`, three 100x100 arrays per jet, which dwarf everything else. Take them
+from Zenodo if you need them.
+
+## Provenance
+
+Simulated proton-proton collisions at the LHC, produced for the hls4ml jet-tagging
+studies and published on Zenodo in 2020 by Maurizio Pierini, Javier Duarte, Nhan Tran
+and Marat Freytsis. This mirror was built from the two archives of that record,
+`hls4ml_LHCjet_150p_train.tar.gz` and `hls4ml_LHCjet_150p_val.tar.gz`, by the code at
+https://github.com/bb511/jet_tagging_datamaker. The data were produced at commit
+[`1718726`](https://github.com/bb511/jet_tagging_datamaker/tree/1718726) of that
+repository.
+
+## Citation
+
+Cite the Zenodo record this dataset mirrors.
+
+```bibtex
+@dataset{pierini_hls4ml_lhc_jets_150p_2020,
+  author    = {Pierini, Maurizio and Duarte, Javier and Tran, Nhan and Freytsis, Marat},
+  title     = {HLS4ML LHC Jet dataset (150 particles)},
+  year      = {2020},
+  publisher = {Zenodo},
+  doi       = {10.5281/zenodo.3602260},
+  url       = {https://doi.org/10.5281/zenodo.3602260}
+}
+```
+
+## Licence
+
+CC BY 4.0, the licence of the original record. See `LICENSE`. Use it for anything,
+including commercially, as long as you credit Pierini, Duarte, Tran and Freytsis, link
+the licence at https://creativecommons.org/licenses/by/4.0/, and say what you changed.
+
+## Contact
+
+Questions and problems are welcome as a discussion on this dataset's page, or as an
+issue on the repository that produced it:
+https://github.com/bb511/jet_tagging_datamaker.

configs/config.yaml

@@ -0,0 +1,21 @@
+# @package _global_
+
+# Root of the configuration tree that ships with the record.
+#
+#   import sys
+#   from hydra import compose, initialize_config_dir
+#   from hydra.utils import instantiate
+#
+#   sys.path.insert(0, record)   # the _target_ below names loader.*, so it has to import
+#   with initialize_config_dir(config_dir=f"{record}/configs", version_base=None):
+#       cfg = compose("config", overrides=[f"paths.root_dir={record}"])
+#   data = instantiate(cfg.data)
+#   data.prepare()
+#   train = data.load("train")
+#
+# basis is the configuration the published studies were run with. Change any single
+# setting with, say, data.nconstituents=8.
+
+defaults:
+  - _self_
+  - data: basis

configs/data/basis.yaml

@@ -0,0 +1,40 @@
+# @package data
+
+# The configuration the published studies were run with: the 32 leading constituents by
+# pT of each jet, five flavour classes (g, q, W, Z, t).
+
+defaults:
+  - /paths: default
+  - _self_
+
+_target_: loader.datamodule.JetData
+_convert_: all
+
+# Where the record is read from and where its caches are built.
+data_dir: ${paths.raw_data_dir}
+cache_root_dir: ${paths.base_data_dir}
+
+# 0 or less keeps every slot, up to max_constituents.
+nconstituents: 32
+max_constituents: 150
+n_classes: 5
+
+# The 16 constituent columns, in the order the h5 files carry them. The order is what
+# fixes the last axis of the tensors, so it must not be rearranged here.
+constituent_features:
+  - j1_px
+  - j1_py
+  - j1_pz
+  - j1_e
+  - j1_erel
+  - j1_pt
+  - j1_ptrel
+  - j1_eta
+  - j1_etarel
+  - j1_etarot
+  - j1_phi
+  - j1_phirel
+  - j1_phirot
+  - j1_deltaR
+  - j1_costheta
+  - j1_costhetarel

configs/paths/default.yaml

@@ -0,0 +1,12 @@
+# @package paths
+
+# Root of the downloaded record, the folder holding data/, loader/ and configs/.
+# Override it on the command line with paths.root_dir=/path/to/the/record.
+root_dir: ${oc.env:HLS4ML_JETS_ROOT,.}
+
+# The published shards.
+raw_data_dir: ${paths.root_dir}/data
+
+# Where the restricted, normalised arrays are cached. They are written to, so they stay
+# outside the downloaded copy.
+base_data_dir: ${oc.env:HLS4ML_JETS_CACHE,./cache}

data/test-00000-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5a7cdd43eec8438850f2d52e7a002b9ab6fce997b0e051f827677e8b707396c
+size 534529744

data/test-00001-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75aa907a5e42e0cbec0c5acfd8b5b56f38b63984ed22943b13b83c95302ec491
+size 388537121

data/train-00000-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:233a273eeaa6ed3b79488d5c95a8727b46888e809c32411d3d14b45718553ab6
+size 533948666

data/train-00001-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:723885abf40dbed1f5153d068069001b37a29fa2008efdd3ce3e981a66669792
+size 535060832

data/train-00002-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d4da883ffa8dacb318958aba40d6ea2f746ad323d9df292bf06fc6fcb660235
+size 534207019

data/train-00003-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8afb425656294d1303fb47d566dbfa5e11b42308d7503b22822fda9a0078b154
+size 161003391

data/validation-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:306ff31b535c7352e9540715b5935559e28de02eb7f4d91d8a0a07d7acf0bbc1
+size 440522352

loader/__init__.py

@@ -0,0 +1,16 @@
+# The loading pipeline that ships with the record.
+#
+# Three stages run in order and the last one caches what it wrote, so a rerun over the
+# same cache directory costs nothing:
+#
+#   reading      the published parquet shards -> the padded (jets, constituents,
+#                features) array the study's own pipeline works on
+#   physics      keep the leading constituents by pT, fit the scale-only normalisation
+#                on the training split, apply it
+#   datamodule   drive both for a caller who wants tensors and nothing else
+#
+# The stages are configured by the hydra tree under configs/, which names them by their
+# _target_. datamodule.JetData is the only entry point a consumer needs.
+#
+# Nothing is imported here, so that reading and physics can be used without torch
+# installed.

loader/datamodule.py

@@ -0,0 +1,133 @@
+# Driving the two stages, for a caller who wants tensors and nothing else.
+
+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__)
+
+# The record is published pre-split: train and validation are the Zenodo train archive
+# split 80/20, test is the Zenodo validation archive.
+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()

loader/physics.py

@@ -0,0 +1,92 @@
+# Restricting to the leading constituents and normalising them.
+#
+# Copied from the study's own data module (jet_tagging_gdl,
+# src/data/hls4ml_datamodule.py) rather than rewritten, so that arrays built from the
+# record and arrays built from the original h5 files agree bit for bit: the same stable
+# argsort over all 150 slots, the same truncate-or-pad, the same python-float scales and
+# the same eps.
+
+from pathlib import Path
+
+import numpy as np
+
+# Features that live on both sides of zero, so the scale is half the observed range.
+CENTERED_FEATURES = {
+    "j1_px", "j1_py", "j1_pz",
+    "j1_eta", "j1_etarel", "j1_etarot",
+    "j1_phi", "j1_phirel", "j1_phirot",
+    "j1_costheta", "j1_costhetarel",
+}
+
+# Features that are non-negative by construction, so the scale is the observed maximum.
+POSITIVE_FEATURES = {
+    "j1_pt", "j1_ptrel",
+    "j1_e",  "j1_erel",
+    "j1_deltaR",
+}
+
+
+def restrict_and_sort_by_pt(x, pt_idx: int, nconstituents: int | None) -> np.ndarray:
+    """Keep the leading *nconstituents* by pT, in descending pT order.
+
+    The full constituent list is sorted before truncation, so the constituents kept are
+    genuinely the highest-pT ones whatever order they appear in on disk. Negating and
+    using a stable sort gives a deterministic order for equal-pT constituents (ties keep
+    their on-disk order); ``argsort(...)[::-1]`` would instead reverse an unstable
+    ascending sort, making tie order arbitrary run to run. Padded slots carry pT = 0 and
+    therefore sort to the end.
+    """
+    sort_idx = np.argsort(-x[:, :, pt_idx], axis=1, kind="stable")
+    x = np.take_along_axis(x, sort_idx[:, :, np.newaxis], axis=1)
+
+    target = x.shape[1] if (nconstituents is None or nconstituents <= 0) else nconstituents
+    if x.shape[1] < target:
+        padding = np.zeros((x.shape[0], target - x.shape[1], x.shape[2]), dtype=x.dtype)
+        return np.concatenate((x, padding), axis=1)
+
+    return x[:, :target, :]
+
+
+def fit_physics_norm(x_train, feature_names) -> dict[str, tuple[str, float]]:
+    """One scale per feature, fitted on the restricted training array alone."""
+    params: dict[str, tuple[str, float]] = {}
+    for i, name in enumerate(feature_names):
+        vals = x_train[:, :, i]
+        vmin, vmax = float(vals.min()), float(vals.max())
+        if name in CENTERED_FEATURES:
+            params[name] = ("centered", 0.5 * (vmax - vmin))
+        elif name in POSITIVE_FEATURES:
+            params[name] = ("positive", vmax)
+        else:
+            raise ValueError(f"Feature '{name}' not categorised in CENTERED or POSITIVE sets.")
+
+    return params
+
+
+def apply_physics_norm(x, feature_names, params, eps: float = 1e-8) -> np.ndarray:
+    """Divide each feature by its scale. Zero padding stays zero, so it survives."""
+    x_norm = x.copy()
+    for i, name in enumerate(feature_names):
+        kind, scale = params[name]
+        if kind not in {"centered", "positive"}:
+            raise ValueError(f"Unknown normalisation kind '{kind}' for feature '{name}'.")
+        x_norm[:, :, i] /= (scale + eps)
+
+    return x_norm
+
+
+def save_norm_params(path, params: dict[str, tuple[str, float]]) -> None:
+    """The study's own npz layout, which its diagnostics and feature lookup read back."""
+    names = np.array(list(params.keys()), dtype="U64")
+    kinds = np.array([params[n][0] for n in names], dtype="U16")
+    scales = np.array([params[n][1] for n in names], dtype=np.float32)
+    np.savez(Path(path), feature_names=names, kinds=kinds, scales=scales)
+
+
+def load_norm_params(path) -> dict[str, tuple[str, float]]:
+    npz = np.load(Path(path), allow_pickle=False)
+
+    return {
+        str(name): (str(kind), float(scale))
+        for name, kind, scale in zip(npz["feature_names"], npz["kinds"], npz["scales"])
+    }

loader/reading.py

@@ -0,0 +1,87 @@
+# Reading the published shards back into the padded arrays the study's pipeline works on.
+#
+# One row of the record is one jet and its constituent columns are jagged: only the real
+# constituents are stored, in the order they had on disk. Padding them back out to a
+# fixed width is what the study's normalisation and its models expect.
+
+from pathlib import Path
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+def shards(data_dir, split: str) -> list[Path]:
+    """The shards of one split, in the order the record numbers them."""
+    found = sorted(Path(data_dir).glob(f"{split}-*.parquet"))
+    if not found:
+        raise FileNotFoundError(f"No {split} shards under {data_dir}")
+
+    return found
+
+
+def dense(table, names, width: int) -> np.ndarray:
+    """Rebuild the (jets, width, features) array, zero-padding the empty slots.
+
+    float64 throughout: the study fits its normalisation on the h5 arrays, which numpy
+    reads as float64, so anything narrower here would shift the scales.
+    """
+    # The 16 columns of a row are one jet's constituents, so they share their offsets and
+    # the first column places the values of all of them.
+    row, slot, n = _positions(_list_array(table[names[0]]), width)
+    out = np.zeros((n, width, len(names)), np.float64)
+    for f, name in enumerate(names):
+        out[row, slot, f] = np.asarray(_list_array(table[name]).flatten())
+
+    return out
+
+
+def labels(table, n_classes: int) -> np.ndarray:
+    """The label column as one-hot rows, the shape the models are trained against."""
+    return np.eye(n_classes, dtype=np.float32)[np.asarray(table["label"]).astype(np.intp)]
+
+
+def read_split(
+    data_dir, split: str, names, width: int, n_classes: int, transform
+) -> tuple[np.ndarray, np.ndarray]:
+    """Every shard of one split, transformed shard by shard and concatenated.
+
+    *transform* is applied before the concatenation, so peak memory holds one dense shard
+    rather than the whole split at full width.
+    """
+    x, y = [], []
+    for shard in shards(data_dir, split):
+        table = pq.read_table(shard, columns=[*names, "label"])
+        x.append(transform(dense(table, names, width)))
+        y.append(labels(table, n_classes))
+
+    return np.concatenate(x), np.concatenate(y)
+
+
+def _positions(column, width: int) -> tuple[np.ndarray, np.ndarray, int]:
+    """Row and slot of every constituent within the flattened value array.
+
+    The offsets of a sliced or combined list array need not start at zero and its
+    ``.values`` may hold entries the array itself does not own, so the slots are counted
+    from ``offsets[0]`` and the values come from ``.flatten()``, which respects the slice.
+    """
+    offsets = np.asarray(column.offsets).astype(np.int64)
+    counts = np.diff(offsets)
+    if counts.size and counts.max() > width:
+        raise ValueError(
+            f"A jet carries {counts.max()} constituents, more than the width {width}"
+        )
+
+    starts = offsets[:-1] - offsets[0]
+    row = np.repeat(np.arange(len(counts)), counts)
+    slot = np.arange(counts.sum()) - np.repeat(starts, counts)
+
+    return row, slot, len(counts)
+
+
+def _list_array(column) -> pa.ListArray:
+    """One contiguous list array, whether the table handed over chunks or an array."""
+    if isinstance(column, pa.ChunkedArray):
+        column = column.combine_chunks()
+
+    return column.chunk(0) if isinstance(column, pa.ChunkedArray) else column

requirements.txt

@@ -0,0 +1,17 @@
+# What the pipeline in loader/ needs, on python 3.11 or newer. From the root of the
+# downloaded record:
+#
+#   pip install -r requirements.txt
+#
+# These are lower bounds rather than pins, and name the major versions the APIs used
+# here belong to rather than floors anyone has tested. The pipeline was run on python
+# 3.11 with numpy 2.4, pyarrow 25, torch 2.9, omegaconf 2.3 and hydra-core 1.3.
+numpy>=1.24
+pyarrow>=14
+torch>=2.0
+omegaconf>=2.3
+hydra-core>=1.3
+
+# Only for fetching the record, as the dataset card's example does. Nothing in loader/
+# imports it, so a record already on disk does not need it.
+huggingface-hub>=1.0