regressor

Classes:

Name	Description
Regressor	Wrapper for PyTorch regression models that enables
RegressorInitialized	Wrapper for PyTorch classification models that supports feature and class incremental learning.

Regressor

Regressor(
    module: Type[Module],
    loss_fn: Union[str, Callable] = "mse",
    optimizer_fn: Union[str, Callable] = "sgd",
    lr: float = 0.001,
    is_feature_incremental: bool = False,
    device: str = "cpu",
    seed: int = 42,
    **kwargs
)

Bases: DeepEstimator, MiniBatchRegressor

Wrapper for PyTorch regression models that enables compatibility with River.

Parameters:

Name	Type	Description	Default
module	Type[Module]	Torch Module that builds the autoencoder to be wrapped. The Module should accept parameter n_features so that the returned model's input shape can be determined based on the number of features in the initial training example.	required
loss_fn	Union[str, Callable]	Loss function to be used for training the wrapped model. Can be a loss function provided by torch.nn.functional or one of the following: 'mse', 'l1', 'cross_entropy', 'binary_crossentropy', 'smooth_l1', 'kl_div'.	'mse'
optimizer_fn	Union[str, Callable]	Optimizer to be used for training the wrapped model. Can be an optimizer class provided by torch.optim or one of the following: "adam", "adam_w", "sgd", "rmsprop", "lbfgs".	'sgd'
lr	float	Learning rate of the optimizer.	0.001
device	str	Device to run the wrapped model on. Can be "cpu" or "cuda".	'cpu'
seed	int	Random seed to be used for training the wrapped model.	42
**kwargs		Parameters to be passed to the Module or the optimizer.	{}

Examples:

Methods:

Name	Description
clone	Clones the estimator.
draw	Draws the wrapped model.
initialize_module	Parameters
learn_many	Performs one step of training with a batch of examples.
learn_one	Performs one step of training with a single example.
predict_many	Predicts the target value for a batch of examples.
predict_one	Predicts the target value for a single example.

Source code in deep_river/regression/regressor.py

