deep-river 0.2.6__tar.gz → 0.2.7__tar.gz

{deep_river-0.2.6 → deep_river-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deep_river
-Version: 0.2.6
+Version: 0.2.7
 Summary: Online Deep Learning for river
 Home-page: https://online-ml.github.io/deep-river/
 Author: Cedric Kulbach
@@ -17,42 +17,44 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.6.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: scikit-learn~=1.4.2
+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~=0.21.1
-Requires-Dist: tqdm~=4.66.4
+Requires-Dist: river~=0.21.2
+Requires-Dist: scipy~=1.13.0
+Requires-Dist: tqdm~=4.66.5
 Requires-Dist: ordered-set~=4.1.0
 Requires-Dist: torchviz~=0.0.2
 Provides-Extra: dev
-Requires-Dist: scikit-learn~=1.4.2; extra == "dev"
+Requires-Dist: scikit-learn~=1.5.0; extra == "dev"
 Requires-Dist: torch~=2.2.2; extra == "dev"
 Requires-Dist: pandas~=2.2.2; extra == "dev"
 Requires-Dist: numpy~=1.26.4; extra == "dev"
-Requires-Dist: river~=0.21.1; extra == "dev"
-Requires-Dist: tqdm~=4.66.4; extra == "dev"
+Requires-Dist: river~=0.21.2; extra == "dev"
+Requires-Dist: scipy~=1.13.0; extra == "dev"
+Requires-Dist: tqdm~=4.66.5; extra == "dev"
 Requires-Dist: ordered-set~=4.1.0; extra == "dev"
 Requires-Dist: torchviz~=0.0.2; extra == "dev"
-Requires-Dist: graphviz>=0.10.1; extra == "dev"
-Requires-Dist: matplotlib>=3.0.2; extra == "dev"
-Requires-Dist: mypy>=0.990; extra == "dev"
-Requires-Dist: pre-commit>=2.20.0; extra == "dev"
-Requires-Dist: pytest>=7.2.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: scikit-learn>=0.22.1; extra == "dev"
-Requires-Dist: black>=22.10.0; extra == "dev"
-Requires-Dist: flake8>=5.0.4; extra == "dev"
-Requires-Dist: isort>=5.10.1; 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: 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.2.0; extra == "dev"
+Requires-Dist: pyupgrade==3.17.0; extra == "dev"
 Provides-Extra: docs
-Requires-Dist: scikit-learn~=1.4.2; extra == "docs"
+Requires-Dist: scikit-learn~=1.5.0; extra == "docs"
 Requires-Dist: torch~=2.2.2; extra == "docs"
 Requires-Dist: pandas~=2.2.2; extra == "docs"
 Requires-Dist: numpy~=1.26.4; extra == "docs"
-Requires-Dist: river~=0.21.1; extra == "docs"
-Requires-Dist: tqdm~=4.66.4; extra == "docs"
+Requires-Dist: river~=0.21.2; extra == "docs"
+Requires-Dist: scipy~=1.13.0; extra == "docs"
+Requires-Dist: tqdm~=4.66.5; extra == "docs"
 Requires-Dist: ordered-set~=4.1.0; extra == "docs"
 Requires-Dist: torchviz~=0.0.2; extra == "docs"
 Requires-Dist: flask>=2.0.2; extra == "docs"
@@ -78,18 +80,17 @@ Requires-Dist: mkdocs-charts-plugin; extra == "docs"
 Requires-Dist: python-slugify; extra == "docs"
 Requires-Dist: watermark==2.3.1; extra == "docs"
 Provides-Extra: all
-Requires-Dist: graphviz>=0.10.1; extra == "all"
-Requires-Dist: matplotlib>=3.0.2; extra == "all"
-Requires-Dist: mypy>=0.990; extra == "all"
-Requires-Dist: pre-commit>=2.20.0; extra == "all"
-Requires-Dist: pytest>=7.2.0; extra == "all"
-Requires-Dist: pytest-cov>=4.0.0; extra == "all"
-Requires-Dist: scikit-learn>=0.22.1; extra == "all"
-Requires-Dist: black>=22.10.0; extra == "all"
-Requires-Dist: flake8>=5.0.4; extra == "all"
-Requires-Dist: isort>=5.10.1; extra == "all"
+Requires-Dist: graphviz>=0.20.3; extra == "all"
+Requires-Dist: matplotlib>=3.9.2; extra == "all"
+Requires-Dist: mypy>=1.11.1; extra == "all"
+Requires-Dist: pre-commit>=3.8.0; extra == "all"
+Requires-Dist: pytest>=8.3.2; extra == "all"
+Requires-Dist: pytest-cov>=5.0.0; extra == "all"
+Requires-Dist: black>=24.8.0; extra == "all"
+Requires-Dist: flake8>=7.1.1; extra == "all"
+Requires-Dist: isort>=5.13.2; extra == "all"
 Requires-Dist: jupyter>=1.0.0; extra == "all"
-Requires-Dist: pyupgrade==3.2.0; extra == "all"
+Requires-Dist: pyupgrade==3.17.0; extra == "all"
 Requires-Dist: flask>=2.0.2; extra == "all"
 Requires-Dist: ipykernel>=6.9.0; extra == "all"
 Requires-Dist: mike>=0.5.3; extra == "all"
@@ -125,6 +126,7 @@ Requires-Dist: dataclasses; python_version == "3.6"
     </a>
     <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/deep-river">
     <img alt="GitHub" src="https://img.shields.io/github/license/online-ml/deep-river">
+    <a href="https://joss.theoj.org/papers/6a76784f55e8b041d71a7fa776eb386a"><img src="https://joss.theoj.org/papers/6a76784f55e8b041d71a7fa776eb386a/status.svg"></a>
 </p>
 <p align="center">
     deep-river is a Python library for online deep learning.
@@ -194,7 +196,7 @@ For further examples check out the <a href="https://online-ml.github.io/deep-riv
 ...     metric.update(y, y_pred)  # update the metric
 ...     model_pipeline.learn_one(x, y)  # make the model learn
 >>> print(f"Accuracy: {metric.get():.4f}")
-Accuracy: 0.6736
+Accuracy: 0.7264
 
 ```
 ### Multi Target Regression 
@@ -274,7 +276,7 @@ MicroAverage(MAE): 34.31
 ...     metric.update(y, score)
 ...
 >>> print(f"ROCAUC: {metric.get():.4f}")
-ROCAUC: 0.9017
+ROCAUC: 0.7812
 
 ```
 

{deep_river-0.2.6 → deep_river-0.2.7}/README.md

@@ -8,6 +8,7 @@
     </a>
     <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/deep-river">
     <img alt="GitHub" src="https://img.shields.io/github/license/online-ml/deep-river">
+    <a href="https://joss.theoj.org/papers/6a76784f55e8b041d71a7fa776eb386a"><img src="https://joss.theoj.org/papers/6a76784f55e8b041d71a7fa776eb386a/status.svg"></a>
 </p>
 <p align="center">
     deep-river is a Python library for online deep learning.
@@ -77,7 +78,7 @@ For further examples check out the <a href="https://online-ml.github.io/deep-riv
 ...     metric.update(y, y_pred)  # update the metric
 ...     model_pipeline.learn_one(x, y)  # make the model learn
 >>> print(f"Accuracy: {metric.get():.4f}")
-Accuracy: 0.6736
+Accuracy: 0.7264
 
 ```
 ### Multi Target Regression 
@@ -157,7 +158,7 @@ MicroAverage(MAE): 34.31
 ...     metric.update(y, score)
 ...
 >>> print(f"ROCAUC: {metric.get():.4f}")
-ROCAUC: 0.9017
+ROCAUC: 0.7812
 
 ```
 

{deep_river-0.2.6 → deep_river-0.2.7}/deep_river/__version__.py

@@ -1,3 +1,3 @@
-VERSION = (0, 2, 6)
+VERSION = (0, 2, 7)
 
 __version__ = ".".join(map(str, VERSION))  # noqa: F401

{deep_river-0.2.6 → deep_river-0.2.7}/deep_river/anomaly/ae.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Type, Union
+from typing import Any, Callable, Dict, Type, Union
 
 import numpy as np
 import pandas as pd
@@ -8,6 +8,7 @@ from torch import nn
 
 from deep_river.base import DeepEstimator
 from deep_river.utils import dict2tensor
+from deep_river.utils.layer_adaptation import expand_layer
 from deep_river.utils.tensor_conversion import df2tensor
 
 
@@ -93,7 +94,7 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
     ...    metric.update(y, score)
     ...
     >>> print(f"ROCAUC: {metric.get():.4f}")
-    ROCAUC: 0.9017
+    ROCAUC: 0.7812
     """
 
     def __init__(
@@ -102,6 +103,7 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
         loss_fn: Union[str, Callable] = "mse",
         optimizer_fn: Union[str, Callable] = "sgd",
         lr: float = 1e-3,
+        is_feature_incremental: bool = False,
         device: str = "cpu",
         seed: int = 42,
         **kwargs,
@@ -111,10 +113,12 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
             loss_fn=loss_fn,
             optimizer_fn=optimizer_fn,
             lr=lr,
+            is_feature_incremental=is_feature_incremental,
             device=device,
             seed=seed,
             **kwargs,
         )
+        self.is_class_incremental = is_feature_incremental
 
     @classmethod
     def _unit_test_params(cls):
@@ -133,6 +137,7 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
             "module": _TestAutoencoder,
             "loss_fn": "mse",
             "optimizer_fn": "sgd",
+            "is_feature_incremental": True,
         }
 
     @classmethod
@@ -148,13 +153,7 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
         set
             Set of checks to skip during unit testing.
         """
-        return {
-            "check_shuffle_features_no_impact",
-            "check_emerging_features",
-            "check_disappearing_features",
-            "check_predict_proba_one",
-            "check_predict_proba_one_binary",
-        }
+        return set()
 
     def learn_one(self, x: dict, y: Any = None, **kwargs) -> "Autoencoder":
         """
@@ -173,14 +172,17 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
             The model itself.
         """
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(x)
-            self.initialize_module(**self.kwargs)
-        return self._learn(dict2tensor(x, device=self.device))
+            self._update_observed_features(x)
+            self.initialize_module(x=x, **self.kwargs)
+        self._adapt_input_dim(x)
+        return self._learn(
+            dict2tensor(x, features=self.observed_features, device=self.device)
+        )
 
     def _learn(self, x: torch.Tensor) -> "Autoencoder":
         self.module.train()
         x_pred = self.module(x)
-        loss = self.loss_fn(x_pred, x)
+        loss = self.loss_func(x_pred, x)
         loss.backward()
         self.optimizer.step()
         self.optimizer.zero_grad()
@@ -205,14 +207,18 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
         """
 
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(x)
-            self.initialize_module(**self.kwargs)
+            self._update_observed_features(x)
+            self.initialize_module(x=x, **self.kwargs)
 
-        x_t = dict2tensor(x, device=self.device)
+        self._adapt_input_dim(x)
+
+        x_t = dict2tensor(
+            x, features=self.observed_features, device=self.device
+        )
         self.module.eval()
         with torch.inference_mode():
             x_pred = self.module(x_t)
-        loss = self.loss_fn(x_pred, x_t).item()
+        loss = self.loss_func(x_pred, x_t).item()
         return loss
 
     def learn_many(self, X: pd.DataFrame) -> "Autoencoder":
@@ -231,10 +237,13 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
 
         """
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(X.columns)
-            self.initialize_module(**self.kwargs)
-        X = df2tensor(X, device=self.device)
-        return self._learn(X)
+
+            self._update_observed_features(X)
+            self.initialize_module(x=X, **self.kwargs)
+
+        self._adapt_input_dim(X)
+        X_t = df2tensor(X, features=self.observed_features, device=self.device)
+        return self._learn(X_t)
 
     def score_many(self, X: pd.DataFrame) -> np.ndarray:
         """
@@ -253,16 +262,35 @@ class Autoencoder(DeepEstimator, AnomalyDetector):
             indicate more anomalous examples.
         """
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(X.columns)
-            self.initialize_module(**self.kwargs)
-        X = df2tensor(X, device=self.device)
+            self._update_observed_features(X)
+            self.initialize_module(x=X, **self.kwargs)
+
+        self._adapt_input_dim(X)
+        X_t = df2tensor(X, features=self.observed_features, device=self.device)
 
         self.module.eval()
         with torch.inference_mode():
-            X_pred = self.module(X)
+            X_pred = self.module(X_t)
         loss = torch.mean(
-            self.loss_fn(X_pred, X, reduction="none"),
-            dim=list(range(1, X.dim())),
+            self.loss_func(X_pred, X_t, reduction="none"),
+            dim=list(range(1, X_t.dim())),
         )
         score = loss.cpu().detach().numpy()
         return score
+
+    def _adapt_input_dim(self, x: Dict | pd.DataFrame):
+        has_new_feature = self._update_observed_features(x)
+
+        if has_new_feature and self.is_feature_incremental:
+            expand_layer(
+                self.input_layer,
+                self.input_expansion_instructions,
+                len(self.observed_features),
+                output=False,
+            )
+            expand_layer(
+                self.output_layer,
+                self.output_expansion_instructions,
+                len(self.observed_features),
+                output=True,
+            )

{deep_river-0.2.6 → deep_river-0.2.7}/deep_river/anomaly/probability_weighted_ae.py

@@ -8,6 +8,7 @@ from scipy.special import ndtr
 
 from deep_river.anomaly import ae
 from deep_river.utils import dict2tensor
+from deep_river.utils.tensor_conversion import df2tensor
 
 
 class ProbabilityWeightedAutoencoder(ae.Autoencoder):
@@ -87,7 +88,7 @@ class ProbabilityWeightedAutoencoder(ae.Autoencoder):
     ...    metric.update(y, score)
     ...
     >>> print(f"ROCAUC: {metric.get():.4f}")
-    ROCAUC: 0.8599
+    ROCAUC: 0.7572
     """
 
     def __init__(
@@ -138,13 +139,15 @@ class ProbabilityWeightedAutoencoder(ae.Autoencoder):
             The autoencoder itself.
         """
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(x)
-            self.initialize_module(**self.kwargs)
-        x_t = dict2tensor(x, device=self.device)
+            self._update_observed_features(x)
+            self.initialize_module(x=x, **self.kwargs)
+
+        self._adapt_input_dim(x)
+        x_t = dict2tensor(x, self.observed_features, device=self.device)
 
         self.module.train()
         x_pred = self.module(x_t)
-        loss = self.loss_fn(x_pred, x_t)
+        loss = self.loss_func(x_pred, x_t)
         self._apply_loss(loss)
         return self
 
@@ -173,15 +176,16 @@ class ProbabilityWeightedAutoencoder(ae.Autoencoder):
 
     def learn_many(self, X: pd.DataFrame) -> "ProbabilityWeightedAutoencoder":
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(X.columns)
-            self.initialize_module(**self.kwargs)
-        X = dict2tensor(X.to_dict(), device=self.device)
+            self._update_observed_features(X)
+            self.initialize_module(x=X, **self.kwargs)
+        self._adapt_input_dim(X)
+        X_t = df2tensor(X, features=self.observed_features, device=self.device)
 
         self.module.train()
         x_pred = self.module(X)
         loss = torch.mean(
-            self.loss_fn(x_pred, X, reduction="none"),
-            dim=list(range(1, X.dim())),
+            self.loss_func(x_pred, X_t, reduction="none"),
+            dim=list(range(1, X_t.dim())),
         )
         self._apply_loss(loss)
         return self

{deep_river-0.2.6 → deep_river-0.2.7}/deep_river/anomaly/rolling_ae.py

@@ -26,20 +26,10 @@ class _TestLSTMAutoencoder(nn.Module):
             num_layers=n_layers,
             batch_first=batch_first,
         )
