| |
| |
| |
| |
| |
|
|
| import logging |
| import pickle |
| from dataclasses import dataclass, field |
| from pathlib import Path |
|
|
| import awkward as ak |
| import numpy as np |
|
|
| log = logging.getLogger(__name__) |
|
|
|
|
| @dataclass |
| class L1DataNormalizer: |
| """Shift and scale each feature of each object by parameters fitted on train. |
| |
| :param name: The scheme, one of ``unnormalized``, ``robust``, ``standard`` and |
| ``robust_axov4``. It also names the ml-ready cache, so two schemes never share |
| one directory. |
| :param hyperparams: Passed to the fit of that scheme, e.g. the quantiles bounding |
| the robust range. ``None`` for a scheme that takes none. |
| """ |
|
|
| name: str |
| hyperparams: dict | None = None |
| norm_params: dict = field(default_factory=dict, init=False) |
|
|
| def fit(self, data: ak.Array, obj_name: str) -> None: |
| """Determine one object's parameters. Fit on the training split only.""" |
| log.info("Fitting %s normalisation to %s.", self.name, obj_name) |
| self.obj_name = obj_name |
| fit = getattr(self, f"_{self.name}_fit") |
| if self.hyperparams: |
| fit(data, **self.hyperparams) |
| else: |
| fit(data) |
|
|
| def norm(self, data: ak.Array, obj_name: str) -> ak.Array: |
| """Apply the parameters fitted earlier to any split.""" |
| return getattr(self, f"_{self.name}")(data, obj_name) |
|
|
| def import_norm_params(self, norm_filepath: Path, obj_name: str) -> None: |
| """Read one object's parameters back, for a run that did not fit them itself.""" |
| if not Path(norm_filepath).is_file(): |
| raise FileNotFoundError(f"Norm params not found at {norm_filepath}!") |
|
|
| self.norm_params[obj_name] = pickle.loads(Path(norm_filepath).read_bytes()) |
|
|
| def export_norm_params(self, norm_filepath: Path, obj_name: str) -> None: |
| """Write one object's parameters beside the split they were fitted on.""" |
| if Path(norm_filepath).suffix != ".pkl": |
| raise ValueError( |
| f"Norm params are only written to .pkl, not {norm_filepath}." |
| ) |
|
|
| Path(norm_filepath).write_bytes(pickle.dumps(self.norm_params[obj_name])) |
|
|
| def setup_1d_denorm(self, object_feature_map: dict) -> None: |
| """Build the tensors that undo the normalisation on a flattened model input. |
| |
| :param object_feature_map: ``{object: {feature: [flat indices]}}``, as the torch |
| stage writes it beside the tensors. |
| """ |
| import torch |
|
|
| self.object_feature_map = object_feature_map |
| length = sum(len(i) for m in object_feature_map.values() for i in m.values()) |
| self.scale_tensor = torch.ones(length, dtype=torch.float32) |
| self.shift_tensor = torch.zeros(length, dtype=torch.float32) |
| for obj_name, feature_map in object_feature_map.items(): |
| self._fill_1d(obj_name, feature_map) |
|
|
| def norm_1d_tensor(self, data): |
| """Normalise a flattened model input in place.""" |
| scale, shift = self._as(data) |
|
|
| return data.sub_(shift).div_(scale) |
|
|
| def denorm_1d_tensor(self, data): |
| """Undo :meth:`norm_1d_tensor` in place, e.g. on a model's reconstruction.""" |
| scale, shift = self._as(data) |
|
|
| return data.mul_(scale).add_(shift) |
|
|
| def _fill_1d(self, obj_name: str, feature_map: dict) -> None: |
| """One object's parameters, spread over the columns it occupies.""" |
| params = self.norm_params.get(obj_name) |
| if not params: |
| raise ValueError(f"Missing norm params for the {obj_name} object.") |
|
|
| for feat, idxs in feature_map.items(): |
| self.scale_tensor[idxs] = float(params.get(feat, {}).get("scale", 1.0)) |
| self.shift_tensor[idxs] = float(params.get(feat, {}).get("shift", 0.0)) |
|
|
| def _as(self, data): |
| """The parameter tensors, on the device and dtype of the data they act on.""" |
| if getattr(self, "scale_tensor", None) is None: |
| raise ValueError("Run setup_1d_denorm before normalising a flat tensor.") |
|
|
| return ( |
| self.scale_tensor.to(device=data.device, dtype=data.dtype), |
| self.shift_tensor.to(device=data.device, dtype=data.dtype), |
| ) |
|
|
| def _affine(self, data: ak.Array, obj_name: str) -> ak.Array: |
| """Shift and scale every feature by the parameters fitted for it.""" |
| params = self.norm_params[obj_name] |
|
|
| return ak.Array( |
| { |
| f: (data[f] - params[f]["shift"]) / params[f]["scale"] |
| for f in data.fields |
| } |
| ) |
|
|
| def _unnormalized(self, data: ak.Array, obj_name: str) -> ak.Array: |
| return data |
|
|
| def _unnormalized_fit(self, data: ak.Array) -> None: |
| self._record({f: (0.0, 1.0) for f in data.fields}) |
|
|
| |
| _robust = _affine |
| _standard = _affine |
| _robust_axov4 = _affine |
|
|
| def _robust_fit(self, data: ak.Array, percentiles: list) -> None: |
| """Shift by the median, scale by the interquantile range.""" |
| fitted = {} |
| for feat in data.fields: |
| values = _values(data[feat]) |
| low, high = np.quantile(values, percentiles) |
| fitted[feat] = (float(np.median(values)), float(high - low)) |
|
|
| self._record(fitted) |
|
|
| def _standard_fit(self, data: ak.Array) -> None: |
| """Shift by the mean, scale by the standard deviation.""" |
| fitted = {} |
| for feat in data.fields: |
| values = _values(data[feat]) |
| fitted[feat] = (float(np.mean(values)), float(np.std(values))) |
|
|
| self._record(fitted) |
|
|
| def _robust_axov4_fit(self, data: ak.Array, percentiles: list, scale: list) -> None: |
| """Robust, with the quantile range mapped onto the interval ``scale``. |
| |
| ``scale = [2, -2]`` puts the quantile range between -2 and 2 rather than between |
| 0 and 1, which is the convention the axol1tl v4 and v5 trainings were run with. |
| """ |
| width = scale[0] - scale[1] |
| fitted = {} |
| for feat in data.fields: |
| low, high = np.quantile(_values(data[feat]), percentiles) |
| fitted[feat] = ( |
| (low * scale[0] - high * scale[1]) / width, |
| (high - low) / width, |
| ) |
|
|
| self._record(fitted) |
|
|
| def _record(self, fitted: dict) -> None: |
| """Store one object's parameters, guarding the degenerate scale of a flat feature.""" |
| self.norm_params[self.obj_name] = { |
| feat: {"shift": shift, "scale": scale if scale else 1e-12} |
| for feat, (shift, scale) in fitted.items() |
| } |
|
|
|
|
| def _values(feature: ak.Array) -> np.ndarray: |
| """One feature's real entries, the padding not yet being there to exclude.""" |
| return ak.to_numpy(ak.flatten(feature)) |
|
|