def __init__(
    self,
    module: Type[torch.nn.Module],
    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__(
        module=module,
        loss_fn=loss_fn,
        device=device,
        optimizer_fn=optimizer_fn,
        lr=lr,
        is_feature_incremental=is_feature_incremental,
        seed=seed,
        **kwargs,
    )

clone

clone(
    new_params: dict[Any, Any] | None = None,
    include_attributes=False,
)

Clones the estimator.

Parameters:

Name	Type	Description	Default
new_params	dict[Any, Any] | None	New parameters to be passed to the cloned estimator.	None
include_attributes		If True, the attributes of the estimator will be copied to the cloned estimator. This is useful when the estimator is a transformer and the attributes are the learned parameters.	False

Returns:

Type	Description
DeepEstimator	The cloned estimator.

Source code in deep_river/base.py

def clone(
    self,
    new_params: dict[Any, Any] | None = None,
    include_attributes=False,
):
    """Clones the estimator.

    Parameters
    ----------
    new_params
        New parameters to be passed to the cloned estimator.
    include_attributes
        If True, the attributes of the estimator will be copied to the
        cloned estimator. This is useful when the estimator is a
        transformer and the attributes are the learned parameters.

    Returns
    -------
    DeepEstimator
        The cloned estimator.
    """
    new_params = new_params or {}
    new_params.update(self.kwargs)
    new_params.update(self._get_params())
    new_params.update({"module": self.module_cls})

    clone = self.__class__(**new_params)
    if include_attributes:
        clone.__dict__.update(self.__dict__)
    return clone

draw

draw() -> Digraph

Draws the wrapped model.

Source code in deep_river/base.py

def draw(self) -> Digraph:
    """Draws the wrapped model."""
    first_parameter = next(self.module.parameters())
    input_shape = first_parameter.size()
    y_pred = self.module(torch.rand(input_shape))
    return make_dot(y_pred.mean(), params=dict(self.module.named_parameters()))

initialize_module

initialize_module(x: dict | DataFrame, **kwargs)

Parameters:

Name	Type	Description	Default
module		The instance or class or callable to be initialized, e.g. self.module.	required
kwargs	dict	The keyword arguments to initialize the instance or class. Can be an empty dict.	{}

Returns:

Type	Description
instance	The initialized component.

Source code in deep_river/base.py

def initialize_module(self, x: dict | pd.DataFrame, **kwargs):
    """
    Parameters
    ----------
    module
      The instance or class or callable to be initialized, e.g.
      ``self.module``.
    kwargs : dict
      The keyword arguments to initialize the instance or class. Can be an
      empty dict.
    Returns
    -------
    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(
            n_features=n_features,
            **self._filter_kwargs(self.module_cls, kwargs),
        )

    self.module.to(self.device)
    self.optimizer = self.optimizer_func(self.module.parameters(), lr=self.lr)
    self.module_initialized = True

    self._get_input_output_layers(n_features=n_features)

learn_many

learn_many(X: DataFrame, y: Series) -> None

Performs one step of training with a batch of examples.

Parameters:

Name	Type	Description	Default
x		Input examples.	required
y	Series	Target values.	required

Returns:

Type	Description
Regressor	The regressor itself.

Source code in deep_river/regression/regressor.py

def learn_many(self, X: pd.DataFrame, y: pd.Series) -> None:
    """
    Performs one step of training with a batch of examples.

    Parameters
    ----------
    x
        Input examples.
    y
        Target values.

    Returns
    -------
    Regressor
        The regressor itself.
    """
    if not self.module_initialized:

        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)
    y_t = torch.tensor(y, device=self.device, dtype=torch.float32).unsqueeze(1)

    self._learn(X_t, y_t)

learn_one

learn_one(x: dict, y: RegTarget, **kwargs) -> None

Performs one step of training with a single example.

Parameters:

Name	Type	Description	Default
x	dict	Input example.	required
y	RegTarget	Target value.	required

Returns:

Type	Description
Regressor	The regressor itself.

Source code in deep_river/regression/regressor.py

def learn_one(self, x: dict, y: RegTarget, **kwargs) -> None:
    """
    Performs one step of training with a single example.

    Parameters
    ----------
    x
        Input example.
    y
        Target value.

    Returns
    -------
    Regressor
        The regressor itself.
    """
    if not self.module_initialized:
        self._update_observed_features(x)
        self.initialize_module(x=x, **self.kwargs)
    self._adapt_input_dim(x)
    x_t = dict2tensor(x, features=self.observed_features, device=self.device)
    y_t = float2tensor(y, device=self.device)

    self._learn(x_t, y_t)

predict_many

predict_many(X: DataFrame) -> Series

Predicts the target value for a batch of examples.

Parameters:

Name	Type	Description	Default
x		Input examples.	required

Returns:

Type	Description
List	Predicted target values.

Source code in deep_river/regression/regressor.py

def predict_many(self, X: pd.DataFrame) -> pd.Series:
    """
    Predicts the target value for a batch of examples.

    Parameters
    ----------
    x
        Input examples.

    Returns
    -------
    List
        Predicted target values.
    """
    if not self.module_initialized:
        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():
        y_preds = self.module(X_t).detach().squeeze().tolist()
    return y_preds

predict_one

predict_one(x: dict) -> RegTarget

Predicts the target value for a single example.

Parameters:

Name	Type	Description	Default
x	dict	Input example.	required

Returns:

Type	Description
RegTarget	Predicted target value.

Source code in deep_river/regression/regressor.py

def predict_one(self, x: dict) -> RegTarget:
    """
    Predicts the target value for a single example.

    Parameters
    ----------
    x
        Input example.

    Returns
    -------
    RegTarget
        Predicted target value.
    """
    if not self.module_initialized:
        self._update_observed_features(x)
        self.initialize_module(x=x, **self.kwargs)
    self._adapt_input_dim(x)
    x_t = dict2tensor(x, features=self.observed_features, device=self.device)

    self.module.eval()
    with torch.inference_mode():
        y_pred = self.module(x_t).item()
    return y_pred

RegressorInitialized

RegressorInitialized(
    module: Module,
    loss_fn: Union[str, Callable],
    optimizer_fn: Union[str, Type[Optimizer]],
    lr: float = 0.001,
    output_is_logit: bool = True,
    is_feature_incremental: bool = False,
    device: str = "cpu",
    seed: int = 42,
    **kwargs
)

Bases: DeepEstimatorInitialized, MiniBatchRegressor

Wrapper for PyTorch classification models that supports feature and class incremental learning.

Parameters:

Name	Type	Description	Default
module	Module	A PyTorch model. Can be pre-initialized or uninitialized.	required
loss_fn	Union[str, Callable]	Loss function for training. Can be a string ('mse', 'cross_entropy', etc.) or a PyTorch function.	required
optimizer_fn	Union[str, Type[Optimizer]]	Optimizer for training (e.g., "adam", "sgd", or a PyTorch optimizer class).	required
lr	float	Learning rate of the optimizer.	0.001
output_is_logit	bool	If True, applies softmax/sigmoid during inference.	True
is_class_incremental	bool	If True, adds neurons when new classes appear.	False
is_feature_incremental	bool	If True, adds neurons when new features appear.	False
device	str	Whether to use "cpu" or "cuda".	"cpu"
seed	Optional[int]	Random seed for reproducibility.	None
**kwargs		Additional parameters for model initialization.	{}

Methods:

Name	Description
predict_many	Predicts probabilities for multiple examples.
predict_one	Predicts the target value for a single example.

Source code in deep_river/regression/regressor.py

def __init__(
    self,
    module: nn.Module,
    loss_fn: Union[str, Callable],
    optimizer_fn: Union[str, Type[optim.Optimizer]],
    lr: float = 0.001,
    output_is_logit: bool = True,
    is_feature_incremental: bool = False,
    device: str = "cpu",
    seed: int = 42,
    **kwargs,
):
    super().__init__(
        module=module,
        loss_fn=loss_fn,
        optimizer_fn=optimizer_fn,
        device=device,
        lr=lr,
        is_feature_incremental=is_feature_incremental,
        seed=seed,
        **kwargs,
    )
    self.output_is_logit = output_is_logit

predict_many

predict_many(X: DataFrame) -> DataFrame

Predicts probabilities for multiple examples.

Source code in deep_river/regression/regressor.py

def predict_many(self, X: pd.DataFrame) -> pd.DataFrame:
    """Predicts probabilities for multiple examples."""
    self._update_observed_features(X)
    x_t = self._df2tensor(X)
    self.module.eval()
    with torch.inference_mode():
        y_preds = self.module(x_t)
    return pd.DataFrame(y_preds if not y_preds.is_cuda else y_preds.cpu().numpy())

predict_one

predict_one(x: dict) -> RegTarget

Predicts the target value for a single example.

Parameters:

Name	Type	Description	Default
x	dict	Input example.	required

Returns:

Type	Description
RegTarget	Predicted target value.

Source code in deep_river/regression/regressor.py

def predict_one(self, x: dict) -> RegTarget:
    """
    Predicts the target value for a single example.

    Parameters
    ----------
    x
        Input example.

    Returns
    -------
    RegTarget
        Predicted target value.
    """
    self._update_observed_features(x)
    x_t = self._dict2tensor(x)
    self.module.eval()
    with torch.inference_mode():
        y_pred = self.module(x_t).item()
    return y_pred