-        self.decoder = nn.LSTM(
-            input_size=hidden_size,
-            hidden_size=n_features,
-            num_layers=n_layers,
-            batch_first=batch_first,
-        )
 
     def forward(self, x):
-        _, (h, _) = self.encoder(x)
-        h = h[-1].view(1, 1, -1)
-        x_flipped = torch.flip(x[1:], dims=[self.time_axis])
-        input = torch.cat((h, x_flipped), dim=self.time_axis)
-        x_hat, _ = self.decoder(input)
-        return torch.flip(x_hat, dims=[self.time_axis])
+        output, (h, c) = self.encoder(x)
+        return output
 
 
 class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
@@ -146,7 +136,7 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
     def _learn(self, x: torch.Tensor):
         self.module.train()
         x_pred = self.module(x)
-        loss = self.loss_fn(x_pred, x)
+        loss = self.loss_func(x_pred, x)
 
         self.optimizer.zero_grad()
         loss.backward()
@@ -169,8 +159,8 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
             The estimator itself.
         """
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(x)
-            self.initialize_module(**self.kwargs)
+            self._update_observed_features(x)
+            self.initialize_module(x=x, **self.kwargs)
 
         self._x_window.append(list(x.values()))
 
@@ -197,8 +187,8 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
             The estimator itself.
         """
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(X.columns)
-            self.initialize_module(**self.kwargs)
+            self._update_observed_features(X)
+            self.initialize_module(x=X, **self.kwargs)
 
         self._x_window.append(X.values.tolist())
         if len(self._x_window) == self.window_size:
