rolling_classifier

RollingClassifier(module, loss_fn='binary_cross_entropy_with_logits', optimizer_fn='sgd', lr=0.001, output_is_logit=True, is_class_incremental=False, is_feature_incremental=False, device='cpu', seed=42, window_size=10, append_predict=False, **kwargs)

Bases: Classifier, RollingDeepEstimator

Wrapper that feeds a sliding window of the most recent examples to the wrapped PyTorch classification model. The class also automatically handles increases in the number of classes by adding output neurons in case the number of observed classes exceeds the current number of output neurons.

PARAMETER	DESCRIPTION
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. TYPE: Type[Module]
loss_fn	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'. TYPE: Union[str, Callable] DEFAULT: 'binary_cross_entropy_with_logits'
optimizer_fn	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". TYPE: Union[str, Callable] DEFAULT: 'sgd'
lr	Learning rate of the optimizer. TYPE: float DEFAULT: 0.001
output_is_logit	Whether the module produces logits as output. If true, either softmax or sigmoid is applied to the outputs when predicting. TYPE: bool DEFAULT: True
is_class_incremental	Whether the classifier should adapt to the appearance of previously unobserved classes by adding an unit to the output layer of the network. This works only if the last trainable layer is an nn.Linear layer. Note also, that output activation functions can not be adapted, meaning that a binary classifier with a sigmoid output can not be altered to perform multi-class predictions. TYPE: bool DEFAULT: False
is_feature_incremental	Whether the model should adapt to the appearance of previously features by adding units to the input layer of the network. TYPE: bool DEFAULT: False
device	Device to run the wrapped model on. Can be "cpu" or "cuda". TYPE: str DEFAULT: 'cpu'
seed	Random seed to be used for training the wrapped model. TYPE: int DEFAULT: 42
window_size	Number of recent examples to be fed to the wrapped model at each step. TYPE: int DEFAULT: 10
append_predict	Whether to append inputs passed for prediction to the rolling window. TYPE: bool DEFAULT: False
**kwargs	Parameters to be passed to the build_fn function aside from n_features. DEFAULT: {}

learn_many(X, y)

Performs one step of training with the most recent training examples stored in the sliding window.

PARAMETER	DESCRIPTION
X	Input examples. TYPE: DataFrame
y	Target values. TYPE: Series

RETURNS	DESCRIPTION
Classifier	The classifier itself.

learn_one(x, y, **kwargs)

Performs one step of training with the most recent training examples stored in the sliding window.

PARAMETER	DESCRIPTION
x	Input example. TYPE: dict
y	Target value. TYPE: ClfTarget

RETURNS	DESCRIPTION
Classifier	The classifier itself.

predict_proba_many(x)

Predict the probability of each label given the most recent examples

PARAMETER	DESCRIPTION
x	TYPE: DataFrame

RETURNS	DESCRIPTION
DataFrame	DataFrame of probabilities for each label.

predict_proba_one(x)

Predict the probability of each label given the most recent examples stored in the sliding window.

PARAMETER	DESCRIPTION
x	Input example. TYPE: dict

RETURNS	DESCRIPTION
Dict[ClfTarget, float]	Dictionary of probabilities for each label.

RollingClassifierInitialized(module, loss_fn='binary_cross_entropy_with_logits', optimizer_fn='sgd', lr=0.001, output_is_logit=True, is_class_incremental=False, is_feature_incremental=False, device='cpu', seed=42, window_size=10, append_predict=False, **kwargs)

Bases: ClassifierInitialized, RollingDeepEstimatorInitialized

RollingClassifierInitialized extends both ClassifierInitialized and RollingDeepEstimatorInitialized, incorporating a rolling window mechanism for sequential learning in an evolving feature and class space.

This classifier dynamically adapts to new features and classes over time while leveraging a rolling window for training. It supports single-instance and batch learning while maintaining adaptability.

ATTRIBUTE	DESCRIPTION
module	The PyTorch model used for classification. TYPE: Module
loss_fn	The loss function for training, defaulting to binary cross-entropy with logits. TYPE: Union[str, Callable]
optimizer_fn	The optimizer function or class used for training. TYPE: Union[str, Type[Optimizer]]
lr	The learning rate for optimization. TYPE: float
output_is_logit	Indicates whether model outputs logits or probabilities. TYPE: bool
is_class_incremental	Whether new classes should be dynamically added. TYPE: bool
is_feature_incremental	Whether new features should be dynamically added. TYPE: bool
device	The computational device for training (e.g., "cpu", "cuda"). TYPE: str
seed	The random seed for reproducibility. TYPE: int
window_size	The number of past instances considered in the rolling window. TYPE: int
append_predict	Whether predictions should be appended to the rolling window. TYPE: bool
observed_classes	Tracks observed class labels for incremental learning. TYPE: SortedSet

Examples:

>>> from deep_river.classification import RollingClassifier
>>> from river import metrics, preprocessing, datasets, compose
>>> import torch

>>> class RnnModule(torch.nn.Module):
... def __init__(self, n_features, hidden_size=1):
...     super().__init__()
...     self.n_features = n_features
...     self.rnn = torch.nn.RNN(
...         input_size=n_features, hidden_size=hidden_size, num_layers=1
...     )
...     self.softmax = torch.nn.Softmax(dim=-1)
...
... def forward(self, X, **kwargs):
...     out, hn = self.rnn(X)  # lstm with input, hidden, and internal state
...     hn = hn.view(-1, self.rnn.hidden_size)
...     return self.softmax(hn)

>>> model_pipeline = compose.Pipeline(
...     preprocessing.StandardScaler,
...     RollingClassifierInitialized(module=RnnModule(10,1),
...                loss_fn="binary_cross_entropy",
...                optimizer_fn='adam')
... )

>>> dataset = datasets.Keystroke()
>>> metric = metrics.Accuracy()
>>> optimizer_fn = torch.optim.SGD

>>> model_pipeline = preprocessing.StandardScaler()
>>> model_pipeline |= RollingClassifier(
...    module=RnnModule,
...    loss_fn="binary_cross_entropy",
...    optimizer_fn=torch.optim.SGD,
...    window_size=20,
...    lr=1e-2,
...    append_predict=True,
...    is_class_incremental=False,
... )

>>> for x, y in dataset:
...     y_pred = model_pipeline.predict_one(x)  # make a prediction
...     metric.update(y, y_pred)  # update the metric
...     model_pipeline.learn_one(x, y)  # make the model learn
>>> print(f"Accuracy: {metric.get():.2f}")

learn_many(X, y)

Learns from multiple examples using the rolling window.

learn_one(x, y, **kwargs)

Learns from one example using the rolling window.

predict_proba_many(X)

Predicts probabilities for many examples.

predict_proba_one(x)

Predicts class probabilities using the rolling window.