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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deep_river
-Version: 0.3.1
+Version: 0.3.2
 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
@@ -70,8 +70,9 @@ Dynamic: license-file
 </p>
 <p align="center">
     <img alt="PyPI" src="https://img.shields.io/pypi/v/deep-river">
-    <a href="https://codecov.io/gh/online-ml/deep-river" > 
-        <img src="https://codecov.io/gh/online-ml/deep-river/branch/master/graph/badge.svg?token=ZKUIISZAYA"/> 
+    <!-- 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" />
     </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">
@@ -136,209 +137,160 @@ We build the development of neural networks on top of the <a href="https://www.r
 The following example creates a simple MLP architecture based on PyTorch and incrementally predicts and trains on the website phishing dataset.
 For further examples check out the <a href="https://online-ml.github.io/deep-river">Documentation</a>.
 
+
 ### Classification
 
 ```python
->> > from river import metrics, datasets, preprocessing, compose
->> > from deep_river import classification
->> > from torch import nn
->> > from torch import optim
->> > from torch import manual_seed
-
->> > _ = manual_seed(42)
-
->> >
-
-class MyModule(nn.Module):
-
-
-    ...
-
-
-def __init__(self, n_features):
-
-
-    ...
-super(MyModule, self).__init__()
-...
-self.dense0 = nn.Linear(n_features, 5)
-...
-self.nonlin = nn.ReLU()
-...
-self.dense1 = nn.Linear(5, 2)
-...
-self.softmax = nn.Softmax(dim=-1)
-...
-...
-
-
-def forward(self, X, **kwargs):
-
-
-    ...
-X = self.nonlin(self.dense0(X))
-...
-X = self.nonlin(self.dense1(X))
-...
-X = self.softmax(X)
-...
-return X
-
->> > model_pipeline = compose.Pipeline(
-    ...
-preprocessing.StandardScaler(),
-...
-classification.Classifier(module=MyModule(10), loss_fn='binary_cross_entropy',
-                          optimizer_fn='adam')
+>>> import random, numpy as np
+>>> from river import metrics, datasets, preprocessing, compose
+>>> from deep_river.classification import Classifier
+>>> from torch import nn, manual_seed
+>>> _ = manual_seed(42); random.seed(42); np.random.seed(42)
+>>> first_x, _ = next(iter(datasets.Phishing()))
+>>> n_features = len(first_x)
+>>> class MyModule(nn.Module):
+...     def __init__(self, n_features):
+...         super().__init__()
+...         self.net = nn.Sequential(
+...             nn.Linear(n_features, 16),
+...             nn.ReLU(),
+...             nn.Linear(16, 2)
+...         )
+...     def forward(self, x):
+...         return self.net(x)
+>>> model = compose.Pipeline(
+...     preprocessing.StandardScaler(),
+...     Classifier(
+...         module=MyModule(n_features),
+...         loss_fn='cross_entropy',
+...         optimizer_fn='adam',
+...         lr=1e-3,
+...         is_class_incremental=True
+...     )
 ... )
-
->> > dataset = datasets.Phishing()
->> > metric = metrics.Accuracy()
-
->> > 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():.4f}")
-Accuracy: 0.7264
+>>> metric = metrics.Accuracy()
+>>> for i, (x, y) in enumerate(datasets.Phishing().take(200)):
+...     if i > 0:
+...         y_pred = model.predict_one(x)
+...         metric.update(y, y_pred)
+...     model.learn_one(x, y)
+>>> assert 0.5 <= metric.get() <= 1.0
+>>> print(f"Accuracy: {metric.get():.4f}")  # doctest: +ELLIPSIS
+Accuracy: ...
 
 ```