@@ -209,8 +199,10 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
     def score_one(self, x: dict) -> float:
         res = 0.0
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(x)
-            self.initialize_module(**self.kwargs)
+
+            self._update_observed_features(x)
+
+            self.initialize_module(x=x, **self.kwargs)
 
         if len(self._x_window) == self.window_size:
             x_win = self._x_window.copy()
@@ -219,7 +211,7 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
             self.module.eval()
             with torch.inference_mode():
                 x_pred = self.module(x_t)
-            loss = self.loss_fn(x_pred, x_t)
+            loss = self.loss_func(x_pred, x_t)
             res = loss.item()
 
         if self.append_predict:
@@ -228,8 +220,9 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
 
     def score_many(self, X: pd.DataFrame) -> List[Any]:
         if not self.module_initialized:
-            self.kwargs["n_features"] = len(X.columns)
-            self.initialize_module(**self.kwargs)
+
+            self._update_observed_features(X)
+            self.initialize_module(x=X, **self.kwargs)
 
         x_win = self._x_window.copy()
         x_win.append(X.values.tolist())
@@ -242,7 +235,7 @@ class RollingAutoencoder(RollingDeepEstimator, anomaly.base.AnomalyDetector):
             with torch.inference_mode():
                 x_pred = self.module(X_t)
             loss = torch.mean(
-                self.loss_fn(x_pred, x_pred, reduction="none"),
+                self.loss_func(x_pred, x_pred, reduction="none"),
                 dim=list(range(1, x_pred.dim())),
             )
             losses = loss.detach().numpy()

