Implementation:Online ml River NeuralNet MLPRegressor
| Knowledge Sources | |
|---|---|
| Domains | Online_Learning, Neural_Networks, Deep_Learning |
| Last Updated | 2026-02-08 16:00 GMT |
Overview
Multi-layer Perceptron regressor implementing feedforward neural networks with backpropagation for online regression tasks.
Description
This implementation provides a fully connected neural network with configurable hidden layers and activation functions. The forward pass computes outputs layer by layer, storing intermediate activations. Backpropagation then calculates gradients in reverse order and updates weights using specified optimizers (one per layer). Xavier initialization ensures stable weight values. The model supports both single-instance (learn_one) and mini-batch (learn_many) training, though single-instance operations currently convert to batch mode internally for efficiency reasons.
Usage
Use MLP regressor for complex non-linear regression problems where linear models underperform. Specify hidden layer dimensions as a tuple (e.g., (10, 20) for two hidden layers). Choose activation functions per layer including input, hidden, and output layers. ReLU is common for hidden layers; use Identity for output. The model works best with StandardScaler preprocessing. Note that emerging/disappearing features are not supported - all instances must have the same features.
Code Reference
Source Location
- Repository: Online_ml_River
- File: river/neural_net/mlp.py
Signature
class MLPRegressor(base.Regressor, MLP):
def __init__(
self,
hidden_dims,
activations,
loss: optim.losses.Loss | None = None,
optimizer: optim.base.Optimizer | None = None,
seed: int | None = None,
):
super().__init__(
hidden_dims=hidden_dims,
activations=activations,
loss=loss or optim.losses.Squared(),
optimizer=optimizer or optim.SGD(0.01),
seed=seed,
)
Import
from river import neural_net as nn
I/O Contract
Parameters
| Parameter | Type | Default | Description |
|---|---|---|---|
| hidden_dims | tuple[int] | required | Dimensions of hidden layers |
| activations | tuple | required | Activation functions per layer (including I/O) |
| loss | Loss or None | Squared() | Loss function to optimize |
| optimizer | Optimizer or None | SGD(0.01) | Optimizer for weight updates |
| seed | int or None | None | Random seed for initialization |
Attributes
| Attribute | Type | Description |
|---|---|---|
| w | dict | Weight matrices per layer |
| b | dict | Bias vectors per layer |
| features | ndarray | Feature names (sorted) |
| targets | ndarray | Target names |
Input/Output
| Method | Input | Output |
|---|---|---|
| learn_one | x: dict, y: float or dict | None |
| predict_one | x: dict | float or dict |
| learn_many | X: DataFrame, y: Series/DataFrame | None |
| predict_many | X: DataFrame | DataFrame |
Usage Examples
from river import datasets
from river import evaluate
from river import neural_net as nn
from river import optim
from river import preprocessing as pp
from river import metrics
# Single instance learning
model = (
pp.StandardScaler() |
nn.MLPRegressor(
hidden_dims=(5,),
activations=(
nn.activations.ReLU,
nn.activations.ReLU,
nn.activations.Identity
),
optimizer=optim.SGD(1e-3),
seed=42
)
)
dataset = datasets.TrumpApproval()
metric = metrics.MAE()
evaluate.progressive_val_score(dataset, model, metric)
# MAE: 1.580578
# Mini-batch learning
import pandas as pd
model = (
pp.StandardScaler() |
nn.MLPRegressor(
hidden_dims=(10,),
activations=(
nn.activations.ReLU,
nn.activations.ReLU,
nn.activations.ReLU
),
optimizer=optim.SGD(1e-4),
seed=42
)
)
dataset = datasets.TrumpApproval()
batch_size = 32
for epoch in range(10):
for xb in pd.read_csv(dataset.path, chunksize=batch_size):
yb = xb.pop('five_thirty_eight')
y_pred = model.predict_many(xb)
model.learn_many(xb, yb)
model.predict_many(xb)
# Returns predictions for last batch