f9columnar 0.3.2__tar.gz → 0.3.4__tar.gz

{f9columnar-0.3.2 → f9columnar-0.3.4}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: f9columnar
-Version: 0.3.2
+Version: 0.3.4
 Summary: Columnar analysis utils.
 License: MIT
+License-File: LICENSE
 Author: Jan Gavranovic
 Author-email: jan.gavranovic@cern.ch
 Requires-Python: >=3.10,<3.13
@@ -33,7 +34,7 @@ Requires-Dist: scipy (>=1.14.1,<2.0.0)
 Requires-Dist: seaborn (>=0.13.2,<0.14.0)
 Requires-Dist: sympy (>=1.13.1,<2.0.0)
 Requires-Dist: tables (>=3.10.1,<4.0.0)
-Requires-Dist: torch (==2.7.0) ; extra == "torch"
+Requires-Dist: torch (==2.8.0) ; extra == "torch"
 Requires-Dist: tqdm (>=4.65.0,<5.0.0)
 Requires-Dist: uncertainties (>=3.2.2,<4.0.0)
 Requires-Dist: uproot (>=5.3.10,<6.0.0)
@@ -47,7 +48,7 @@ Description-Content-Type: text/markdown
 
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![python](https://img.shields.io/badge/-Python_3.12-3776AB?logo=python&logoColor=white)](https://www.python.org/)
-[![pytorch](https://img.shields.io/badge/-PyTorch_2.7-EE4C2C?logo=pytorch&logoColor=white)](https://pytorch.org/)
+[![pytorch](https://img.shields.io/badge/-PyTorch_2.8-EE4C2C?logo=pytorch&logoColor=white)](https://pytorch.org/)
 [![License](https://img.shields.io/badge/license-MIT-green)](./LICENSE)
 [![pytorch](https://img.shields.io/pypi/v/f9columnar)](https://pypi.org/project/f9columnar/)
 
@@ -59,7 +60,7 @@ A lightweight Python package for batch processing of ROOT and HDF5 event data.
 
 This package is designed for efficient handling of large datasets. Built on PyTorch, Awkward Array, and Uproot, it utilizes PyTorch's DataLoader with an IterableDataset to enable parallel processing. It implements a columnar event loop, returning batches of events in a format compatible with standard PyTorch training loops over multiple epochs.
 
-Optimized for machine learning applications, the package provides `RootDataLoader` and `Hdf5DataLoader` classes for data loading from ROOT and HDF5 files. Additionally, it supports parallel data processing through a modular pipeline of processor classes, allowing users to chain operations for complex computations and histogramming.
+It is optimized for machine learning applications, the package provides `RootDataLoader` and `Hdf5DataLoader` classes for data loading from ROOT and HDF5 files. Additionally, it supports parallel data processing through a modular pipeline of processor classes, allowing users to chain operations for complex computations and histogramming.
 
 ##  Setup
 

{f9columnar-0.3.2 → f9columnar-0.3.4}/README.md

@@ -4,7 +4,7 @@
 
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![python](https://img.shields.io/badge/-Python_3.12-3776AB?logo=python&logoColor=white)](https://www.python.org/)
-[![pytorch](https://img.shields.io/badge/-PyTorch_2.7-EE4C2C?logo=pytorch&logoColor=white)](https://pytorch.org/)
+[![pytorch](https://img.shields.io/badge/-PyTorch_2.8-EE4C2C?logo=pytorch&logoColor=white)](https://pytorch.org/)
 [![License](https://img.shields.io/badge/license-MIT-green)](./LICENSE)
 [![pytorch](https://img.shields.io/pypi/v/f9columnar)](https://pypi.org/project/f9columnar/)
 
@@ -16,7 +16,7 @@ A lightweight Python package for batch processing of ROOT and HDF5 event data.
 
 This package is designed for efficient handling of large datasets. Built on PyTorch, Awkward Array, and Uproot, it utilizes PyTorch's DataLoader with an IterableDataset to enable parallel processing. It implements a columnar event loop, returning batches of events in a format compatible with standard PyTorch training loops over multiple epochs.
 
-Optimized for machine learning applications, the package provides `RootDataLoader` and `Hdf5DataLoader` classes for data loading from ROOT and HDF5 files. Additionally, it supports parallel data processing through a modular pipeline of processor classes, allowing users to chain operations for complex computations and histogramming.
+It is optimized for machine learning applications, the package provides `RootDataLoader` and `Hdf5DataLoader` classes for data loading from ROOT and HDF5 files. Additionally, it supports parallel data processing through a modular pipeline of processor classes, allowing users to chain operations for complex computations and histogramming.
 
 ##  Setup
 

{f9columnar-0.3.2 → f9columnar-0.3.4}/f9columnar/arrays.py

@@ -4,7 +4,7 @@ import copy
 import logging
 from dataclasses import dataclass
 from dataclasses import field as dataclass_field
-from typing import Any
+from typing import Any, Self
 
 import awkward as ak
 import numpy as np
@@ -25,12 +25,12 @@ class BaseArrays:
     def shape(self) -> tuple[int, int]:
         return (len(self.array), len(self.fields))
 
-    def mask(self, mask: ak.Array | np.ndarray, inplace: bool = True) -> ak.Array | BaseArrays:
+    def mask(self, mask: ak.Array | np.ndarray, inplace: bool = True) -> Self:
         if inplace:
             self.array = self.array[mask]
             return self
         else:
-            return self.array[mask]
+            return self.__class__(self.array[mask])
 
     def _check_type(self, value: Any) -> bool:
         raise NotImplementedError
@@ -71,9 +71,9 @@ class BaseArrays:
         return self
 
     def __len__(self) -> int:
-        if type(self.array) is ak.Array:
+        if isinstance(self.array, ak.Array):
             return len(self.array)
-        elif type(self.array) is ak.Record:
+        elif isinstance(self.array, ak.Record):
             return 1
         else:
             raise ValueError("Invalid array type!")
@@ -169,9 +169,7 @@ class Arrays:
     def shape(self) -> tuple[int, int, int]:
         return (len(self), len(self.flat_fields), len(self.jagged_fields))
 
-    def remove_empty(
-        self, return_mask: bool = False, all_fields: bool = True
-    ) -> Arrays | ak.Array | tuple[ak.Array | None, ak.Array] | None:
+    def remove_empty(self, return_mask: bool = False, all_fields: bool = True) -> Arrays | ak.Array | None:
         if self.jagged_arrays is None:
             if return_mask:
                 return None
@@ -185,7 +183,7 @@ class Arrays:
         else:
             return self.mask_flat_inplace(non_empty_mask)
 
-    def mask_flat(self, mask: ak.Array | np.ndarray) -> tuple[ak.Array | None, ak.Array | None]:
+    def mask_flat(self, mask: ak.Array | np.ndarray) -> tuple[FlatArrays | None, JaggedArrays | None]:
         if self.flat_arrays is not None:
             flat_masked = self.flat_arrays.mask(mask, inplace=False)
         else:
@@ -207,7 +205,7 @@ class Arrays:
 
         return self
 
-    def mask_jagged(self, mask: ak.Array | np.ndarray) -> ak.Array | None:
+    def mask_jagged(self, mask: ak.Array | np.ndarray) -> JaggedArrays | None:
         if self.jagged_arrays is not None:
             jagged_masked = self.jagged_arrays.mask(mask, inplace=False)
         else:
@@ -661,3 +659,32 @@ class ArraysProcessor(Processor):
             arrays = self.arrays_handler.make_array_groups(arrays, self.groups)
 
         return {"arrays": arrays}
+
+
+def arrays_to_ak(arrays: Arrays) -> ak.Array:
+    fields: dict[str, ak.Array] = {}
+
+    if arrays.flat_arrays is not None:
+        for field in arrays.flat_arrays.fields:
+            fields[field] = arrays.flat_arrays.array[field]
+
+    if arrays.jagged_arrays is not None:
+        for field in arrays.jagged_arrays.fields:
+            fields[field] = arrays.jagged_arrays.array[field]
+
+    return ak.zip(fields, depth_limit=1)
+
+
+def group_arrays_to_ak(group_arrays: GroupArrays) -> ak.Array:
+    group_fields: dict[str, ak.Array] = {}
+
+    for _, arrays in group_arrays.group_arrays.items():
+        if arrays.flat_arrays is not None:
+            for field in arrays.flat_arrays.fields:
+                group_fields[field] = arrays.flat_arrays.array[field]
+
+        if arrays.jagged_arrays is not None:
+            for field in arrays.jagged_arrays.fields:
+                group_fields[field] = arrays.jagged_arrays.array[field]
+
+    return ak.zip(group_fields, depth_limit=1)

{f9columnar-0.3.2 → f9columnar-0.3.4}/f9columnar/hdf5_dataloader.py

@@ -141,9 +141,6 @@ class Hdf5Iterator:
         else:
             arrays = dataset[self._current_start_entry : self._current_stop_entry]
 
-        if self.shuffle:
-            np.random.shuffle(arrays)
-
         return arrays
 
     def __next__(self) -> tuple[Any, dict[str, Any]]:

{f9columnar-0.3.2 → f9columnar-0.3.4}/f9columnar/ml/dataloader_helpers.py

@@ -87,7 +87,10 @@ def get_hdf5_metadata(hdf5_file_path: str | list[str], resolve_path: bool = Fals
         hdf5_file_path = resolve_hdf5_path(hdf5_file_path)
 
     with h5py.File(hdf5_file_path, "r") as f:
-        metadata = json.loads(f["metadata"][()])
+        try:
+            metadata = json.loads(f["metadata"][()])
+        except KeyError:
+            return {}
 
     return metadata
 
@@ -377,7 +380,7 @@ def get_column_selection(hdf5_files: str | list[str], column_names: list[str]) -
     selection = ColumnSelection()
 
     for dataset_name in used_columns_dct.keys():
-        if dataset_name in pad_values:
+        if pad_values is not None and dataset_name in pad_values:
             pad_value = float(pad_values[dataset_name])
         else:
             pad_value = None

{f9columnar-0.3.2 → f9columnar-0.3.4}/f9columnar/ml/dataset_scaling.py

@@ -22,6 +22,7 @@ class DatasetScaler:
         scaler_save_path: str | None = None,
         n_max: int | float | None = None,
         extra_hash: str | None = None,
+        reuse_scalers: bool = True,
         scaler_kwargs: dict[str, Any] | None = None,
         dataset_kwargs: dict[str, Any] | None = None,
         dataloader_kwargs: dict[str, Any] | None = None,
@@ -41,10 +42,10 @@ class DatasetScaler:
             by default None.
         n_max : int | float | None, optional
             Maximum number of events to use for feature scaling. If None, all events will be used, by default None.
-        perform_closure : bool, optional
-            Whether to perform feature scaling closure. If True, the `closure_config` must be provided, by default False.
-        closure_config : dict[str, dict[str, Any]] | None, optional
-            Configuration for the feature scaling closure. Needed if `perform_closure` is True.
+        extra_hash : str | None, optional
+            Extra hash to append to the scaler filename, by default None.
+        reuse_scalers : bool, optional
+            Whether to reuse the same scaler for all objects in a dataset, by default True.
         scaler_kwargs : dict[str, Any] | None, optional
             Additional keyword arguments to pass to the sklearn feature scaler, by default None.
         dataset_kwargs : dict[str, Any] | None, optional
@@ -76,7 +77,7 @@ class DatasetScaler:
             dataloader_kwargs,
         )
 
-        self.dataset_scalers = self._get_scalers(scaler_type, scaler_save_path, n_max, scaler_kwargs)
+        self.dataset_scalers = self._get_scalers(scaler_type, scaler_save_path, n_max, scaler_kwargs, reuse_scalers)
         logging.info(f"Scaling datasets: {list(self.dataset_scalers.keys())}")
 
     def _get_dataloader(
@@ -104,6 +105,7 @@ class DatasetScaler:
         scaler_save_path: str,
         n_max: int | float | None = None,
         scaler_kwargs: dict[str, Any] | None = None,
+        reuse_scalers: bool = False,
     ) -> dict[str, dict[str, list[FeatureScaler | None]]]:
         if scaler_kwargs is None:
             scaler_kwargs = {}
@@ -116,21 +118,22 @@ class DatasetScaler:
             numer_scalers: list[FeatureScaler | None] = []
             categ_scalers: list[FeatureScaler | None] = []
 
-            for _ in range(n_objects):
-                if len(column_selection.numer_columns) != 0:
-                    numer_feature_scaler = NumericalFeatureScaler(
-                        scaler_type,
-                        n_max=n_max,
-                        save_path=scaler_save_path,
-                        **scaler_kwargs,
-                    )
-                else:
-                    numer_feature_scaler = None
-
-                if len(column_selection.categ_columns) != 0:
-                    categ_feature_scaler = CategoricalFeatureScaler("categorical", scaler_save_path)
-                else:
-                    categ_feature_scaler = None
+            for n_obj in range(n_objects):
+                if (reuse_scalers and n_obj == 0) or (not reuse_scalers):
+                    if len(column_selection.numer_columns) != 0:
+                        numer_feature_scaler = NumericalFeatureScaler(
+                            scaler_type,
+                            n_max=n_max,
+                            save_path=scaler_save_path,
+                            **scaler_kwargs,
+                        )
+                    else:
+                        numer_feature_scaler = None
+
+                    if len(column_selection.categ_columns) != 0:
+                        categ_feature_scaler = CategoricalFeatureScaler("categorical", scaler_save_path)
+                    else:
+                        categ_feature_scaler = None
 
                 numer_scalers.append(numer_feature_scaler)
                 categ_scalers.append(categ_feature_scaler)
@@ -145,19 +148,21 @@ class DatasetScaler:
     def _get_padding_mask(self, X: np.ndarray, dataset_name: str) -> np.ndarray | None:
         return padding_mask(X, self.selection[dataset_name].pad_value)
 
-    def _scale_dataset_idx(self, ds_batch: WeightedDatasetBatch, dataset_name: str, idx: int) -> bool:
+    def _scale_dataset_idx(
+        self, ds_batch: WeightedDatasetBatch, dataset_name: str, idx: int, scale_categ_padding: bool = True
+    ) -> bool:
         X = ds_batch[dataset_name].X.numpy()
 
         if dataset_name != "events":
             X = X[:, idx, :]
             padding_mask = self._get_padding_mask(X, dataset_name)
-
-            if padding_mask is not None:
-                X = X[padding_mask]
         else:
             padding_mask = None
 
         if self.selection[dataset_name].has_categ_columns:
+            if padding_mask is not None and not scale_categ_padding:
+                X = X[padding_mask]
+
             categ_feature_scaler = self.dataset_scalers[dataset_name]["categ"][idx]
 
             if categ_feature_scaler is None:
@@ -169,6 +174,9 @@ class DatasetScaler:
             categ_feature_scaler.fit(X_categ)
 
         if self.selection[dataset_name].has_numer_columns:
+            if padding_mask is not None:
+                X = X[padding_mask]
+
             numer_feature_scaler = self.dataset_scalers[dataset_name]["numer"][idx]
 
             if numer_feature_scaler is None:

{f9columnar-0.3.2 → f9columnar-0.3.4}/f9columnar/ml/hdf5_dataloader.py

@@ -28,6 +28,10 @@ WeightedBatchType = tuple[
     torch.Tensor,
     dict[str, Any],
 ]
+FullWeightedBatchType = tuple[
+    dict[str, tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None, torch.Tensor | None]],
+    dict[str, Any],
+]
 
 
 @dataclass(frozen=True, slots=True, repr=False, eq=False)
@@ -165,6 +169,16 @@ class WeightedBatch:
         if isinstance(self._y_aux, np.ndarray):
             self._y_aux = torch.from_numpy(self._y_aux)
 
+        n_samples = self._X.shape[0]
+        if self._y is not None and self._y.shape[0] != n_samples:
+            raise RuntimeError("X and y must have the same first dimension!")
+
+        if self._w is not None and self._w.shape[0] != n_samples:
+            raise RuntimeError("X and w must have the same first dimension!")
+
+        if self._y_aux is not None and self._y_aux.shape[0] != n_samples:
+            raise RuntimeError("X and y_aux must have the same first dimension!")
+
     @property
     def X(self) -> torch.Tensor:
         return self._X  # type: ignore
@@ -185,8 +199,7 @@ class WeightedBatch:
     def feature_shape(self) -> tuple[int, ...]:
         return tuple(self._X.shape)
 
-    @property
-    def batch(self) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None, torch.Tensor | None]:
+    def make_batch(self) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None, torch.Tensor | None]:
         return self._X, self._y, self._w, self._y_aux  # type: ignore
 
     def mask(self, mask: np.ndarray | torch.Tensor) -> WeightedBatch:
@@ -283,6 +296,14 @@ class WeightedDatasetBatch:
 
         return self.__class__(_masked_datasets)
 
+    def make_batch(
+        self,
+    ) -> dict[str, tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None, torch.Tensor | None]]:
+        batch = {}
+        for key, ds_batch in self._datasets.items():
+            batch[key] = ds_batch.make_batch()
+        return batch
+
     def __repr__(self) -> str:
         return f"WeightedDatasetBatch({self.keys()})"
 
@@ -393,7 +414,7 @@ class MLHdf5Iterator(Hdf5Iterator):
         postfix: str | None = None,
         extra_hash: str = "",
     ) -> tuple[NumericalFeatureScaler | None, CategoricalFeatureScaler | None]:
-        if scaler_path is None and scaler_type is None:
+        if scaler_path is None or scaler_type is None:
             return None, None
 
         numer_feature_scaler: NumericalFeatureScaler | None
@@ -422,7 +443,7 @@ class MLHdf5Iterator(Hdf5Iterator):
 
         return numer_feature_scaler, categ_feature_scaler
 
-    def _scale(self, X: np.ndarray, dataset_name: str, is_numer: bool) -> np.ndarray:
+    def _scale(self, X: np.ndarray, dataset_name: str, is_numer: bool, scale_categ_padding: bool = True) -> np.ndarray:
         scalers: list[NumericalFeatureScaler | None] | list[CategoricalFeatureScaler | None]
 
         if is_numer:
@@ -432,6 +453,9 @@ class MLHdf5Iterator(Hdf5Iterator):
 
         n_objects = self.selection[dataset_name].n_objects
 
+        if len(scalers) != n_objects:
+            raise RuntimeError(f"Scaler list length mismatch for dataset {dataset_name}.")
+
         if n_objects == 1:
             scaler = scalers[0]
             if scaler is not None:
@@ -443,7 +467,9 @@ class MLHdf5Iterator(Hdf5Iterator):
                     X_i = X[:, i, :]
                     pad_value = self.selection[dataset_name].pad_value
 
-                    if pad_value is not None:
+                    if pad_value is not None and scale_categ_padding and not is_numer:
+                        X_objects.append(scaler.transform(X_i))
+                    elif pad_value is not None:
                         mask = padding_mask(X_i, pad_value)
 
                         X_full = np.full_like(X_i, pad_value)
@@ -504,16 +530,16 @@ class MLHdf5Iterator(Hdf5Iterator):
 
             if X_numer_dataset_stack is not None and X_categ_dataset_stack is not None:
                 X_dataset_stack = np.concatenate([X_numer_dataset_stack, X_categ_dataset_stack], axis=-1)
-                numer_idx = np.arange(numer_shape[1])
-                categ_idx = np.arange(numer_shape[1], numer_shape[1] + categ_shape[1])
+                numer_idx = np.arange(numer_shape[-1])
+                categ_idx = np.arange(numer_shape[-1], numer_shape[-1] + categ_shape[-1])
 
             elif X_numer_dataset_stack is not None:
                 X_dataset_stack = X_numer_dataset_stack
-                categ_idx, numer_idx = None, np.arange(X_numer_dataset_stack.shape[1])
+                categ_idx, numer_idx = None, np.arange(numer_shape[-1])
 
             elif X_categ_dataset_stack is not None:
                 X_dataset_stack = X_categ_dataset_stack
-                categ_idx, numer_idx = np.arange(X_categ_dataset_stack.shape[1]), None
+                categ_idx, numer_idx = np.arange(categ_shape[-1]), None
 
             else:
                 raise RuntimeError("Both X_numer and X_categ are None!")
@@ -629,10 +655,24 @@ def events_collate_fn(batch: Any) -> WeightedBatchType:
     return ds.X, ds.y, ds.w, ds.y_aux, reports
 
 
-def default_setup_func(stacked_datasets: StackedDatasets, ml_iterator: MLHdf5Iterator) -> WeightedDatasetBatch:
+def full_collate_fn(batch: Any) -> Any:
+    datasets_batch, reports = batch[0].make_batch(), batch[1]
+    return datasets_batch, reports
+
+
+def default_setup_func(stacked_datasets: StackedDatasets, ml_iterator: MLHdf5Iterator) -> WeightedDatasetBatch | None:
     weighted_datase_batch = WeightedDatasetBatch()
 
-    for ds_name, ds in stacked_datasets.items():
+    dataset_keys = stacked_datasets.keys()
+    if "events" in dataset_keys:
+        dataset_keys.remove("events")
+        dataset_keys.insert(0, "events")
+
+    mask_unmapped: np.ndarray | None = None
+
+    for ds_name in dataset_keys:
+        ds = stacked_datasets[ds_name]
+
         X = ds.X.astype(np.float32)
         y = ds.get_extra("label_type", None)
         w = ds.get_extra("weights", None)
@@ -643,18 +683,14 @@ def default_setup_func(stacked_datasets: StackedDatasets, ml_iterator: MLHdf5Ite
             if remap_labels is not None:
                 max_label = ml_iterator.dataset_kwargs["max_label"]
                 y, mask_unmapped = remap_labels_lookup(y, max_label, remap_labels)
-                X = X[mask_unmapped]
-                if w is not None:
-                    w = w[mask_unmapped]
 
-        if ml_iterator.shuffle:
-            shuffle_idx = np.random.permutation(len(X))
-            X[:] = X[shuffle_idx]
+            if y.shape[0] == 0:
+                return None
 
-            if y is not None:
-                y[:] = y[shuffle_idx]
+        if mask_unmapped is not None:
+            X = X[mask_unmapped]
             if w is not None:
-                w[:] = w[shuffle_idx]
+                w = w[mask_unmapped]
 
         weighted_datase_batch[ds_name] = WeightedBatch(X, y, w, y_aux)
 

{f9columnar-0.3.2 → f9columnar-0.3.4}/f9columnar/processors_collection.py

@@ -28,19 +28,26 @@ class ProcessorsCollection:
     def __getitem__(self, name: str) -> Processor:
         return self.objects[name]
 
+    def _add_processor(self, processor: Processor) -> None:
+        # Check if processor being added is unique
+        if processor in self.objects.values():
+            raise ValueError(f"{processor.name} already exists in the {self.collection_name} collection!")
+
+        # Check if name of unique processor being added is unique
+        if processor.name in self.objects:
+            raise ValueError(
+                f'Processor with name "{processor.name}" already exists in the {self.collection_name} collection! Choose a unique name.'
+            )
+
+        self.objects[processor.name] = processor
+
     def add(self, *objs: Processor | ProcessorsCollection) -> ProcessorsCollection:
         for obj in objs:
             if isinstance(obj, ProcessorsCollection):
                 for v in obj.objects.values():
-                    if v in self.objects:
-                        raise ValueError(f"{v.name} already exists in the {self.collection_name} collection!")
-                    else:
-                        self.objects[v.name] = v
+                    self._add_processor(v)
             elif isinstance(obj, Processor):
-                if obj in self.objects:
-                    raise ValueError(f"{obj.name} already exists in the {self.collection_name} collection!")
-                else:
-                    self.objects[obj.name] = obj
+                self._add_processor(obj)
             else:
                 raise ValueError(f"Invalid object type {type(obj)}!")
 

{f9columnar-0.3.2 → f9columnar-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "f9columnar"
-version = "0.3.2"
+version = "0.3.4"
 description = "Columnar analysis utils."
 authors = ["Jan Gavranovic <jan.gavranovic@cern.ch>"]
 readme = "README.md"
@@ -9,7 +9,7 @@ license = "MIT"
 
 [tool.poetry.dependencies]
 python = ">=3.10,<3.13"
-torch = { version = "2.7.0", optional = true }
+torch = { version = "2.8.0", optional = true }
 numpy = "^2.0.2"
 pandas = "^2.2.2"
 scipy = "^1.14.1"