{deep_river-0.2.6 → deep_river-0.2.7}/deep_river/base.py

@@ -1,11 +1,21 @@
 import collections
 import inspect
-from typing import Any, Callable, Deque, Type, Union, cast
+import warnings
+from typing import Any, Callable, Deque, Dict, List, Type, Union, cast
 
+import pandas as pd
 import torch
+from ordered_set import OrderedSet
 from river import base
+from torch.utils.hooks import RemovableHandle
 
 from deep_river.utils import get_loss_fn, get_optim_fn
+from deep_river.utils.hooks import ForwardOrderTracker, apply_hooks
+from deep_river.utils.layer_adaptation import (
+    SUPPORTED_LAYERS,
+    expand_layer,
+    load_instructions,
+)
 
 try:
     from graphviz import Digraph
@@ -53,19 +63,29 @@ class DeepEstimator(base.Estimator):
         loss_fn: Union[str, Callable] = "mse",
         optimizer_fn: Union[str, Callable] = "sgd",
         lr: float = 1e-3,
+        is_feature_incremental: bool = False,
         device: str = "cpu",
         seed: int = 42,
         **kwargs,
     ):
         super().__init__()
         self.module_cls = module
-        self.module: torch.nn.Module = cast(torch.nn.Module, None)  # cleaner
-        self.loss_fn = get_loss_fn(loss_fn)
-        self.optimizer_fn = get_optim_fn(optimizer_fn)
+        self.module: torch.nn.Module = cast(torch.nn.Module, None)
+        self.loss_func = get_loss_fn(loss_fn)
+        self.loss_fn = loss_fn
+        self.optimizer_func = get_optim_fn(optimizer_fn)
+        self.optimizer_fn = optimizer_fn
+        self.is_feature_incremental = is_feature_incremental
+        self.is_class_incremental: bool = False
+        self.observed_features: OrderedSet[str] = OrderedSet([])
         self.lr = lr
         self.device = device
         self.kwargs = kwargs
         self.seed = seed
