deep-river 0.3.2__tar.gz → 0.3.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deep_river
-Version: 0.3.2
+Version: 0.3.4
 Summary: Online Deep Learning for river
 Author-email: Cedric Kulbach <cedric.kulbach@googlemail.com>, Lucas Cazzonelli <Cazzonelli@fzi.de>, Hoang-Anh Ngo <hoang-anh.ngo@alumni.polytechnique.org>, Max Halford <maxhalford25@gmail.com>, Saulo Martiello Mastelini <saulomastelini@gmail.com>
 License: BSD-3-Clause
@@ -8,71 +8,28 @@ Project-URL: Homepage, https://github.com/online-ml/deep-river
 Project-URL: Repository, https://github.com/online-ml/deep-river
 Project-URL: Documentation, https://github.com/online-ml/deep-river
 Keywords: online-learning,deep-learning,data-streams
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: <3.13,>=3.10
+Requires-Python: <3.13,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: scikit-learn~=1.5.0
-Requires-Dist: torch==2.2.2
-Requires-Dist: pandas~=2.2.2
-Requires-Dist: numpy~=1.26.4
-Requires-Dist: river
+Requires-Dist: numpy<3,>=2.3.4
+Requires-Dist: pandas<3,>=2.2
+Requires-Dist: river<0.26,>=0.25
+Requires-Dist: scikit-learn<2,>=1.5.1
+Requires-Dist: sortedcontainers>=2.4.0
+Requires-Dist: torch==2.2.2; sys_platform == "darwin" and platform_machine == "x86_64"
+Requires-Dist: torch<2.6,>=2.5; sys_platform != "darwin" or platform_machine != "x86_64"
 Requires-Dist: tqdm~=4.66.5
 Requires-Dist: torchviz~=0.0.2
-Requires-Dist: mkdocstrings[python]>=0.19.0
-Requires-Dist: pytkdocs[numpy-style]>=0.5.0
-Requires-Dist: sortedcontainers>=2.4.0
-Provides-Extra: dev
-Requires-Dist: graphviz>=0.20.3; extra == "dev"
-Requires-Dist: matplotlib>=3.9.2; extra == "dev"
-Requires-Dist: mypy>=1.11.1; extra == "dev"
-Requires-Dist: codecov>=2.1.13; extra == "dev"
-Requires-Dist: pre-commit>=3.8.0; extra == "dev"
-Requires-Dist: pytest>=8.3.2; extra == "dev"
-Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
-Requires-Dist: black>=24.8.0; extra == "dev"
-Requires-Dist: flake8>=7.1.1; extra == "dev"
-Requires-Dist: isort>=5.13.2; extra == "dev"
-Requires-Dist: jupyter>=1.0.0; extra == "dev"
-Requires-Dist: pyupgrade==3.17.0; extra == "dev"
-Requires-Dist: flask>=3.0.2; extra == "dev"
-Requires-Dist: ipykernel>=6.9.0; extra == "dev"
-Requires-Dist: mike>=0.5.3; extra == "dev"
-Requires-Dist: mkdocs>=1.2.3; extra == "dev"
-Requires-Dist: mkdocs-awesome-pages-plugin>=2.7.0; extra == "dev"
-Requires-Dist: mkdocs-gen-files>=0.3.5; extra == "dev"
-Requires-Dist: mkdocs-charts-plugin>=0.0.8; extra == "dev"
-Requires-Dist: mkdocs-literate-nav>=0.4.1; extra == "dev"
-Requires-Dist: mkdocs-material>=8.1.11; extra == "dev"
-Requires-Dist: ipython_genutils>=0.1.0; extra == "dev"
-Requires-Dist: mkdocs-jupyter>=0.20.0; extra == "dev"
-Requires-Dist: nbconvert>=6.4.2; extra == "dev"
-Requires-Dist: jupyter_contrib_nbextensions==0.7.0; extra == "dev"
-Requires-Dist: numpydoc>=1.2; extra == "dev"
-Requires-Dist: notebook==6.4.3; extra == "dev"
-Requires-Dist: spacy>=3.2.2; extra == "dev"
-Requires-Dist: jinja2>=3.0.3; extra == "dev"
-Requires-Dist: dominate; extra == "dev"
-Requires-Dist: jupyter-client; extra == "dev"
-Requires-Dist: python-slugify; extra == "dev"
-Requires-Dist: watermark==2.3.1; extra == "dev"
-Requires-Dist: plotly>=5.0.0; extra == "dev"
 Dynamic: license-file
 
 <p align="center">
