tirex-mirror 2025.11.28__tar.gz → 2025.12.2__tar.gz

{tirex_mirror-2025.11.28 → tirex_mirror-2025.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tirex-mirror
-Version: 2025.11.28
+Version: 2025.12.2
 Summary: Unofficial mirror of NX-AI/tirex for packaging
 Author-email: Arpad Rozsas <rozsasarpi@gmail.com>
 License: NXAI COMMUNITY LICENSE AGREEMENT
@@ -55,7 +55,7 @@ License: NXAI COMMUNITY LICENSE AGREEMENT
         
 Project-URL: Repository, https://github.com/rozsasarpi/tirex-mirror
 Project-URL: Issues, https://github.com/rozsasarpi/tirex-mirror/issues
-Keywords: TiRex,xLSTM,Time Series,Zero-shot,Deep Learning
+Keywords: TiRex,xLSTM,Time Series,Zero-shot,Deep Learning,Classification,Timeseries-Classification
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
@@ -86,6 +86,7 @@ Requires-Dist: fev>=0.6.0; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Provides-Extra: classification
 Requires-Dist: scikit-learn; extra == "classification"
+Requires-Dist: lightgbm[scikit-learn]; extra == "classification"
 Provides-Extra: all
 Requires-Dist: xlstm; extra == "all"
 Requires-Dist: ninja; extra == "all"
@@ -98,6 +99,7 @@ Requires-Dist: datasets; extra == "all"
 Requires-Dist: pytest; extra == "all"
 Requires-Dist: fev>=0.6.0; extra == "all"
 Requires-Dist: scikit-learn; extra == "all"
+Requires-Dist: lightgbm[scikit-learn]; extra == "all"
 Dynamic: license-file
 
 # tirex-mirror

{tirex_mirror-2025.11.28 → tirex_mirror-2025.12.2}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "tirex-mirror"
-version = "2025.11.28"
+version = "2025.12.02"
 description = "Unofficial mirror of NX-AI/tirex for packaging"
 readme = "README.md"
 requires-python = ">=3.11"
 classifiers = [ "Programming Language :: Python :: 3", "Operating System :: OS Independent",]
-keywords = [ "TiRex", "xLSTM", "Time Series", "Zero-shot", "Deep Learning",]
+keywords = [ "TiRex", "xLSTM", "Time Series", "Zero-shot", "Deep Learning", "Classification", "Timeseries-Classification",]
 dependencies = [ "torch", "huggingface-hub", "numpy",]
 [[project.authors]]
 name = "Arpad Rozsas"
@@ -29,8 +29,8 @@ plotting = [ "matplotlib",]
 gluonts = [ "gluonts", "pandas",]
 hfdataset = [ "datasets",]
 test = [ "fev>=0.6.0", "pytest",]
-classification = [ "scikit-learn",]
-all = [ "xlstm", "ninja", "ipykernel", "matplotlib", "pandas", "python-dotenv", "gluonts", "datasets", "pytest", "fev>=0.6.0", "scikit-learn",]
+classification = [ "scikit-learn", "lightgbm[scikit-learn]",]
+all = [ "xlstm", "ninja", "ipykernel", "matplotlib", "pandas", "python-dotenv", "gluonts", "datasets", "pytest", "fev>=0.6.0", "scikit-learn", "lightgbm[scikit-learn]",]
 
 [tool.docformatter]
 diff = false

tirex_mirror-2025.12.2/src/tirex/models/classification/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) NXAI GmbH.
+# This software may be used and distributed according to the terms of the NXAI Community License Agreement.
+
+from .heads.gbm_classifier import TirexGBMClassifier
+from .heads.linear_classifier import TirexClassifierTorch
+from .heads.rf_classifier import TirexRFClassifier
+
+__all__ = ["TirexClassifierTorch", "TirexRFClassifier", "TirexGBMClassifier"]

{tirex_mirror-2025.11.28 → tirex_mirror-2025.12.2}/src/tirex/models/classification/embedding.py