+        self.input_layer = cast(torch.nn.Module, None)
+        self.input_expansion_instructions = cast(Dict, None)
+        self.output_layer = cast(torch.nn.Module, None)
+        self.output_expansion_instructions = cast(Dict, None)
         self.module_initialized = False
         torch.manual_seed(seed)
 
@@ -103,7 +123,7 @@ class DeepEstimator(base.Estimator):
             y_pred.mean(), params=dict(self.module.named_parameters())
         )
 
-    def initialize_module(self, **kwargs):
+    def initialize_module(self, x: dict | pd.DataFrame, **kwargs):
         """
         Parameters
         ----------
@@ -118,17 +138,26 @@ class DeepEstimator(base.Estimator):
         instance
           The initialized component.
         """
+        torch.manual_seed(self.seed)
+        if isinstance(x, Dict):
+            n_features = len(x)
+        elif isinstance(x, pd.DataFrame):
+            n_features = len(x.columns)
+
         if not isinstance(self.module_cls, torch.nn.Module):
             self.module = self.module_cls(
-                **self._filter_kwargs(self.module_cls, kwargs)
+                n_features=n_features,
+                **self._filter_kwargs(self.module_cls, kwargs),
             )
 
         self.module.to(self.device)
-        self.optimizer = self.optimizer_fn(
+        self.optimizer = self.optimizer_func(
             self.module.parameters(), lr=self.lr
         )
         self.module_initialized = True
 
+        self._get_input_output_layers(n_features=n_features)
+
     def clone(
         self,
         new_params: dict[Any, Any] | None = None,
@@ -160,6 +189,72 @@ class DeepEstimator(base.Estimator):
             clone.__dict__.update(self.__dict__)
         return clone
 
+    def _adapt_input_dim(self, x: Dict | pd.DataFrame):
+        has_new_feature = self._update_observed_features(x)
+
+        if has_new_feature and self.is_feature_incremental:
+            expand_layer(
+                self.input_layer,
+                self.input_expansion_instructions,
+                len(self.observed_features),
+                output=False,
+            )
+
+    def _update_observed_features(self, x):
+        n_existing_features = len(self.observed_features)
+        if isinstance(x, Dict):
+            self.observed_features |= x.keys()
+        else:
+            self.observed_features |= x.columns
+
+        if len(self.observed_features) > n_existing_features:
+            self.observed_features = OrderedSet(sorted(self.observed_features))
+            return True
+        else:
+            return False
+
+    def _get_input_output_layers(self, n_features: int):
+        handles: List[RemovableHandle] = []
+        tracker = ForwardOrderTracker()
+        apply_hooks(module=self.module, hook=tracker, handles=handles)
+
+        x_dummy = torch.empty((1, n_features), device=self.device)
+        self.module(x_dummy)
+
+        for h in handles:
+            h.remove()
+
+        if self.is_class_incremental:
+            if tracker.ordered_modules and isinstance(
+                tracker.ordered_modules[-1], SUPPORTED_LAYERS
+            ):
+
+                self.output_layer = tracker.ordered_modules[-1]
+                self.output_expansion_instructions = load_instructions(
+                    self.output_layer
+                )
+            else:
+                warnings.warn(
+                    "The model will not be able to adapt its output to new "
+                    "classes since no supported output layer was found."
+                )
+                self.is_class_incremental = False
+
+        if self.is_feature_incremental:
+            if tracker.ordered_modules and isinstance(
+                tracker.ordered_modules[0], SUPPORTED_LAYERS
+            ):
+                self.input_layer = tracker.ordered_modules[0]
+                self.input_expansion_instructions = load_instructions(
+                    self.input_layer
+                )
+            else:
+                warnings.warn(
+                    "The model will not be able to adapt its input layer to "
+                    "new features since no supported input layer was found."
+                )
+                self.is_feature_incremental = False
+
 
 class RollingDeepEstimator(DeepEstimator):
     """