+
 ### Multi Target Regression
 
 ```python
->> > from river import evaluate, compose
->> > from river import metrics
->> > from river import preprocessing
->> > from river import stream
->> > from sklearn import datasets
->> > from torch import nn
->> > from deep_river.regression.multioutput import MultiTargetRegressor
-
->> >
-
-class MyModule(nn.Module):
-
-
-    ...
-
-
-def __init__(self, n_features):
-
-
-    ...
-super(MyModule, self).__init__()
-...
-self.dense0 = nn.Linear(n_features, 3)
-...
-...
-
-
-def forward(self, X, **kwargs):
-
-
-    ...
-X = self.dense0(X)
-...
-return X
-
->> > dataset = stream.iter_sklearn_dataset(
-    ...
-dataset = datasets.load_linnerud(),
-...
-shuffle = True,
-...
-seed = 42
+>>> import random, numpy as np
+>>> from river import stream, metrics, preprocessing, compose
+>>> from sklearn import datasets as sk_datasets
+>>> from deep_river.regression import MultiTargetRegressor
+>>> from torch import nn, manual_seed
+>>> _ = manual_seed(42); random.seed(42); np.random.seed(42)
+>>> linnerud_stream = stream.iter_sklearn_dataset(sk_datasets.load_linnerud(), shuffle=True, seed=42)
+>>> first_x, first_y = next(iter(linnerud_stream))
+>>> n_features, n_outputs = len(first_x), len(first_y)
+>>> class TinyNet(nn.Module):
+...     def __init__(self, n_features, n_outputs):
+...         super().__init__()
+...         self.net = nn.Sequential(
+...             nn.Linear(n_features, 16),
+...             nn.ReLU(),
+...             nn.Linear(16, n_outputs)
+...         )
+...     def forward(self, x):
+...         return self.net(x)
+>>> model = compose.Pipeline(
+...     preprocessing.StandardScaler(),  # feature scaling stabilizes training
+...     MultiTargetRegressor(
+...         module=TinyNet(n_features, n_outputs),
+...         loss_fn='mse', optimizer_fn='adam', lr=5e-3,
+...         is_feature_incremental=False, is_target_incremental=False,
+...         gradient_clip_value=1.0,
 ...     )
->> > model = compose.Pipeline(
-    ...
-preprocessing.StandardScaler(),
-...
-MultiTargetRegressorInitialized(
-    ...
-module = MyModule(10),
-...
-loss_fn = 'mse',
-...
-lr = 0.3,
-...
-optimizer_fn = 'sgd',
-...     ))
->> > metric = metrics.multioutput.MicroAverage(metrics.MAE())
->> > ev = evaluate.progressive_val_score(dataset, model, metric)
->> > print(f"MicroAverage(MAE): {metric.get():.2f}")
-MicroAverage(MAE): 34.31
+... )
+>>> mae_micro = metrics.multioutput.MicroAverage(metrics.MAE())
+>>> mae_macro = metrics.multioutput.MacroAverage(metrics.MAE())
+>>> rmse_micro = metrics.multioutput.MicroAverage(metrics.RMSE())
+>>> # Recreate the iterator (the first sample was consumed to infer shapes)
+>>> linnerud_stream = stream.iter_sklearn_dataset(sk_datasets.load_linnerud(), shuffle=True, seed=42)
+>>> for i, (x, y_dict) in enumerate(linnerud_stream):
+...     if i > 0:
+...         y_pred = model.predict_one(x)
+...         mae_micro.update(y_dict, y_pred)
+...         mae_macro.update(y_dict, y_pred)
+...         rmse_micro.update(y_dict, y_pred)
+...     model.learn_one(x, y_dict)
+>>> assert 0.0 <= mae_micro.get() < 300.0
+>>> assert 0.0 <= mae_macro.get() < 300.0
+>>> assert 0.0 <= rmse_micro.get() < 400.0
+>>> print({
+...     'MAE_micro': round(mae_micro.get(), 4),
+...     'MAE_macro': round(mae_macro.get(), 4),
+...     'RMSE_micro': round(rmse_micro.get(), 4)
+... })  # doctest: +ELLIPSIS
+{'MAE_micro': ..., 'MAE_macro': ..., 'RMSE_micro': ...}
 
 ```
 
 ### Anomaly Detection
 
 ```python
->> > from deep_river.anomaly import Autoencoder
->> > from river import metrics
->> > from river.datasets import CreditCard
->> > from torch import nn
->> > import math
->> > from river.compose import Pipeline
->> > from river.preprocessing import MinMaxScaler
-
->> > dataset = CreditCard().take(5000)
->> > metric = metrics.RollingROCAUC(window_size=5000)
-
->> >
-
-class MyAutoEncoder(nn.Module):
-
-
-    ...
-
-
-def __init__(self, n_features, latent_dim=3):
-
-
-    ...
-super(MyAutoEncoder, self).__init__()
-...
-self.linear1 = nn.Linear(n_features, latent_dim)
-...
-self.nonlin = nn.LeakyReLU()
-...
-self.linear2 = nn.Linear(latent_dim, n_features)
-...
-self.sigmoid = nn.Sigmoid()
-...
-...
-
-
-def forward(self, X, **kwargs):
-
-
-    ...
-X = self.linear1(X)
-...
-X = self.nonlin(X)
-...
-X = self.linear2(X)
-...
-return self.sigmoid(X)
-
->> > ae = AutoencoderInitialized(module=MyAutoEncoder(10), lr=0.005)
->> > scaler = MinMaxScaler()
->> > model = Pipeline(scaler, ae)
-
->> > for x, y in dataset:
-    ...
-score = model.score_one(x)
-...
-model.learn_one(x=x)
-...
-metric.update(y, score)
-...
->> > print(f"Rolling ROCAUC: {metric.get():.4f}")
-Rolling
-ROCAUC: 0.8901
+>>> import random, numpy as np
+>>> from torch import nn, manual_seed
+>>> from river import metrics
+>>> from deep_river.anomaly import Autoencoder
+>>> _ = manual_seed(42); random.seed(42); np.random.seed(42)
+>>> # Create a deterministic synthetic stream: normals (y=0) vs. anomalies (y=1)
+>>> def synthetic_stream(n_norm=2000, n_anom=200, n_features=8, seed=42):
+...     rng = np.random.default_rng(seed)
+...     # Normals around 0, anomalies shifted
+...     X_norm = rng.normal(loc=0.0, scale=1.0, size=(n_norm, n_features))
+...     y_norm = np.zeros(n_norm, dtype=int)
+...     X_anom = rng.normal(loc=5.0, scale=1.0, size=(n_anom, n_features))
+...     y_anom = np.ones(n_anom, dtype=int)
+...     # Interleave anomalies every k steps to keep streaming flavour
+...     k = max(1, n_norm // n_anom)
+...     X, Y = [], []
+...     i_norm = i_anom = 0
+...     for t in range(n_norm + n_anom):
+...         take_anom = (t % k == 0) and (i_anom < n_anom)
+...         if take_anom:
+...             X.append(X_anom[i_anom]); Y.append(y_anom[i_anom]); i_anom += 1
+...         else:
+...             if i_norm < n_norm:
+...                 X.append(X_norm[i_norm]); Y.append(y_norm[i_norm]); i_norm += 1
+...             elif i_anom < n_anom:
+...                 X.append(X_anom[i_anom]); Y.append(y_anom[i_anom]); i_anom += 1
+...     for row, label in zip(X, Y):
+...         yield {f"f{i}": float(v) for i, v in enumerate(row)}, int(label)
+>>> n_features = 8
+>>> class MyAutoEncoder(nn.Module):
+...     def __init__(self, n_features, latent_dim=4):
+...         super().__init__()
+...         self.encoder = nn.Sequential(
+...             nn.Linear(n_features, latent_dim),
+...             nn.LeakyReLU()
+...         )
+...         self.decoder = nn.Sequential(
+...             nn.Linear(latent_dim, n_features),
+...             nn.Sigmoid()
+...         )
+...     def forward(self, x):
+...         z = self.encoder(x)
+...         return self.decoder(z)
+>>> ae = Autoencoder(module=MyAutoEncoder(n_features), lr=5e-3, optimizer_fn='adam')
+>>> metric = metrics.ROCAUC()
+>>> # Train only on normal samples to keep the model focused on the normal manifold
+>>> for x, y in synthetic_stream(n_norm=2000, n_anom=200, n_features=n_features, seed=42):
+...     score = ae.score_one(x)
+...     if y == 0:
+...         ae.learn_one(x)
+...     metric.update(y, score)
+>>> print(f"ROCAUC: {metric.get():.4f}")  # doctest: +ELLIPSIS
+ROCAUC: ...
 
 ```
 