@@ -1,6 +1,6 @@
-import inspect
+# Copyright (c) NXAI GmbH.
+# This software may be used and distributed according to the terms of the NXAI Community License Agreement.
 
-import numpy as np
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -11,7 +11,9 @@ from .utils import nanmax, nanmin, nanstd
 
 
 class TiRexEmbedding(nn.Module):
-    def __init__(self, device: str | None = None, data_augmentation: bool = False, batch_size: int = 512) -> None:
+    def __init__(
+        self, device: str | None = None, data_augmentation: bool = False, batch_size: int = 512, compile: bool = False
+    ) -> None:
         super().__init__()
         self.data_augmentation = data_augmentation
         self.number_of_patches = 8
@@ -20,8 +22,9 @@ class TiRexEmbedding(nn.Module):
         if device is None:
             device = "cuda" if torch.cuda.is_available() else "cpu"
         self.device = device
+        self._compile = compile
 
-        self.model = load_model(path="NX-AI/TiRex", device=self.device)
+        self.model = load_model(path="NX-AI/TiRex", device=self.device, compile=self._compile)
 
     def _gen_emb_batched(self, data: torch.Tensor) -> torch.Tensor:
         batches = list(torch.split(data, self.batch_size))

tirex_mirror-2025.12.2/src/tirex/models/classification/heads/base_classifier.py

@@ -0,0 +1,93 @@
+# Copyright (c) NXAI GmbH.
+# This software may be used and distributed according to the terms of the NXAI Community License Agreement.
+
+from abc import ABC, abstractmethod
+
+import torch
+
+from ..embedding import TiRexEmbedding
+
+
+class BaseTirexClassifier(ABC):
+    """Abstract base class for TiRex classification models.
+
+    This base class provides common functionality for all TiRex classifiers,
+    including embedding model initialization and a consistent interface.
+
+    """
+
+    def __init__(
+        self, data_augmentation: bool = False, device: str | None = None, compile: bool = False, batch_size: int = 512
+    ) -> None:
+        """Initializes a TiRex classification model.
+
+        Args:
+            data_augmentation : bool
+                Whether to use data_augmentation for embeddings (sample statistics and first-order differences of the original data). Default: False
+            device : str | None
+                Device to run the embedding model on. If None, uses CUDA if available, else CPU. Default: None
+            compile: bool
+                Whether to compile the frozen embedding model. Default: False
+            batch_size : int
+                Batch size for embedding calculations. Default: 512
+        """
+
+        # Set device
+        if device is None:
+            device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        self.device = device
+        self._compile = compile
+
+        self.batch_size = batch_size
+        self.data_augmentation = data_augmentation
+        self.emb_model = TiRexEmbedding(
+            device=self.device,
+            data_augmentation=self.data_augmentation,
+            batch_size=self.batch_size,
+            compile=self._compile,
+        )
+
+    @abstractmethod
+    def fit(self, train_data: tuple[torch.Tensor, torch.Tensor]) -> None:
+        pass
+
+    @torch.inference_mode()
+    def predict(self, x: torch.Tensor) -> torch.Tensor:
+        """Predict class labels for input time series data.
+
+        Args:
+            x: Input time series data as torch.Tensor with shape
+                (batch_size, num_variates, seq_len).
+        Returns:
+            torch.Tensor: Predicted class labels with shape (batch_size,).
+        """
+        self.emb_model.eval()
+        x = x.to(self.device)
+        embeddings = self.emb_model(x).cpu().numpy()
+        return torch.from_numpy(self.head.predict(embeddings)).long()
+
+    @torch.inference_mode()
+    def predict_proba(self, x: torch.Tensor) -> torch.Tensor:
+        """Predict class probabilities for input time series data.
+
+        Args:
+            x: Input time series data as torch.Tensor with shape
+                (batch_size, num_variates, seq_len).
+        Returns:
+            torch.Tensor: Class probabilities with shape (batch_size, num_classes).
+        """
+        self.emb_model.eval()
+        x = x.to(self.device)
+        embeddings = self.emb_model(x).cpu().numpy()
+        return torch.from_numpy(self.head.predict_proba(embeddings))
+
+    @abstractmethod
+    def save_model(self, path: str) -> None:
+        """Saving model abstract method"""
+        pass
+
+    @classmethod
+    @abstractmethod
+    def load_model(cls, path: str):
+        """Loading model abstract method"""
+        pass