-  <img height="150px" src="https://raw.githubusercontent.com/online-ml/deep-river/master/docs/img/logo.png" alt="incremental dl logo">
+  <img height="150px" src="https://raw.githubusercontent.com/online-ml/deep-river/main/docs/img/logo.png" alt="incremental dl logo">
 </p>
 <p align="center">
     <img alt="PyPI" src="https://img.shields.io/pypi/v/deep-river">
     <!-- Single Coverage Badge (Shields.io) -->
     <a href="https://app.codecov.io/gh/online-ml/deep-river" >
-        <img alt="Coverage" src="https://img.shields.io/codecov/c/github/online-ml/deep-river?branch=master&logo=codecov&label=coverage" />
+        <img alt="Coverage" src="https://img.shields.io/codecov/c/github/online-ml/deep-river?branch=main&logo=codecov&label=coverage" />
     </a>
     <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/deep-river">
     <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/deep-river">
@@ -88,7 +45,7 @@ Dynamic: license-file
 
 ## 📚 [Documentation](https://online-ml.github.io/deep-river/)
 The [documentation](https://online-ml.github.io/deep-river/) contains an overview of all features of this repository as well as the repository's full features list. 
-In each of these, the git repo reference is listed in a section that shows [examples](https://github.com/online-ml/deep-river/blob/master/docs/examples) of the features and functionality.
+In each of these, the git repo reference is listed in a section that shows [examples](https://github.com/online-ml/deep-river/blob/main/docs/examples) of the features and functionality.
 As we are always looking for further use cases and examples, feel free to contribute to the documentation or the repository itself via a pull request
 
 ## 💈 Installation
@@ -103,7 +60,7 @@ pip install "river[deep]"
 You can install the latest development version from GitHub as so:
 
 ```shell
-pip install https://github.com/online-ml/deep-river/archive/refs/heads/master.zip
+pip install https://github.com/online-ml/deep-river/archive/refs/heads/main.zip
 ```
 
 ### Development Environment
@@ -316,7 +273,7 @@ To acknowledge the use of the `DeepRiver` library in your research, please refer
 ## 🏫 Affiliations
 
 <p align="center">
-    <img src="https://upload.wikimedia.org/wikipedia/de/thumb/4/44/Fzi_logo.svg/1200px-Fzi_logo.svg.png?raw=true" alt="FZI Logo" height="200"/>
+    <img src="https://upload.wikimedia.org/wikipedia/de/4/44/Fzi_logo.svg" alt="FZI Logo" height="200"/>
 </p>
 
 <p align="center">

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

@@ -1,11 +1,11 @@
 <p align="center">
-  <img height="150px" src="https://raw.githubusercontent.com/online-ml/deep-river/master/docs/img/logo.png" alt="incremental dl logo">
+  <img height="150px" src="https://raw.githubusercontent.com/online-ml/deep-river/main/docs/img/logo.png" alt="incremental dl logo">
 </p>
 <p align="center">
     <img alt="PyPI" src="https://img.shields.io/pypi/v/deep-river">
     <!-- Single Coverage Badge (Shields.io) -->
     <a href="https://app.codecov.io/gh/online-ml/deep-river" >
-        <img alt="Coverage" src="https://img.shields.io/codecov/c/github/online-ml/deep-river?branch=master&logo=codecov&label=coverage" />
+        <img alt="Coverage" src="https://img.shields.io/codecov/c/github/online-ml/deep-river?branch=main&logo=codecov&label=coverage" />
     </a>
     <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/deep-river">
     <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/deep-river">
@@ -21,7 +21,7 @@
 
 ## 📚 [Documentation](https://online-ml.github.io/deep-river/)
 The [documentation](https://online-ml.github.io/deep-river/) contains an overview of all features of this repository as well as the repository's full features list. 
-In each of these, the git repo reference is listed in a section that shows [examples](https://github.com/online-ml/deep-river/blob/master/docs/examples) of the features and functionality.
+In each of these, the git repo reference is listed in a section that shows [examples](https://github.com/online-ml/deep-river/blob/main/docs/examples) of the features and functionality.
 As we are always looking for further use cases and examples, feel free to contribute to the documentation or the repository itself via a pull request
 
 ## 💈 Installation
@@ -36,7 +36,7 @@ pip install "river[deep]"
 You can install the latest development version from GitHub as so:
 
 ```shell
-pip install https://github.com/online-ml/deep-river/archive/refs/heads/master.zip
+pip install https://github.com/online-ml/deep-river/archive/refs/heads/main.zip
 ```
 
 ### Development Environment
@@ -249,7 +249,7 @@ To acknowledge the use of the `DeepRiver` library in your research, please refer
 ## 🏫 Affiliations
 
 <p align="center">
-    <img src="https://upload.wikimedia.org/wikipedia/de/thumb/4/44/Fzi_logo.svg/1200px-Fzi_logo.svg.png?raw=true" alt="FZI Logo" height="200"/>
+    <img src="https://upload.wikimedia.org/wikipedia/de/4/44/Fzi_logo.svg" alt="FZI Logo" height="200"/>
 </p>
 
 <p align="center">

deep_river-0.3.4/deep_river/__init__.py

@@ -0,0 +1,7 @@
+from importlib.metadata import version as _version
+
+from . import anomaly, classification, forecasting, regression, utils
+
+__version__ = _version("deep-river")
+
+__all__ = ["anomaly", "classification", "forecasting", "regression", "utils"]

{deep_river-0.3.2 → deep_river-0.3.4}/deep_river/anomaly/ae.py

@@ -188,5 +188,5 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
             self.loss_func(x_pred, x_t, reduction="none"),
             dim=list(range(1, x_t.dim())),
         )
-        score = loss.cpu().detach().numpy()
+        score = np.asarray(loss.cpu().detach().tolist())
         return score

{deep_river-0.3.2 → deep_river-0.3.4}/deep_river/anomaly/probability_weighted_ae.py

@@ -1,6 +1,7 @@
 import math
 from typing import Any, Callable, Union
 
+import numpy as np
 import pandas as pd
 import torch
 from river import stats, utils
@@ -65,7 +66,7 @@ class ProbabilityWeightedAutoencoder(ae.Autoencoder):
         self._apply_loss(loss)
 
     def _apply_loss(self, loss):
-        losses_numpy = loss.detach().numpy()
+        losses_numpy = np.asarray(loss.detach().cpu().tolist())
         mean = self.rolling_mean.get()
         var = self.rolling_var.get() if self.rolling_var.get() > 0 else 1
         if losses_numpy.ndim == 0:

{deep_river-0.3.2 → deep_river-0.3.4}/deep_river/anomaly/rolling_ae.py

@@ -154,7 +154,7 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
             Additional keyword arguments.
         """
         self._update_observed_features(x)
-        self._x_window.append(list(x.values()))
+        self._x_window.append([x.get(feature, 0) for feature in self.observed_features])
 
         x_t = deque2rolling_tensor(self._x_window, device=self.device)
         self._learn(x=x_t)
@@ -171,7 +171,8 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
         """
         self._update_observed_features(X)
 
-        self._x_window.append(X.values.tolist())
+        X = X[list(self.observed_features)]
+        self._x_window.extend(X.values.tolist())
         if len(self._x_window) == self.window_size:
             X_t = deque2rolling_tensor(self._x_window, device=self.device)
             self._learn(x=X_t)
@@ -193,7 +194,7 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
         self._update_observed_features(x)
         if len(self._x_window) == self.window_size:
             x_win = self._x_window.copy()
-            x_win.append(list(x.values()))
+            x_win.append([x.get(feature, 0) for feature in self.observed_features])
             x_t = deque2rolling_tensor(x_win, device=self.device)
             self.module.eval()
             with torch.inference_mode():
@@ -202,7 +203,9 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
             res = loss.item()
 
         if self.append_predict:
-            self._x_window.append(list(x.values()))
+            self._x_window.append(
+                [x.get(feature, 0) for feature in self.observed_features]
+            )
         return res
 
     def score_many(self, X: pd.DataFrame) -> List[Any]:
@@ -221,10 +224,11 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
             List of computed anomaly scores (reconstruction errors) for each sample in X.
         """
         self._update_observed_features(X)
+        X = X[list(self.observed_features)]
         x_win = self._x_window.copy()
-        x_win.append(X.values.tolist())
+        x_win.extend(X.values.tolist())
         if self.append_predict:
-            self._x_window.append(X.values.tolist())
+            self._x_window.extend(X.values.tolist())
 
         if len(self._x_window) == self.window_size:
             X_t = deque2rolling_tensor(x_win, device=self.device)
@@ -235,7 +239,7 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
                 self.loss_func(x_pred, x_pred, reduction="none"),
                 dim=list(range(1, x_pred.dim())),
             )
-            losses = loss.detach().numpy()
+            losses = np.asarray(loss.detach().cpu().tolist())
             if len(losses) < len(X):
                 losses = np.pad(losses, (len(X) - len(losses), 0))
             return losses.tolist()

{deep_river-0.3.2 → deep_river-0.3.4}/deep_river/anomaly/scaler.py

@@ -21,7 +21,7 @@ class AnomalyScaler(base.Wrapper, AnomalyDetector):
         self.anomaly_detector = anomaly_detector
 
     @classmethod
-    def _unit_test_params(self) -> dict:
+    def _unit_test_params(cls):
         """
         Returns a dictionary of parameters to be used for unit testing
         the respective class.
@@ -32,7 +32,7 @@ class AnomalyScaler(base.Wrapper, AnomalyDetector):
             Dictionary of parameters to be used for unit testing the
             respective class.
         """
-        return {"anomaly_detector": HalfSpaceTrees()}
+        yield {"anomaly_detector": HalfSpaceTrees()}
 
     @classmethod
     def _unit_test_skips(self) -> set:
@@ -60,7 +60,7 @@ class AnomalyScaler(base.Wrapper, AnomalyDetector):
         return self.anomaly_detector
 
     @abc.abstractmethod
-    def score_one(self, *args) -> float:
+    def score_one(self, *args, **kwargs) -> float:
         """Return a scaled anomaly score based on raw score provided by
         the wrapped anomaly detector.
 
@@ -79,7 +79,7 @@ class AnomalyScaler(base.Wrapper, AnomalyDetector):
         more anomalous examples.
         """
 
-    def learn_one(self, *args) -> None:
+    def learn_one(self, *args, **kwargs) -> None:
         """
         Update the scaler and the underlying anomaly scaler.
 
@@ -95,10 +95,10 @@ class AnomalyScaler(base.Wrapper, AnomalyDetector):
             The model itself.
         """
 
-        self.anomaly_detector.learn_one(*args)
+        self.anomaly_detector.learn_one(*args, **kwargs)
 
     @abc.abstractmethod
-    def score_many(self, *args) -> np.ndarray:
+    def score_many(self, *args, **kwargs) -> np.ndarray:
         """Return scaled anomaly scores based on raw score provided by
         the wrapped anomaly detector.
 
@@ -150,7 +150,7 @@ class AnomalyStandardScaler(AnomalyScaler):
         )
         self.with_std = with_std
 
-    def score_one(self, *args):
+    def score_one(self, *args, **kwargs):
         """
         Return a scaled anomaly score based on raw score provided by the
         wrapped anomaly detector. Larger values indicate more
@@ -167,7 +167,7 @@ class AnomalyStandardScaler(AnomalyScaler):
         An scaled anomaly score. Larger values indicate more
         anomalous examples.
         """
-        raw_score = self.anomaly_detector.score_one(*args)
+        raw_score = self.anomaly_detector.score_one(*args, **kwargs)
         mean = self.mean.update(raw_score).get()
         if self.with_std:
             var = (
@@ -207,7 +207,7 @@ class AnomalyMeanScaler(AnomalyScaler):
         self.window_size = window_size
         self.mean = utils.Rolling(Mean(), self.window_size) if self.rolling else Mean()
 
-    def score_one(self, *args):
+    def score_one(self, *args, **kwargs):
         """
         Return a scaled anomaly score based on raw score provided by the
         wrapped anomaly detector. Larger values indicate more
@@ -224,7 +224,7 @@ class AnomalyMeanScaler(AnomalyScaler):
         An scaled anomaly score. Larger values indicate more
         anomalous examples.
         """
-        raw_score = self.anomaly_detector.score_one(*args)
+        raw_score = self.anomaly_detector.score_one(*args, **kwargs)
         mean = self.mean.update(raw_score).get()
         score = raw_score / mean
 
@@ -257,7 +257,7 @@ class AnomalyMinMaxScaler(AnomalyScaler):
         self.min = RollingMin(self.window_size) if self.rolling else Min()
         self.max = RollingMin(self.window_size) if self.rolling else Min()
 
-    def score_one(self, *args):
+    def score_one(self, *args, **kwargs):
         """
         Return a scaled anomaly score based on raw score provided by the
         wrapped anomaly detector. Larger values indicate more
@@ -274,7 +274,7 @@ class AnomalyMinMaxScaler(AnomalyScaler):
         An scaled anomaly score. Larger values indicate more
         anomalous examples.
         """
-        raw_score = self.anomaly_detector.score_one(*args)
+        raw_score = self.anomaly_detector.score_one(*args, **kwargs)
         min = self.min.update(raw_score).get()
         max = self.max.update(raw_score).get()
         score = (raw_score - min) / (max - min)

{deep_river-0.3.2 → deep_river-0.3.4}/deep_river/base.py

@@ -388,8 +388,8 @@ class DeepEstimator(base.Estimator):
             }
         if hasattr(layer, "bias") and layer.bias is not None:
             instructions["bias"] = {"output": [{"axis": 0, "n_subparams": 1}]}
-        # LSTM special case
-        if isinstance(layer, torch.nn.LSTM):
+        # Recurrent layer special case
+        if isinstance(layer, (torch.nn.LSTM, torch.nn.GRU, torch.nn.RNN)):
             instructions["input_size"] = "input_attribute"
             if hasattr(layer, "weight_ih_l0"):
                 instructions["weight_ih_l0"] = {

{deep_river-0.3.2 → deep_river-0.3.4}/deep_river/classification/classifier.py

@@ -252,7 +252,9 @@ class Classifier(DeepEstimator, base.MiniBatchClassifier):
     # ------------------------------------------------------------------
     # Prediction
     # ------------------------------------------------------------------
-    def predict_proba_one(self, x: dict) -> dict[base.typing.ClfTarget, float]:
+    def predict_proba_one(
+        self, x: dict, **kwargs
+    ) -> dict[base.typing.ClfTarget, float]:
         """Predict class membership probabilities for one instance.
 
         Parameters

{deep_river-0.3.2 → deep_river-0.3.4}/deep_river/classification/rolling_classifier.py

@@ -167,7 +167,7 @@ class RollingClassifier(Classifier, RollingDeepEstimator):
         x_t = self._deque2rolling_tensor(self._x_window)
         self._learn(x=x_t, y=y)
 
-    def predict_proba_one(self, x: dict) -> Dict[ClfTarget, float]:
+    def predict_proba_one(self, x: dict, **kwargs) -> Dict[ClfTarget, float]:
         """Return class probability mapping for one sample using rolling context."""
         self._update_observed_features(x)
         x_win = self._x_window.copy()
@@ -192,14 +192,5 @@ class RollingClassifier(Classifier, RollingDeepEstimator):
 
     def predict_proba_many(self, X: pd.DataFrame) -> pd.DataFrame:
         """Return probability DataFrame for multiple samples with rolling context."""
-        self._update_observed_features(X)
-        X = X[list(self.observed_features)]
-        x_win = self._x_window.copy()
-        x_win.extend(X.values.tolist())
-        if self.append_predict:
-            self._x_window = x_win
-        self.module.eval()
-        with torch.inference_mode():
-            x_t = self._deque2rolling_tensor(x_win)
-            probas = self.module(x_t).detach().tolist()
-        return pd.DataFrame(probas)
+        probas = [self.predict_proba_one(row) for row in X.to_dict(orient="records")]
+        return pd.DataFrame(probas, index=X.index)

deep_river-0.3.4/deep_river/forecasting/__init__.py

@@ -0,0 +1,23 @@
+from deep_river.forecasting.forecaster import DeepForecaster
+from deep_river.forecasting.zoo import (
+    GRUForecaster,
+    LinearForecaster,
+    LiquidForecaster,
+    LSTMForecaster,
+    MLPForecaster,
+    NBEATSForecaster,
+    RNNForecaster,
+)
+
+"""This module contains forecasters for the deep_river package."""
+
+__all__ = [
+    "DeepForecaster",
+    "LinearForecaster",
+    "MLPForecaster",
+    "RNNForecaster",
+    "GRUForecaster",
+    "LiquidForecaster",
+    "LSTMForecaster",
+    "NBEATSForecaster",
+]

deep_river-0.3.4/deep_river/forecasting/forecaster.py

@@ -0,0 +1,189 @@
+import collections
+from typing import Callable, Deque, Type, Union
+
+import torch
+from river.time_series import base as time_series_base
+from torch import nn, optim
+
+from deep_river.base import DeepEstimator
+
+
+class _TestModule(nn.Module):
+    def __init__(self, n_features: int = 4):
+        super().__init__()
+        self.n_features = n_features
+        self.dense0 = nn.Linear(n_features, 8)
+        self.activation = nn.ReLU()
+        self.dense1 = nn.Linear(8, 1)
+
+    def forward(self, x, **kwargs):
+        return self.dense1(self.activation(self.dense0(x)))
+
+
+class DeepForecaster(DeepEstimator, time_series_base.Forecaster):
+    """Incremental PyTorch forecaster compatible with River's time-series API.
+
+    ``DeepForecaster`` learns a one-step-ahead model from the recent endogenous
+    target history and optional exogenous features. Multi-step forecasts are
+    produced autoregressively by feeding each predicted value back into a copied
+    history buffer.
+
+    Parameters
+    ----------
+    module
+        PyTorch module. In flat mode it receives a tensor of shape
+        ``(1, window_size + n_exogenous_features)``. In sequence mode it receives
+        ``(window_size, 1, 1 + n_exogenous_features)``.
+    window_size
+        Number of past target values used as autoregressive context.
+    is_sequence_model
+        Whether ``module`` expects sequence-shaped input.
+    loss_fn, optimizer_fn, lr, is_feature_incremental, device, seed,
+    gradient_clip_value, **kwargs
+        Standard deep-river estimator configuration.
+    """
+
+    def __init__(
+        self,
+        module: nn.Module,
+        loss_fn: Union[str, Callable] = "mse",
+        optimizer_fn: Union[str, Type[optim.Optimizer]] = "sgd",
+        lr: float = 1e-3,
+        is_feature_incremental: bool = False,
+        device: str = "cpu",
+        seed: int = 42,
+        window_size: int = 10,
+        is_sequence_model: bool = False,
+        gradient_clip_value: float | None = 1.0,
+        **kwargs,
+    ):
+        if window_size < 1:
+            raise ValueError("window_size must be at least 1")
+
+        self.window_size = window_size
+        self.is_sequence_model = is_sequence_model
+        self._y_window: Deque[float] = collections.deque(maxlen=window_size)
+
+        super().__init__(
+            module=module,
+            loss_fn=loss_fn,
+            optimizer_fn=optimizer_fn,
+            lr=lr,
+            is_feature_incremental=is_feature_incremental,
+            device=device,
+            seed=seed,
+            gradient_clip_value=gradient_clip_value,
+            **kwargs,
+        )
+
+    def learn_one(self, y: float, x: dict | None = None) -> None:
+        """Update the model with one target and optional exogenous features."""
+        x = x or {}
+        self._update_observed_features(x)
+        x_t = self._make_input_tensor(self._y_window, x)
+        y_t = torch.tensor([[y]], dtype=torch.float32, device=self.device)
+        self._learn(x_t, y_t)
+        self._y_window.append(float(y))
+
+    def forecast(self, horizon: int, xs: list[dict] | None = None) -> list:
+        """Forecast ``horizon`` steps ahead using autoregressive rollouts."""
+        if horizon < 0:
+            raise ValueError("horizon must be non-negative")
+        if xs is None:
+            xs = [{} for _ in range(horizon)]
+        if len(xs) != horizon:
+            raise ValueError(
+                "the length of xs should be equal to the specified horizon"
+            )
+
+        y_window = collections.deque(self._y_window, maxlen=self.window_size)
+        forecasts = []
+
+        self.module.eval()
+        with torch.inference_mode():
+            for x in xs:
+                x = x or {}
+                self._update_observed_features(x)
+                x_t = self._make_input_tensor(y_window, x)
+                y_pred = self.module(x_t)
+                if isinstance(y_pred, torch.Tensor):
+                    y_pred = y_pred.detach().view(-1)[-1].cpu().item()
+                else:
+                    y_pred = float(y_pred)
+                forecasts.append(y_pred)
+                y_window.append(float(y_pred))
+
+        return forecasts
+
+    def _update_observed_features(self, x):
+        """Track exogenous features and expand the first layer when requested."""
+        if not x:
+            return False
+
+        prev_feature_count = len(self.observed_features)
+        self.observed_features.update(x.keys())
+
+        if self.is_feature_incremental and self.input_layer:
+            target_size = self._target_input_size()
+            if self._get_input_size() < target_size:
+                self._expand_layer(
+                    self.input_layer, target_size=target_size, output=False
+                )
+
+        return len(self.observed_features) > prev_feature_count
+
+    def _target_input_size(self) -> int:
+        endogenous_size = 1 if self.is_sequence_model else self.window_size
+        return endogenous_size + len(self.observed_features)
+
+    def _n_exogenous_inputs(self) -> int:
+        endogenous_size = 1 if self.is_sequence_model else self.window_size
+        return max(0, self._get_input_size() - endogenous_size)
+
+    def _lag_values(self, y_window: Deque[float]) -> list[float]:
+        values = list(y_window)[-self.window_size :]
+        return [0.0] * (self.window_size - len(values)) + values
+
+    def _exogenous_values(self, x: dict) -> list[float]:
+        values = [
+            float(x.get(feature, 0.0) or 0.0) for feature in self.observed_features
+        ]
+        n_exogenous_inputs = self._n_exogenous_inputs()
+        if len(values) < n_exogenous_inputs:
+            values.extend([0.0] * (n_exogenous_inputs - len(values)))
+        return values[:n_exogenous_inputs]
+
+    def _make_input_tensor(self, y_window: Deque[float], x: dict) -> torch.Tensor:
+        lags = self._lag_values(y_window)
+        exogenous = self._exogenous_values(x)
+
+        if self.is_sequence_model:
+            rows = [[lag, *exogenous] for lag in lags]
+            return torch.tensor(
+                rows, dtype=torch.float32, device=self.device
+            ).unsqueeze(1)
+
+        row = [*lags, *exogenous]
+        return torch.tensor([row], dtype=torch.float32, device=self.device)
+
+    def _get_runtime_state(self):
+        state = super()._get_runtime_state()
+        state["target_window"] = list(self._y_window)
+        return state
+
+    def _restore_runtime_state(self, state):
+        super()._restore_runtime_state(state)
+        if "target_window" in state:
+            self._y_window = collections.deque(
+                state["target_window"], maxlen=getattr(self, "window_size", 10)
+            )
+
+    @classmethod
+    def _unit_test_params(cls):
+        yield {
+            "module": _TestModule(n_features=4),
+            "window_size": 2,
+            "loss_fn": "mse",
+            "optimizer_fn": "sgd",
+            "is_feature_incremental": False,
+        }