@@ -361,7 +313,6 @@ To acknowledge the use of the `DeepRiver` library in your research, please refer
 }
 ```
 
-
 ## 🏫 Affiliations
 
 <p align="center">

deep_river-0.3.2/README.md

@@ -0,0 +1,257 @@
+<p align="center">
+  <img height="150px" src="https://raw.githubusercontent.com/online-ml/deep-river/master/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" />
+    </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">
+    <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>
+    <a href="https://doi.org/10.5281/zenodo.14601980"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.14601980.svg" alt="DOI"></a>
+</p>
+<p align="center">
+    deep-river is a Python library for online deep learning.
+    deep-river's ambition is to enable <a href="https://www.wikiwand.com/en/Online_machine_learning">online machine learning</a> for neural networks.
+    It combines the <a href="https://www.riverml.xyz">river</a> API with the capabilities of designing neural networks based on <a href="https://pytorch.org">PyTorch</a>.
+</p>
+
+## 📚 [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.
+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
+
+```shell
+pip install deep-river
+```
+or
+```shell
+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
+```
+
+### Development Environment
+
+For contributing to deep-river, we recommend using [uv](https://docs.astral.sh/uv/) for fast dependency management and environment setup:
+
+```shell
+# Install uv if you haven't already
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Clone the repository
+git clone https://github.com/online-ml/deep-river.git
+cd deep-river
+
+# Install all dependencies (including dev dependencies)
+uv sync --extra dev
+
+# Run tests
+make test
+
+# Format code
+make format
+
+# Build documentation
+make doc
+```
+
+## 🍫 Quickstart
+
+We build the development of neural networks on top of the <a href="https://www.riverml.xyz">river API</a> and refer to the rivers design principles.
+The following example creates a simple MLP architecture based on PyTorch and incrementally predicts and trains on the website phishing dataset.
+For further examples check out the <a href="https://online-ml.github.io/deep-river">Documentation</a>.
+
+
+### Classification
+
+```python
+>>> import random, numpy as np
+>>> from river import metrics, datasets, preprocessing, compose
+>>> from deep_river.classification import Classifier
+>>> from torch import nn, manual_seed
+>>> _ = manual_seed(42); random.seed(42); np.random.seed(42)
+>>> first_x, _ = next(iter(datasets.Phishing()))
+>>> n_features = len(first_x)
+>>> class MyModule(nn.Module):
+...     def __init__(self, n_features):
+...         super().__init__()
+...         self.net = nn.Sequential(
+...             nn.Linear(n_features, 16),
+...             nn.ReLU(),
+...             nn.Linear(16, 2)
+...         )
+...     def forward(self, x):
+...         return self.net(x)
+>>> model = compose.Pipeline(
+...     preprocessing.StandardScaler(),
+...     Classifier(
+...         module=MyModule(n_features),
+...         loss_fn='cross_entropy',
+...         optimizer_fn='adam',
+...         lr=1e-3,
+...         is_class_incremental=True
+...     )
+... )
+>>> metric = metrics.Accuracy()
+>>> for i, (x, y) in enumerate(datasets.Phishing().take(200)):
+...     if i > 0:
+...         y_pred = model.predict_one(x)
+...         metric.update(y, y_pred)
+...     model.learn_one(x, y)
+>>> assert 0.5 <= metric.get() <= 1.0
+>>> print(f"Accuracy: {metric.get():.4f}")  # doctest: +ELLIPSIS
+Accuracy: ...
+
+```
+
+### Multi Target Regression
+
+```python
+>>> import random, numpy as np
+>>> from river import stream, metrics, preprocessing, compose
+>>> from sklearn import datasets as sk_datasets
+>>> from deep_river.regression import MultiTargetRegressor
+>>> from torch import nn, manual_seed
+>>> _ = manual_seed(42); random.seed(42); np.random.seed(42)
+>>> linnerud_stream = stream.iter_sklearn_dataset(sk_datasets.load_linnerud(), shuffle=True, seed=42)
+>>> first_x, first_y = next(iter(linnerud_stream))
+>>> n_features, n_outputs = len(first_x), len(first_y)
+>>> class TinyNet(nn.Module):
+...     def __init__(self, n_features, n_outputs):
+...         super().__init__()
+...         self.net = nn.Sequential(
+...             nn.Linear(n_features, 16),
+...             nn.ReLU(),
+...             nn.Linear(16, n_outputs)
+...         )
+...     def forward(self, x):
+...         return self.net(x)
+>>> model = compose.Pipeline(
+...     preprocessing.StandardScaler(),  # feature scaling stabilizes training
+...     MultiTargetRegressor(
+...         module=TinyNet(n_features, n_outputs),
+...         loss_fn='mse', optimizer_fn='adam', lr=5e-3,
+...         is_feature_incremental=False, is_target_incremental=False,
+...         gradient_clip_value=1.0,
+...     )
+... )
+>>> mae_micro = metrics.multioutput.MicroAverage(metrics.MAE())
+>>> mae_macro = metrics.multioutput.MacroAverage(metrics.MAE())
+>>> rmse_micro = metrics.multioutput.MicroAverage(metrics.RMSE())
+>>> # Recreate the iterator (the first sample was consumed to infer shapes)
+>>> linnerud_stream = stream.iter_sklearn_dataset(sk_datasets.load_linnerud(), shuffle=True, seed=42)
+>>> for i, (x, y_dict) in enumerate(linnerud_stream):
+...     if i > 0:
+...         y_pred = model.predict_one(x)
+...         mae_micro.update(y_dict, y_pred)
+...         mae_macro.update(y_dict, y_pred)
+...         rmse_micro.update(y_dict, y_pred)
+...     model.learn_one(x, y_dict)
+>>> assert 0.0 <= mae_micro.get() < 300.0
+>>> assert 0.0 <= mae_macro.get() < 300.0
+>>> assert 0.0 <= rmse_micro.get() < 400.0
+>>> print({
+...     'MAE_micro': round(mae_micro.get(), 4),
+...     'MAE_macro': round(mae_macro.get(), 4),
+...     'RMSE_micro': round(rmse_micro.get(), 4)
+... })  # doctest: +ELLIPSIS
+{'MAE_micro': ..., 'MAE_macro': ..., 'RMSE_micro': ...}
+
+```
+
+### Anomaly Detection
+
+```python
+>>> import random, numpy as np
+>>> from torch import nn, manual_seed
+>>> from river import metrics
+>>> from deep_river.anomaly import Autoencoder
+>>> _ = manual_seed(42); random.seed(42); np.random.seed(42)
+>>> # Create a deterministic synthetic stream: normals (y=0) vs. anomalies (y=1)
+>>> def synthetic_stream(n_norm=2000, n_anom=200, n_features=8, seed=42):
+...     rng = np.random.default_rng(seed)
+...     # Normals around 0, anomalies shifted
+...     X_norm = rng.normal(loc=0.0, scale=1.0, size=(n_norm, n_features))
+...     y_norm = np.zeros(n_norm, dtype=int)
+...     X_anom = rng.normal(loc=5.0, scale=1.0, size=(n_anom, n_features))
+...     y_anom = np.ones(n_anom, dtype=int)
+...     # Interleave anomalies every k steps to keep streaming flavour
+...     k = max(1, n_norm // n_anom)
+...     X, Y = [], []
+...     i_norm = i_anom = 0
+...     for t in range(n_norm + n_anom):
+...         take_anom = (t % k == 0) and (i_anom < n_anom)
+...         if take_anom:
+...             X.append(X_anom[i_anom]); Y.append(y_anom[i_anom]); i_anom += 1
+...         else:
+...             if i_norm < n_norm:
+...                 X.append(X_norm[i_norm]); Y.append(y_norm[i_norm]); i_norm += 1
+...             elif i_anom < n_anom:
+...                 X.append(X_anom[i_anom]); Y.append(y_anom[i_anom]); i_anom += 1
+...     for row, label in zip(X, Y):
+...         yield {f"f{i}": float(v) for i, v in enumerate(row)}, int(label)
+>>> n_features = 8
+>>> class MyAutoEncoder(nn.Module):
+...     def __init__(self, n_features, latent_dim=4):
+...         super().__init__()
+...         self.encoder = nn.Sequential(
+...             nn.Linear(n_features, latent_dim),
+...             nn.LeakyReLU()
+...         )
+...         self.decoder = nn.Sequential(
+...             nn.Linear(latent_dim, n_features),
+...             nn.Sigmoid()
+...         )
+...     def forward(self, x):
+...         z = self.encoder(x)
+...         return self.decoder(z)
+>>> ae = Autoencoder(module=MyAutoEncoder(n_features), lr=5e-3, optimizer_fn='adam')
+>>> metric = metrics.ROCAUC()
+>>> # Train only on normal samples to keep the model focused on the normal manifold
+>>> for x, y in synthetic_stream(n_norm=2000, n_anom=200, n_features=n_features, seed=42):
+...     score = ae.score_one(x)
+...     if y == 0:
+...         ae.learn_one(x)
+...     metric.update(y, score)
+>>> print(f"ROCAUC: {metric.get():.4f}")  # doctest: +ELLIPSIS
+ROCAUC: ...
+
+```
+
+## 💬 Citation
+
+To acknowledge the use of the `DeepRiver` library in your research, please refer to our [paper](https://joss.theoj.org/papers/10.21105/joss.07226) published on Journal of Open Source Software (JOSS):
+
+```bibtex
+@article{Kulbach2025, 
+    doi = {10.21105/joss.07226}, 
+    url = {https://doi.org/10.21105/joss.07226}, 
+    year = {2025}, 
+    publisher = {The Open Journal}, 
+    volume = {10}, 
+    number = {105}, 
+    pages = {7226}, 
+    author = {Cedric Kulbach and Lucas Cazzonelli and Hoang-Anh Ngo and Max Halford and Saulo Martiello Mastelini}, 
+    title = {DeepRiver: A Deep Learning Library for Data Streams}, 
+    journal = {Journal of Open Source Software} 
+}
+```
+
+## 🏫 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"/>
+</p>
+
+<p align="center">
+    <img src="https://lieferbotnet.de/wp-content/uploads/2022/09/LieferBotNet-Logo.png?raw=true" alt="Lieferbot net" height="200"/>
+</p>

{deep_river-0.3.1 → deep_river-0.3.2}/deep_river/__version__.py

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

deep_river-0.3.2/deep_river/classification/__init__.py

@@ -0,0 +1,22 @@
+from deep_river.classification.classifier import Classifier
+from deep_river.classification.rolling_classifier import (
+    RollingClassifier,
+)
+from deep_river.classification.zoo import (
+    LogisticRegression,
+    LSTMClassifier,
+    MultiLayerPerceptron,
+    RNNClassifier,
+)
+
+"""
+This module contains the classifiers for the deep_river package.
+"""
+__all__ = [
+    "Classifier",
+    "RollingClassifier",
+    "LogisticRegression",
+    "MultiLayerPerceptron",
+    "LSTMClassifier",
+    "RNNClassifier",
+]