tirex_mirror-2025.12.2/src/tirex/models/classification/heads/gbm_classifier.py

@@ -0,0 +1,210 @@
+# Copyright (c) NXAI GmbH.
+# This software may be used and distributed according to the terms of the NXAI Community License Agreement.
+
+import joblib
+import torch
+from lightgbm import LGBMClassifier, early_stopping
+
+from ..utils import train_val_split
+from .base_classifier import BaseTirexClassifier
+
+
+class TirexGBMClassifier(BaseTirexClassifier):
+    """
+    A Gradient Boosting classifier that uses time series embeddings as features.
+
+    This classifier combines a pre-trained embedding model for feature extraction with a
+    Gradient Boosting classifier.
+
+    Example:
+        >>> from tirex.models.classification import TirexGBMClassifier
+        >>>
+        >>> # Create model with custom LightGBM parameters
+        >>> model = TirexGBMClassifier(
+        ...     data_augmentation=True,
+        ...     n_estimators=50,
+        ...     random_state=42
+        ... )
+        >>>
+        >>> # Prepare data (can use NumPy arrays or PyTorch tensors)
+        >>> X_train = torch.randn(100, 1, 128)  # 100 samples, 1 number of variates, 128 sequence length
+        >>> y_train = torch.randint(0, 3, (100,))  # 3 classes
+        >>>
+        >>> # Train the model
+        >>> model.fit((X_train, y_train))
+        >>>
+        >>> # Make predictions
+        >>> X_test = torch.randn(20, 1, 128)
+        >>> predictions = model.predict(X_test)
+        >>> probabilities = model.predict_proba(X_test)
+    """
+
+    def __init__(
+        self,
+        data_augmentation: bool = False,
+        device: str | None = None,
+        compile: bool = False,
+        batch_size: int = 512,
+        early_stopping_rounds: int | None = 10,
+        min_delta: float = 0.0,
+        val_split_ratio: float = 0.2,
+        stratify: bool = True,
+        # LightGBM kwargs
+        **lgbm_kwargs,
+    ) -> None:
+        """Initializes Embedding Based Gradient Boosting Classification model.
+
+        Args:
+            data_augmentation : bool
+                Whether to use data_augmentation for embeddings (sample statistics and first-order differences of the original data). Default: False
+            device : str | None
+                Device to run the embedding model on. If None, uses CUDA if available, else CPU. Default: None
+            compile: bool
+                Whether to compile the frozen embedding model. Default: False
+            batch_size : int
+                Batch size for embedding calculations. Default: 512
+            early_stopping_rounds: int | None
+                Number of rounds without improvement of all metrics for Early Stopping. Default: 10
+            min_delta: float
+                Minimum improvement in score to keep training. Default 0.0
+            val_split_ratio : float
+                Proportion of training data to use for validation, if validation data are not provided. Default: 0.2
+            stratify : bool
+                Whether to stratify the train/validation split by class labels. Default: True
+            **lgbm_kwargs
+                Additional keyword arguments to pass to LightGBM's LGBMClassifier.
+                Common options include n_estimators, max_depth, learning_rate, random_state, etc.
+        """
+        super().__init__(data_augmentation=data_augmentation, device=device, compile=compile, batch_size=batch_size)
+
+        # Early Stopping callback
+        self.early_stopping_rounds = early_stopping_rounds
+        self.min_delta = min_delta
+
+        # Data split parameters:
+        self.val_split_ratio = val_split_ratio
+        self.stratify = stratify
+
+        # Extract random_state for train_val_split if provided
+        self.random_state = lgbm_kwargs.get("random_state", None)
+
+        self.head = LGBMClassifier(**lgbm_kwargs)
+
+    @torch.inference_mode()
+    def fit(
+        self,
+        train_data: tuple[torch.Tensor, torch.Tensor],
+        val_data: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> None:
+        """Train the LightGBM classifier on embedded time series data.
+
+        This method generates embeddings for the training data using the embedding
+        model, then trains the LightGBM classifier on these embeddings.
+
+        Args:
+            train_data: Tuple of (X_train, y_train) where X_train is the input time
+                series data (torch.Tensor) and y_train is a torch.Tensor
+                of class labels.
+            val_data: Optional tuple of (X_val, y_val) for validation where X_train is the input time
+                series data (torch.Tensor) and y_train is a torch.Tensor
+                of class labels. If None, validation data will be automatically split from train_data (20% split).
+        """
+
+        (X_train, y_train), (X_val, y_val) = self._create_train_val_datasets(
+            train_data=train_data,
+            val_data=val_data,
+            val_split_ratio=self.val_split_ratio,
+            stratify=self.stratify,
+            seed=self.random_state,
+        )
+
+        self.emb_model.eval()
+        X_train = X_train.to(self.device)
+        X_val = X_val.to(self.device)
+        embeddings_train = self.emb_model(X_train).cpu().numpy()
+        embeddings_val = self.emb_model(X_val).cpu().numpy()
+
+        y_train = y_train.detach().cpu().numpy() if isinstance(y_train, torch.Tensor) else y_train
+        y_val = y_val.detach().cpu().numpy() if isinstance(y_val, torch.Tensor) else y_val
+
+        self.head.fit(
+            embeddings_train,
+            y_train,
+            eval_set=[(embeddings_val, y_val)],
+            callbacks=[early_stopping(stopping_rounds=self.early_stopping_rounds, min_delta=self.min_delta)]
+            if self.early_stopping_rounds is not None
+            else None,
+        )
+
+    def save_model(self, path: str) -> None:
+        """This method saves the trained LightGBM classifier head (joblib format) and embedding information.
+
+        Args:
+            path: File path where the model should be saved (e.g., 'model.joblib').
+        """
+
+        payload = {
+            "data_augmentation": self.data_augmentation,
+            "compile": self._compile,
+            "batch_size": self.batch_size,
+            "early_stopping_rounds": self.early_stopping_rounds,
+            "min_delta": self.min_delta,
+            "val_split_ratio": self.val_split_ratio,
+            "stratify": self.stratify,
+            "head": self.head,
+        }
+        joblib.dump(payload, path)
+
+    @classmethod
+    def load_model(cls, path: str) -> "TirexGBMClassifier":
+        """Load a saved model from file.
+
+        This reconstructs the model with the embedding configuration and loads
+        the trained LightGBM classifier from a checkpoint file created by save_model().
+
+        Args:
+            path: File path to the saved model checkpoint.
+        Returns:
+            TirexGBMClassifier: The loaded model with trained Gradient Boosting, ready for inference.
+        """
+        checkpoint = joblib.load(path)
+
+        # Create new instance with saved configuration
+        model = cls(
+            data_augmentation=checkpoint["data_augmentation"],
+            compile=checkpoint["compile"],
+            batch_size=checkpoint["batch_size"],
+            early_stopping_rounds=checkpoint["early_stopping_rounds"],
+            min_delta=checkpoint["min_delta"],
+            val_split_ratio=checkpoint["val_split_ratio"],
+            stratify=checkpoint["stratify"],
+        )
+
+        # Load the trained LightGBM head
+        model.head = checkpoint["head"]
+
+        # Extract random_state from the loaded head if available
+        model.random_state = getattr(model.head, "random_state", None)
+
+        return model
+
+    def _create_train_val_datasets(
+        self,
+        train_data: tuple[torch.Tensor, torch.Tensor],
+        val_data: tuple[torch.Tensor, torch.Tensor] | None = None,
+        val_split_ratio: float = 0.2,
+        stratify: bool = True,
+        seed: int | None = None,
+    ) -> tuple[tuple[torch.Tensor, torch.Tensor], tuple[torch.Tensor, torch.Tensor]]:
+        X_train, y_train = train_data
+
+        if val_data is None:
+            train_data, val_data = train_val_split(
+                train_data=train_data, val_split_ratio=val_split_ratio, stratify=stratify, seed=seed
+            )
+            X_train, y_train = train_data
+            X_val, y_val = val_data
+        else:
+            X_val, y_val = val_data
+
+        return (X_train, y_train), (X_val, y_val)

{tirex_mirror-2025.11.28/src/tirex/models/classification → tirex_mirror-2025.12.2/src/tirex/models/classification/heads}/linear_classifier.py

@@ -1,12 +1,15 @@
+# Copyright (c) NXAI GmbH.
+# This software may be used and distributed according to the terms of the NXAI Community License Agreement.
+
 from dataclasses import asdict
 
 import torch
 
-from .embedding import TiRexEmbedding
-from .trainer import TrainConfig, Trainer
+from ..trainer import TrainConfig, Trainer
+from .base_classifier import BaseTirexClassifier
 
 
-class TirexClassifierTorch(torch.nn.Module):
+class TirexClassifierTorch(BaseTirexClassifier, torch.nn.Module):
     """
     A PyTorch classifier that combines time series embeddings with a linear classification head.
 
@@ -18,7 +21,7 @@ class TirexClassifierTorch(torch.nn.Module):
         >>> import torch
         >>> from tirex.models.classification import TirexClassifierTorch
         >>>
-        >>> # Create model with TIREX embeddings
+        >>> # Create model with TiRex embeddings
         >>> model = TirexClassifierTorch(
         ...     data_augmentation=True,
         ...     max_epochs=2,
@@ -43,8 +46,9 @@ class TirexClassifierTorch(torch.nn.Module):
         self,
         data_augmentation: bool = False,
         device: str | None = None,
+        compile: bool = False,
         # Training parameters
-        max_epochs: int = 50,
+        max_epochs: int = 10,
         lr: float = 1e-4,
         weight_decay: float = 0.01,
         batch_size: int = 512,
@@ -62,9 +66,11 @@ class TirexClassifierTorch(torch.nn.Module):
 
         Args:
             data_augmentation : bool | None
-                Whether to use data_augmentation for embeddings (stats and first-order differences of the original data). Default: False
+                Whether to use data_augmentation for embeddings (sample statistics and first-order differences of the original data). Default: False
             device : str | None
-                Device to run the model on. If None, uses CUDA if available, else CPU. Default: None
+                Device to run the embedding model on. If None, uses CUDA if available, else CPU. Default: None
+            compile: bool
+                Whether to compile the frozen embedding model. Default: False
             max_epochs : int
                 Maximum number of training epochs. Default: 50
             lr : float
@@ -91,15 +97,9 @@ class TirexClassifierTorch(torch.nn.Module):
                 Dropout probability for the classification head. If None, no dropout is used. Default: None
         """
 
-        super().__init__()
-
-        if device is None:
-            device = "cuda:0" if torch.cuda.is_available() else "cpu"
-        self.device = device
+        torch.nn.Module.__init__(self)
 
-        # Create embedding model
-        self.emb_model = TiRexEmbedding(device=self.device, data_augmentation=data_augmentation, batch_size=batch_size)
-        self.data_augmentation = data_augmentation
+        super().__init__(data_augmentation=data_augmentation, device=device, compile=compile, batch_size=batch_size)
 
         # Head parameters
         self.dropout = dropout
@@ -221,6 +221,7 @@ class TirexClassifierTorch(torch.nn.Module):
             {
                 "head_state_dict": self.head.state_dict(),  # need to save only head, embedding is frozen
                 "data_augmentation": self.data_augmentation,
+                "compile": self._compile,
                 "emb_dim": self.emb_dim,
                 "num_classes": self.num_classes,
                 "dropout": self.dropout,
@@ -248,6 +249,7 @@ class TirexClassifierTorch(torch.nn.Module):
 
         model = cls(
             data_augmentation=checkpoint["data_augmentation"],
+            compile=checkpoint["compile"],
             dropout=checkpoint["dropout"],
             max_epochs=train_config_dict.get("max_epochs", 50),
             lr=train_config_dict.get("lr", 1e-4),

{tirex_mirror-2025.11.28/src/tirex/models/classification → tirex_mirror-2025.12.2/src/tirex/models/classification/heads}/rf_classifier.py

@@ -1,12 +1,14 @@
+# Copyright (c) NXAI GmbH.
+# This software may be used and distributed according to the terms of the NXAI Community License Agreement.
+
 import joblib
-import numpy as np
 import torch
 from sklearn.ensemble import RandomForestClassifier
 
-from .embedding import TiRexEmbedding
+from .base_classifier import BaseTirexClassifier
 
 
-class TirexRFClassifier:
+class TirexRFClassifier(BaseTirexClassifier):
     """
     A Random Forest classifier that uses time series embeddings as features.
 
@@ -15,7 +17,6 @@ class TirexRFClassifier:
     time series, which are then used to train the Random Forest.
 
     Example:
-        >>> import numpy as np
         >>> from tirex.models.classification import TirexRFClassifier
         >>>
         >>> # Create model with custom Random Forest parameters
@@ -43,6 +44,7 @@ class TirexRFClassifier:
         self,
         data_augmentation: bool = False,
         device: str | None = None,
+        compile: bool = False,
         batch_size: int = 512,
         # Random Forest parameters
         **rf_kwargs,
@@ -51,24 +53,18 @@ class TirexRFClassifier:
 
         Args:
             data_augmentation : bool
-                Whether to use data_augmentation for embeddings (stats and first-order differences of the original data). Default: False
+                Whether to use data_augmentation for embeddings (sample statistics and first-order differences of the original data). Default: False
             device : str | None
                 Device to run the embedding model on. If None, uses CUDA if available, else CPU. Default: None
+            compile: bool
+                Whether to compile the frozen embedding model. Default: False
             batch_size : int
                 Batch size for embedding calculations. Default: 512
             **rf_kwargs
                 Additional keyword arguments to pass to sklearn's RandomForestClassifier.
                 Common options include n_estimators, max_depth, min_samples_split, random_state, etc.
         """
-
-        # Set device
-        if device is None:
-            device = "cuda:0" if torch.cuda.is_available() else "cpu"
-        self.device = device
-
-        self.emb_model = TiRexEmbedding(device=self.device, data_augmentation=data_augmentation, batch_size=batch_size)
-        self.data_augmentation = data_augmentation
-
+        super().__init__(data_augmentation=data_augmentation, device=device, compile=compile, batch_size=batch_size)
         self.head = RandomForestClassifier(**rf_kwargs)
 
     @torch.inference_mode()
@@ -80,7 +76,7 @@ class TirexRFClassifier:
 
         Args:
             train_data: Tuple of (X_train, y_train) where X_train is the input time
-                series data (torch.Tensor) and y_train is a numpy array
+                series data (torch.Tensor) and y_train is a torch.Tensor
                 of class labels.
         """
         X_train, y_train = train_data
@@ -88,36 +84,11 @@ class TirexRFClassifier:
         if isinstance(y_train, torch.Tensor):
             y_train = y_train.detach().cpu().numpy()
 
+        self.emb_model.eval()
+        X_train = X_train.to(self.device)
         embeddings = self.emb_model(X_train).cpu().numpy()
         self.head.fit(embeddings, y_train)
 
-    @torch.inference_mode()
-    def predict(self, x: torch.Tensor) -> torch.Tensor:
-        """Predict class labels for input time series data.
-
-        Args:
-            x: Input time series data as torch.Tensor or np.ndarray with shape
-                (batch_size, num_variates, seq_len).
-        Returns:
-            torch.Tensor: Predicted class labels with shape (batch_size,).
-        """
-
-        embeddings = self.emb_model(x).cpu().numpy()
-        return torch.from_numpy(self.head.predict(embeddings)).long()
-
-    @torch.inference_mode()
-    def predict_proba(self, x: torch.Tensor) -> torch.Tensor:
-        """Predict class probabilities for input time series data.
-
-        Args:
-            x: Input time series data as torch.Tensor or np.ndarray with shape
-                (batch_size, num_variates, seq_len).
-        Returns:
-            torch.Tensor: Class probabilities with shape (batch_size, num_classes).
-        """
-        embeddings = self.emb_model(x).cpu().numpy()
-        return torch.from_numpy(self.head.predict_proba(embeddings))
-
     def save_model(self, path: str) -> None:
         """This method saves the trained Random Forest classifier head and embedding information in joblib format
 
@@ -126,6 +97,8 @@ class TirexRFClassifier:
         """
         payload = {
             "data_augmentation": self.data_augmentation,
+            "compile": self._compile,
+            "batch_size": self.batch_size,
             "head": self.head,
         }
         joblib.dump(payload, path)
@@ -147,6 +120,8 @@ class TirexRFClassifier:
         # Create new instance with saved configuration
         model = cls(
             data_augmentation=checkpoint["data_augmentation"],
+            compile=checkpoint["compile"],
+            batch_size=checkpoint["batch_size"],
         )
 
         # Load the trained Random Forest head

{tirex_mirror-2025.11.28 → tirex_mirror-2025.12.2}/src/tirex/models/classification/trainer.py

@@ -1,3 +1,6 @@
+# Copyright (c) NXAI GmbH.
+# This software may be used and distributed according to the terms of the NXAI Community License Agreement.
+
 from dataclasses import dataclass
 
 import torch

{tirex_mirror-2025.11.28 → tirex_mirror-2025.12.2}/src/tirex/models/classification/utils.py

@@ -1,3 +1,6 @@
+# Copyright (c) NXAI GmbH.
+# This software may be used and distributed according to the terms of the NXAI Community License Agreement.
+
 import numpy as np
 import torch
 from sklearn.model_selection import train_test_split

{tirex_mirror-2025.11.28 → tirex_mirror-2025.12.2}/src/tirex_mirror.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tirex-mirror
-Version: 2025.11.28
+Version: 2025.12.2
 Summary: Unofficial mirror of NX-AI/tirex for packaging
 Author-email: Arpad Rozsas <rozsasarpi@gmail.com>
 License: NXAI COMMUNITY LICENSE AGREEMENT
@@ -55,7 +55,7 @@ License: NXAI COMMUNITY LICENSE AGREEMENT
         
 Project-URL: Repository, https://github.com/rozsasarpi/tirex-mirror
 Project-URL: Issues, https://github.com/rozsasarpi/tirex-mirror/issues
-Keywords: TiRex,xLSTM,Time Series,Zero-shot,Deep Learning
+Keywords: TiRex,xLSTM,Time Series,Zero-shot,Deep Learning,Classification,Timeseries-Classification
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
@@ -86,6 +86,7 @@ Requires-Dist: fev>=0.6.0; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Provides-Extra: classification
 Requires-Dist: scikit-learn; extra == "classification"
+Requires-Dist: lightgbm[scikit-learn]; extra == "classification"
 Provides-Extra: all
 Requires-Dist: xlstm; extra == "all"
 Requires-Dist: ninja; extra == "all"
@@ -98,6 +99,7 @@ Requires-Dist: datasets; extra == "all"
 Requires-Dist: pytest; extra == "all"
 Requires-Dist: fev>=0.6.0; extra == "all"
 Requires-Dist: scikit-learn; extra == "all"
+Requires-Dist: lightgbm[scikit-learn]; extra == "all"
 Dynamic: license-file
 
 # tirex-mirror