diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index f47a804..0f90bdd 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -43,6 +43,6 @@ jobs: run: python -c "from river import datasets; datasets.CreditCard().download(); datasets.Elec2().download(); datasets.Keystroke().download()" - name: pytest - run: pytest --cov=river_torch -m "not datasets" + run: pytest --cov=deep_river -m "not datasets" - name: Upload coverage reports to Codecov with GitHub Action uses: codecov/codecov-action@v2 diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 9bb897b..f575d46 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,4 +1,4 @@ -files: river_torch +files: deep_river repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.2.0 diff --git a/README.md b/README.md index 71ad6db..c8f8197 100644 --- a/README.md +++ b/README.md @@ -1,46 +1,46 @@

- incremental dl logo + incremental dl logo

- PyPI - - + PyPI + + - PyPI - Downloads - GitHub + PyPI - Downloads + GitHub

- river-torch is a Python library for online deep learning. - River-torch's ambition is to enable online machine learning for neural networks. + deep-river is a Python library for online deep learning. + deep-river's ambition is to enable online machine learning for neural networks. It combines the river API with the capabilities of designing neural networks based on PyTorch.

## πŸ’ˆ Installation ```shell -pip install river-torch +pip install deep-river ``` or ```shell -pip install "river[torch]" +pip install "river[deep]" ``` You can install the latest development version from GitHub as so: ```shell -pip install https://github.com/online-ml/river-torch/archive/refs/heads/master.zip +pip install https://github.com/online-ml/deep-river/archive/refs/heads/master.zip ``` ## 🍫 Quickstart We build the development of neural networks on top of the river API 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 Documentation. +For further examples check out the Documentation. ### Classification ```python >>> from river import metrics, datasets, preprocessing, compose ->>> from river_torch import classification +>>> from deep_river import classification >>> from torch import nn >>> from torch import optim >>> from torch import manual_seed @@ -72,7 +72,7 @@ For further examples check out the >> from river_torch.anomaly import Autoencoder +>>> from deep_river.anomaly import Autoencoder >>> from river import metrics >>> from river.datasets import CreditCard >>> from torch import nn @@ -111,9 +111,9 @@ Accuracy: 0.6728 >>> model = Pipeline(scaler, ae) >>> for x, y in dataset: -... score = model.score_one(x) -... model = model.learn_one(x=x) -... metric = metric.update(y, score) +... score = model.score_one(x) +... model = model.learn_one(x=x) +... metric = metric.update(y, score) ... >>> print(f"ROCAUC: {metric.get():.4f}") ROCAUC: 0.7447 diff --git a/check.ipynb b/check.ipynb deleted file mode 100644 index 9770eb6..0000000 --- a/check.ipynb +++ /dev/null @@ -1,128 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Accuracy: 0.6512\n" - ] - } - ], - "source": [ - "from river import metrics, preprocessing, compose, datasets\n", - "from river_torch import classification\n", - "from torch import nn\n", - "from torch import manual_seed\n", - "\n", - "_ = manual_seed(42)\n", - "\n", - "class MyModule(nn.Module):\n", - " def __init__(self, n_features):\n", - " super(MyModule, self).__init__()\n", - " self.dense0 = nn.Linear(n_features,5)\n", - " self.nonlin = nn.ReLU()\n", - " self.dense1 = nn.Linear(5, 2)\n", - " self.softmax = nn.Softmax(dim=-1)\n", - " def forward(self, X, **kwargs):\n", - " X = self.nonlin(self.dense0(X))\n", - " X = self.nonlin(self.dense1(X))\n", - " X = self.softmax(X)\n", - " return X\n", - "\n", - "model_pipeline = classification.Classifier(module=MyModule,\n", - " loss_fn=\"binary_cross_entropy\",\n", - " optimizer_fn='adam')\n", - "\n", - "\n", - "\n", - "dataset = datasets.Phishing()\n", - "metric = metrics.Accuracy()\n", - "\n", - "for x, y in dataset:\n", - " y_pred = model_pipeline.predict_one(x) # make a prediction\n", - " metric = metric.update(y, y_pred) # update the metric\n", - " model_pipeline = model_pipeline.learn_one(x,y)\n", - "\n", - "print(f'Accuracy: {metric.get()}')" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "outputs": [ - { - "data": { - "image/svg+xml": "\n\n\n\n\n\n\n\n\n4518249872\n\n ()\n\n\n\n4518415424\n\nMeanBackward0\n------------------\nself_numel:     10\nself_sizes: (5, 2)\n\n\n\n4518415424->4518249872\n\n\n\n\n\n4518413504\n\nSoftmaxBackward0\n----------------------------\ndim   : 18446744073709551615\nresult:       [saved tensor]\n\n\n\n4518413504->4518415424\n\n\n\n\n\n4518415328\n\nReluBackward0\n----------------------\nresult: [saved tensor]\n\n\n\n4518415328->4518413504\n\n\n\n\n\n4518415184\n\nAddmmBackward0\n--------------------------------\nalpha           :              1\nbeta            :              1\nmat1            : [saved tensor]\nmat1_sym_sizes  :         (5, 5)\nmat1_sym_strides:         (5, 1)\nmat2            : [saved tensor]\nmat2_sym_sizes  :         (5, 2)\nmat2_sym_strides:         (1, 5)\n\n\n\n4518415184->4518415328\n\n\n\n\n\n4518412928\n\nAccumulateGrad\n\n\n\n4518412928->4518415184\n\n\n\n\n\n5328388720\n\ndense1.bias\n (2)\n\n\n\n5328388720->4518412928\n\n\n\n\n\n4518412976\n\nReluBackward0\n----------------------\nresult: [saved tensor]\n\n\n\n4518412976->4518415184\n\n\n\n\n\n4518413024\n\nAddmmBackward0\n--------------------------------\nalpha           :              1\nbeta            :              1\nmat1            : [saved tensor]\nmat1_sym_sizes  :         (5, 9)\nmat1_sym_strides:             ()\nmat2            :           None\nmat2_sym_sizes  :         (9, 5)\nmat2_sym_strides:         (1, 9)\n\n\n\n4518413024->4518412976\n\n\n\n\n\n4518412736\n\nAccumulateGrad\n\n\n\n4518412736->4518413024\n\n\n\n\n\n5328388560\n\ndense0.bias\n (5)\n\n\n\n5328388560->4518412736\n\n\n\n\n\n4518412880\n\nTBackward0\n\n\n\n4518412880->4518413024\n\n\n\n\n\n4518412592\n\nAccumulateGrad\n\n\n\n4518412592->4518412880\n\n\n\n\n\n5328388480\n\ndense0.weight\n (5, 9)\n\n\n\n5328388480->4518412592\n\n\n\n\n\n4518413456\n\nTBackward0\n\n\n\n4518413456->4518415184\n\n\n\n\n\n4518415616\n\nAccumulateGrad\n\n\n\n4518415616->4518413456\n\n\n\n\n\n5328388640\n\ndense1.weight\n (2, 5)\n\n\n\n5328388640->4518415616\n\n\n\n\n\n", - "text/plain": "" - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model_pipeline.draw()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 4, - "outputs": [ - { - "data": { - "text/plain": "{'dense0.weight': Parameter containing:\n tensor([[ 0.6163, 0.6062, 0.2020, 0.3562, -0.0089, -0.0448, -0.0024, 0.1695,\n 0.2564],\n [ 0.2298, 0.6903, 0.3647, 0.3497, 0.1688, -0.0575, 0.0620, 0.3075,\n 0.0583],\n [-0.1671, 0.0094, -0.1969, -0.0914, -0.1550, 0.1059, -0.3000, -0.1751,\n -0.0941],\n [-0.2252, 0.0520, -0.2238, 0.3893, -0.0775, 0.5210, 0.1813, 0.2057,\n 0.3228],\n [-0.2302, 0.0371, -0.1207, -0.1402, -0.0536, -0.0104, 0.1163, 0.3848,\n 0.2090]], requires_grad=True),\n 'dense0.bias': Parameter containing:\n tensor([-0.2246, 0.0797, -0.0621, 0.5438, -0.1350], requires_grad=True),\n 'dense1.weight': Parameter containing:\n tensor([[-0.6484, -0.0279, -0.2599, 0.7668, 0.1940],\n [ 0.6540, 0.4322, -0.0743, 0.1886, -0.2932]], requires_grad=True),\n 'dense1.bias': Parameter containing:\n tensor([ 0.2855, -0.2694], requires_grad=True)}" - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dict(model_pipeline.module.named_parameters())" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/river_torch/__init__.py b/deep_river/__init__.py similarity index 100% rename from river_torch/__init__.py rename to deep_river/__init__.py diff --git a/river_torch/__version__.py b/deep_river/__version__.py similarity index 100% rename from river_torch/__version__.py rename to deep_river/__version__.py diff --git a/river_torch/anomaly/__init__.py b/deep_river/anomaly/__init__.py similarity index 100% rename from river_torch/anomaly/__init__.py rename to deep_river/anomaly/__init__.py diff --git a/river_torch/anomaly/ae.py b/deep_river/anomaly/ae.py similarity index 97% rename from river_torch/anomaly/ae.py rename to deep_river/anomaly/ae.py index f2b1e66..9a063e1 100644 --- a/river_torch/anomaly/ae.py +++ b/deep_river/anomaly/ae.py @@ -6,9 +6,9 @@ from river.anomaly.base import AnomalyDetector from torch import nn -from river_torch.base import DeepEstimator -from river_torch.utils import dict2tensor -from river_torch.utils.tensor_conversion import df2tensor +from deep_river.base import DeepEstimator +from deep_river.utils import dict2tensor +from deep_river.utils.tensor_conversion import df2tensor class _TestAutoencoder(torch.nn.Module): @@ -58,7 +58,7 @@ class Autoencoder(DeepEstimator, AnomalyDetector): Examples -------- - >>> from river_torch.anomaly import Autoencoder + >>> from deep_river.anomaly import Autoencoder >>> from river import metrics >>> from river.datasets import CreditCard >>> from torch import nn diff --git a/river_torch/anomaly/probability_weighted_ae.py b/deep_river/anomaly/probability_weighted_ae.py similarity index 97% rename from river_torch/anomaly/probability_weighted_ae.py rename to deep_river/anomaly/probability_weighted_ae.py index e5c7825..5bbe42f 100644 --- a/river_torch/anomaly/probability_weighted_ae.py +++ b/deep_river/anomaly/probability_weighted_ae.py @@ -6,8 +6,8 @@ from river import stats, utils from scipy.special import ndtr -from river_torch.anomaly import ae -from river_torch.utils import dict2tensor +from deep_river.anomaly import ae +from deep_river.utils import dict2tensor class ProbabilityWeightedAutoencoder(ae.Autoencoder): @@ -51,7 +51,7 @@ class ProbabilityWeightedAutoencoder(ae.Autoencoder): Examples -------- - >>> from river_torch.anomaly import ProbabilityWeightedAutoencoder + >>> from deep_river.anomaly import ProbabilityWeightedAutoencoder >>> from river import metrics >>> from river.datasets import CreditCard >>> from torch import nn, manual_seed diff --git a/river_torch/anomaly/rolling_ae.py b/deep_river/anomaly/rolling_ae.py similarity index 98% rename from river_torch/anomaly/rolling_ae.py rename to deep_river/anomaly/rolling_ae.py index 8e98b2b..ddfe82e 100644 --- a/river_torch/anomaly/rolling_ae.py +++ b/deep_river/anomaly/rolling_ae.py @@ -6,8 +6,8 @@ from river import anomaly from torch import nn -from river_torch.base import RollingDeepEstimator -from river_torch.utils.tensor_conversion import deque2rolling_tensor +from deep_river.base import RollingDeepEstimator +from deep_river.utils.tensor_conversion import deque2rolling_tensor class _TestLSTMAutoencoder(nn.Module): diff --git a/river_torch/anomaly/scaler.py b/deep_river/anomaly/scaler.py similarity index 100% rename from river_torch/anomaly/scaler.py rename to deep_river/anomaly/scaler.py diff --git a/river_torch/base.py b/deep_river/base.py similarity index 99% rename from river_torch/base.py rename to deep_river/base.py index d360f1f..90516d7 100644 --- a/river_torch/base.py +++ b/deep_river/base.py @@ -6,7 +6,7 @@ import torch from river import base -from river_torch.utils import get_loss_fn, get_optim_fn +from deep_river.utils import get_loss_fn, get_optim_fn try: from graphviz import Digraph diff --git a/deep_river/classification/__init__.py b/deep_river/classification/__init__.py new file mode 100644 index 0000000..709aa24 --- /dev/null +++ b/deep_river/classification/__init__.py @@ -0,0 +1,7 @@ +from deep_river.classification.classifier import Classifier +from deep_river.classification.rolling_classifier import RollingClassifier + +__all__ = [ + "Classifier", + "RollingClassifier", +] diff --git a/river_torch/classification/classifier.py b/deep_river/classification/classifier.py similarity index 97% rename from river_torch/classification/classifier.py rename to deep_river/classification/classifier.py index 5a4d091..7644788 100644 --- a/river_torch/classification/classifier.py +++ b/deep_river/classification/classifier.py @@ -10,9 +10,9 @@ from torch import nn from torch.utils.hooks import RemovableHandle -from river_torch.base import DeepEstimator -from river_torch.utils.hooks import ForwardOrderTracker, apply_hooks -from river_torch.utils.tensor_conversion import ( +from deep_river.base import DeepEstimator +from deep_river.utils.hooks import ForwardOrderTracker, apply_hooks +from deep_river.utils.tensor_conversion import ( df2tensor, dict2tensor, labels2onehot, @@ -35,7 +35,7 @@ def forward(self, X, **kwargs): return X -class Classifier(DeepEstimator, base.Classifier): +class Classifier(DeepEstimator, base.MiniBatchClassifier): """ Wrapper for PyTorch classification models that automatically handles increases in the number of classes by adding output neurons in case @@ -83,7 +83,7 @@ class Classifier(DeepEstimator, base.Classifier): Examples -------- >>> from river import metrics, preprocessing, compose, datasets - >>> from river_torch import classification + >>> from deep_river import classification >>> from torch import nn >>> from torch import manual_seed @@ -258,7 +258,7 @@ def predict_proba_one(self, x: dict) -> Dict[ClfTarget, float]: y_pred = self.module(x_t) return output2proba( y_pred, self.observed_classes, self.output_is_logit - ) + )[0] def learn_many(self, X: pd.DataFrame, y: pd.Series) -> "Classifier": """ @@ -286,7 +286,7 @@ def learn_many(self, X: pd.DataFrame, y: pd.Series) -> "Classifier": if self.is_class_incremental: self._adapt_output_dim() - return self._learn(x=X, y=y.tolist()) + return self._learn(x=X, y=y) def predict_proba_many(self, X: pd.DataFrame) -> pd.DataFrame: """ @@ -309,7 +309,7 @@ def predict_proba_many(self, X: pd.DataFrame) -> pd.DataFrame: self.module.eval() with torch.inference_mode(): y_preds = self.module(X_t) - return pd.Dataframe(output2proba(y_preds, self.observed_classes)) + return pd.DataFrame(output2proba(y_preds, self.observed_classes)) def _adapt_output_dim(self): out_features_target = ( diff --git a/river_torch/classification/rolling_classifier.py b/deep_river/classification/rolling_classifier.py similarity index 98% rename from river_torch/classification/rolling_classifier.py rename to deep_river/classification/rolling_classifier.py index 7769297..d07d257 100644 --- a/river_torch/classification/rolling_classifier.py +++ b/deep_river/classification/rolling_classifier.py @@ -6,9 +6,9 @@ from river.base.typing import ClfTarget from torch import nn -from river_torch.base import RollingDeepEstimator -from river_torch.classification import Classifier -from river_torch.utils.tensor_conversion import ( +from deep_river.base import RollingDeepEstimator +from deep_river.classification import Classifier +from deep_river.utils.tensor_conversion import ( deque2rolling_tensor, output2proba, ) @@ -80,7 +80,7 @@ class RollingClassifier(Classifier, RollingDeepEstimator): Examples -------- - >>> from river_torch.classification import RollingClassifier + >>> from deep_river.classification import RollingClassifier >>> from river import metrics, datasets, compose, preprocessing >>> import torch @@ -266,7 +266,7 @@ def predict_proba_one(self, x: dict) -> Dict[ClfTarget, float]: if self.append_predict: self._x_window.append(list(x.values())) - return proba + return proba[0] def learn_many(self, X: pd.DataFrame, y: pd.Series) -> "RollingClassifier": """ @@ -333,7 +333,7 @@ def predict_proba_many(self, X: pd.DataFrame) -> pd.DataFrame: probas = [default_proba] * len(X) return pd.DataFrame(probas) - def _get_default_proba(self): + def _get_default_proba(self) -> List[Dict[ClfTarget, float]]: if len(self.observed_classes) > 0: mean_proba = ( 1 / len(self.observed_classes) @@ -343,7 +343,7 @@ def _get_default_proba(self): proba = {c: mean_proba for c in self.observed_classes} else: proba = {c: 1.0 for c in self.observed_classes} - return proba + return [proba] if isinstance(proba, dict) else proba def _adapt_output_dim(self): out_features_target = ( diff --git a/deep_river/regression/__init__.py b/deep_river/regression/__init__.py new file mode 100644 index 0000000..97e5022 --- /dev/null +++ b/deep_river/regression/__init__.py @@ -0,0 +1,7 @@ +from deep_river.regression.regressor import Regressor +from deep_river.regression.rolling_regressor import RollingRegressor + +__all__ = [ + "Regressor", + "RollingRegressor", +] diff --git a/river_torch/regression/regressor.py b/deep_river/regression/regressor.py similarity index 93% rename from river_torch/regression/regressor.py rename to deep_river/regression/regressor.py index 704ffdd..d8cf194 100644 --- a/river_torch/regression/regressor.py +++ b/deep_river/regression/regressor.py @@ -5,8 +5,8 @@ from river import base from river.base.typing import RegTarget -from river_torch.base import DeepEstimator -from river_torch.utils.tensor_conversion import ( +from deep_river.base import DeepEstimator +from deep_river.utils.tensor_conversion import ( df2tensor, dict2tensor, float2tensor, @@ -32,7 +32,7 @@ def forward(self, X, **kwargs): return X -class Regressor(DeepEstimator, base.Regressor): +class Regressor(DeepEstimator, base.MiniBatchRegressor): """ Wrapper for PyTorch regression models that enables compatibility with River. @@ -181,7 +181,7 @@ def predict_one(self, x: dict) -> RegTarget: y_pred = self.module(x_t).item() return y_pred - def learn_many(self, X: pd.DataFrame, y: List) -> "Regressor": + def learn_many(self, X: pd.DataFrame, y: pd.Series) -> "Regressor": """ Performs one step of training with a batch of examples. @@ -201,7 +201,9 @@ def learn_many(self, X: pd.DataFrame, y: List) -> "Regressor": self.kwargs["n_features"] = len(X.columns) self.initialize_module(**self.kwargs) X_t = df2tensor(X, device=self.device) - y_t = torch.tensor(y, device=self.device, dtype=torch.float32) + y_t = torch.tensor( + y, device=self.device, dtype=torch.float32 + ).unsqueeze(1) self._learn(X_t, y_t) return self @@ -224,7 +226,6 @@ def predict_many(self, X: pd.DataFrame) -> List: self.initialize_module(**self.kwargs) X = df2tensor(X, device=self.device) - self.module.eval() with torch.inference_mode(): - y_preds = self.module(X).detach().tolist() + y_preds = self.module(X).detach().squeeze().tolist() return y_preds diff --git a/river_torch/regression/rolling_regressor.py b/deep_river/regression/rolling_regressor.py similarity index 97% rename from river_torch/regression/rolling_regressor.py rename to deep_river/regression/rolling_regressor.py index 7d0dbbf..60049ca 100644 --- a/river_torch/regression/rolling_regressor.py +++ b/deep_river/regression/rolling_regressor.py @@ -4,9 +4,9 @@ import torch from river.base.typing import RegTarget -from river_torch.base import RollingDeepEstimator -from river_torch.regression import Regressor -from river_torch.utils.tensor_conversion import ( +from deep_river.base import RollingDeepEstimator +from deep_river.regression import Regressor +from deep_river.utils.tensor_conversion import ( deque2rolling_tensor, float2tensor, ) diff --git a/river_torch/utils/__init__.py b/deep_river/utils/__init__.py similarity index 100% rename from river_torch/utils/__init__.py rename to deep_river/utils/__init__.py diff --git a/river_torch/utils/estimator_checks.py b/deep_river/utils/estimator_checks.py similarity index 100% rename from river_torch/utils/estimator_checks.py rename to deep_river/utils/estimator_checks.py diff --git a/river_torch/utils/hooks.py b/deep_river/utils/hooks.py similarity index 100% rename from river_torch/utils/hooks.py rename to deep_river/utils/hooks.py diff --git a/river_torch/utils/params.py b/deep_river/utils/params.py similarity index 100% rename from river_torch/utils/params.py rename to deep_river/utils/params.py diff --git a/river_torch/utils/tensor_conversion.py b/deep_river/utils/tensor_conversion.py similarity index 95% rename from river_torch/utils/tensor_conversion.py rename to deep_river/utils/tensor_conversion.py index 2989f31..00babed 100644 --- a/river_torch/utils/tensor_conversion.py +++ b/deep_river/utils/tensor_conversion.py @@ -1,4 +1,4 @@ -from typing import Deque, Dict, Optional, Union +from typing import Deque, Dict, List, Optional, Union import numpy as np import pandas as pd @@ -146,7 +146,7 @@ def labels2onehot( def output2proba( preds: torch.Tensor, classes: OrderedSet, with_logits=False -) -> Dict[ClfTarget, float]: +) -> List[Dict[ClfTarget, float]]: if with_logits: if preds.shape[-1] >= 1: preds = torch.softmax(preds, dim=-1) @@ -168,4 +168,4 @@ def output2proba( if preds_np.shape[0] == 1 else [dict(zip(classes, pred)) for pred in preds_np] ) - return dict(probas) + return [probas] if isinstance(probas, dict) else list(probas) diff --git a/river_torch/utils/test_estimators.py b/deep_river/utils/test_estimators.py similarity index 86% rename from river_torch/utils/test_estimators.py rename to deep_river/utils/test_estimators.py index fb452b8..0183809 100644 --- a/river_torch/utils/test_estimators.py +++ b/deep_river/utils/test_estimators.py @@ -6,11 +6,11 @@ import pytest import river -from river_torch import utils +from deep_river import utils def iter_estimators(): - for submodule in importlib.import_module("river_torch").__all__: + for submodule in importlib.import_module("deep_river").__all__: def is_estimator(obj): return inspect.isclass(obj) and issubclass( @@ -18,7 +18,7 @@ def is_estimator(obj): ) for _, obj in inspect.getmembers( - importlib.import_module(f"river_torch.{submodule}"), is_estimator + importlib.import_module(f"deep_river.{submodule}"), is_estimator ): yield obj diff --git a/river_torch/utils/test_tensor_conversion.py b/deep_river/utils/test_tensor_conversion.py similarity index 77% rename from river_torch/utils/test_tensor_conversion.py rename to deep_river/utils/test_tensor_conversion.py index ab3ccc7..fff4637 100644 --- a/river_torch/utils/test_tensor_conversion.py +++ b/deep_river/utils/test_tensor_conversion.py @@ -5,7 +5,7 @@ import torch from ordered_set import OrderedSet -from river_torch.utils import ( +from deep_river.utils import ( deque2rolling_tensor, df2tensor, dict2tensor, @@ -78,33 +78,40 @@ def test_labels2onehot(): def test_output2proba(): def assert_dicts_almost_equal(d1, d2): - for k in d1: - assert np.isclose(d1[k], d2[k]) + for i in range(len(d1)): + for k in d1[i]: + assert np.isclose( + d1[i][k], d2[i][k] + ), f"{d1[i][k]} != {d2[i][k]}" y = torch.tensor([[0.1, 0.2, 0.7]]) classes = ["first class", "second class", "third class"] assert_dicts_almost_equal( output2proba(y, classes), - dict(zip(classes, np.array([0.1, 0.2, 0.7], dtype=np.float32))), + [dict(zip(classes, np.array([0.1, 0.2, 0.7], dtype=np.float32)))], ) y = torch.tensor([[0.6]]) classes = ["first class"] assert_dicts_almost_equal( output2proba(y, classes), - dict( - zip( - ["first class", "unobserved 0"], - np.array([0.6, 0.4], dtype=np.float32), + [ + dict( + zip( + ["first class", "unobserved 0"], + np.array([0.6, 0.4], dtype=np.float32), + ) ) - ), + ], ) y = torch.tensor([[0.6, 0.4, 0.0]]) assert_dicts_almost_equal( output2proba(y, classes), - dict( - zip( - ["first class", "unobserved 0", "unobserved 1"], - np.array([0.6, 0.4, 0.0], dtype=np.float32), + [ + dict( + zip( + ["first class", "unobserved 0", "unobserved 1"], + np.array([0.6, 0.4, 0.0], dtype=np.float32), + ) ) - ), + ], ) diff --git a/docs/examples/anomaly/example_autoencoder.ipynb b/docs/examples/anomaly/example_autoencoder.ipynb index a4b1f2d..1b80344 100644 --- a/docs/examples/anomaly/example_autoencoder.ipynb +++ b/docs/examples/anomaly/example_autoencoder.ipynb @@ -11,12 +11,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "outputs": [], "source": [ "from river import compose, preprocessing, metrics, datasets\n", "\n", - "from river_torch.anomaly import Autoencoder\n", + "from deep_river.anomaly import Autoencoder\n", "from torch import nn, manual_seed" ], "metadata": { @@ -25,8 +25,18 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 2, + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n MinMaxScaler (),\n Autoencoder (\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=\n lr=0.005\n device=\"cpu\"\n seed=42\n )\n)", + "text/html": "
MinMaxScaler
()\n\n
Autoencoder
(\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.005\n device=\"cpu\"\n seed=42\n)\n\n
" + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "_ = manual_seed(42)\n", "dataset = datasets.CreditCard().take(5000)\n", @@ -58,8 +68,16 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 3, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROCAUC: 0.7447\n" + ] + } + ], "source": [ "for x, y in dataset:\n", " score = model_pipeline.score_one(x)\n", @@ -73,8 +91,16 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 4, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROCAUC: 0.7447\n" + ] + } + ], "source": [ "for x, y in dataset:\n", " score = model_pipeline.score_one(x)\n", @@ -88,8 +114,16 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 5, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROCAUC: 0.7447\n" + ] + } + ], "source": [ "for x, y in dataset:\n", " score = model_pipeline.score_one(x)\n", @@ -103,8 +137,16 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 6, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROCAUC: 0.7447\n" + ] + } + ], "source": [ "for x, y in dataset:\n", " score = model_pipeline.score_one(x)\n", diff --git a/docs/examples/anomaly/example_autoencoder.md b/docs/examples/anomaly/example_autoencoder.md deleted file mode 100644 index 7efeb37..0000000 --- a/docs/examples/anomaly/example_autoencoder.md +++ /dev/null @@ -1,72 +0,0 @@ -# Simple Fully Connected Autoencoder - - -```python -from river import compose, preprocessing, metrics, datasets - -from river_torch.anomaly import Autoencoder -from torch import nn, manual_seed -``` - - -```python -_ = manual_seed(42) -dataset = datasets.CreditCard().take(5000) -metric = metrics.ROCAUC(n_thresholds=50) - -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) - -model_pipeline = compose.Pipeline( - preprocessing.MinMaxScaler(), - Autoencoder(module=MyAutoEncoder, lr=0.005) -) -model_pipeline -``` - - -```python -for x, y in dataset: - score = model_pipeline.score_one(x) - metric.update(y_true=y, y_pred=score) - model_pipeline.learn_one(x=x) -print(f"ROCAUC: {metric.get():.4f}") -``` - - -```python -for x, y in dataset: - score = model_pipeline.score_one(x) - metric.update(y_true=y, y_pred=score) - model_pipeline.learn_one(x=x) -print(f"ROCAUC: {metric.get():.4f}") -``` - - -```python -for x, y in dataset: - score = model_pipeline.score_one(x) - metric.update(y_true=y, y_pred=score) - model_pipeline.learn_one(x=x) -print(f"ROCAUC: {metric.get():.4f}") -``` - - -```python -for x, y in dataset: - score = model_pipeline.score_one(x) - metric.update(y_true=y, y_pred=score) - model_pipeline.learn_one(x=x) -print(f"ROCAUC: {metric.get():.4f}") -``` diff --git a/docs/examples/anomaly/example_lstm_autoencoder.ipynb b/docs/examples/anomaly/example_lstm_autoencoder.ipynb index f223890..caa499c 100644 --- a/docs/examples/anomaly/example_lstm_autoencoder.ipynb +++ b/docs/examples/anomaly/example_lstm_autoencoder.ipynb @@ -15,13 +15,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from river import compose, preprocessing, metrics, datasets\n", "\n", - "from river_torch.anomaly import RollingAutoencoder\n", + "from deep_river.anomaly import RollingAutoencoder\n", "from torch import nn, manual_seed\n", "import torch\n", "from tqdm import tqdm" @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -130,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -227,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -242,9 +242,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 5000/5000 [00:18<00:00, 272.78it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROCAUC: 0.5836\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x, y in tqdm(list(dataset)):\n", " scaler.learn_one(x)\n", diff --git a/docs/examples/anomaly/example_lstm_autoencoder.md b/docs/examples/anomaly/example_lstm_autoencoder.md deleted file mode 100644 index 892f124..0000000 --- a/docs/examples/anomaly/example_lstm_autoencoder.md +++ /dev/null @@ -1,205 +0,0 @@ -# Example for anomaly detection with LSTM autoencoder architectures - -There is a multitude of successful architecture. In the following we demonstrate the implementation of 3 possible architecture types. - -## Models - - -```python -from river import compose, preprocessing, metrics, datasets - -from river_torch.anomaly import RollingAutoencoder -from torch import nn, manual_seed -import torch -from tqdm import tqdm -``` - -![](srivastava_ae.png) - -LSTM Autoencoder Architecture by Srivastava et al. 2016 (https://arxiv.org/abs/1502.04681). Decoding is performed in reverse order to introduce short term dependencies between inputs and outputs. Additional to the encoding, the decoder gets fed the time-shifted original inputs. - - -```python -class LSTMAutoencoderSrivastava(nn.Module): - def __init__(self, n_features, hidden_size=30, n_layers=1, batch_first=False): - super().__init__() - self.n_features = n_features - self.hidden_size = hidden_size - self.n_layers = n_layers - self.batch_first = batch_first - self.time_axis = 1 if batch_first else 0 - self.encoder = nn.LSTM( - input_size=n_features, - hidden_size=hidden_size, - 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) - x_hat = torch.flip(x_hat, dims=[self.time_axis]) - - return x_hat -``` - -![](cho_ae.png) - -Architecture inspired by Cho et al. 2014 (https://arxiv.org/abs/1406.1078). Decoding occurs in natural order and the decoder is only provided with the encoding at every timestep. - - -```python -class LSTMAutoencoderCho(nn.Module): - def __init__(self, n_features, hidden_size=30, n_layers=1, batch_first=False): - super().__init__() - self.n_features = n_features - self.hidden_size = hidden_size - self.n_layers = n_layers - self.batch_first = batch_first - self.encoder = nn.LSTM( - input_size=n_features, - hidden_size=hidden_size, - 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) - target_shape = ( - (-1, x.shape[0], -1) if self.batch_first else (x.shape[0], -1, -1) - ) - h = h[-1].expand(target_shape) - x_hat, _ = self.decoder(h) - return x_hat -``` - -![](sutskever_ae.png) - -LSTM Encoder-Decoder architecture by Sutskever et al. 2014 (https://arxiv.org/abs/1409.3215). The decoder only gets access to its own prediction of the previous timestep. Decoding also takes performed backwards. - - -```python -class LSTMDecoder(nn.Module): - def __init__( - self, - input_size, - hidden_size, - sequence_length=None, - predict_backward=True, - num_layers=1, - ): - super().__init__() - - self.cell = nn.LSTMCell(input_size, hidden_size) - self.input_size = input_size - self.hidden_size = hidden_size - - self.predict_backward = predict_backward - self.sequence_length = sequence_length - self.num_layers = num_layers - self.lstm = ( - None - if num_layers <= 1 - else nn.LSTM( - input_size=hidden_size, - hidden_size=hidden_size, - num_layers=num_layers - 1, - ) - ) - self.linear = ( - None if input_size == hidden_size else nn.Linear(hidden_size, input_size) - ) - - def forward(self, h, sequence_length=None): - """Computes the forward pass. - - Parameters - ---------- - x: - Input of shape (batch_size, input_size) - - Returns - ------- - Tuple[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]] - Decoder outputs (output, (h, c)) where output has the shape (sequence_length, batch_size, input_size). - """ - - if sequence_length is None: - sequence_length = self.sequence_length - x_hat = torch.empty(sequence_length, h.shape[0], self.hidden_size) - for t in range(sequence_length): - if t == 0: - h, c = self.cell(h) - else: - input = h if self.linear is None else self.linear(h) - h, c = self.cell(input, (h, c)) - t_predicted = -t if self.predict_backward else t - x_hat[t_predicted] = h - - if self.lstm is not None: - x_hat = self.lstm(x_hat) - - return x_hat, (h, c) - - -class LSTMAutoencoderSutskever(nn.Module): - def __init__(self, n_features, hidden_size=30, n_layers=1): - super().__init__() - self.n_features = n_features - self.hidden_size = hidden_size - self.n_layers = n_layers - self.encoder = nn.LSTM( - input_size=n_features, hidden_size=hidden_size, num_layers=n_layers - ) - self.decoder = LSTMDecoder( - input_size=hidden_size, hidden_size=n_features, predict_backward=True - ) - - def forward(self, x): - _, (h, _) = self.encoder(x) - x_hat, _ = self.decoder(h[-1], x.shape[0]) - return x_hat -``` - -## Testing - -The models can be tested with the code in the following cells. Since River currently does not feature any anomaly detection datasets with temporal dependencies, the results should be expected to be somewhat inaccurate. - - -```python -_ = manual_seed(42) -dataset = datasets.CreditCard().take(5000) -metric = metrics.ROCAUC(n_thresholds=50) - -module = LSTMAutoencoderSrivastava # Set this variable to your architecture of choice -ae = RollingAutoencoder(module=module, lr=0.005) -scaler = preprocessing.StandardScaler() - -``` - - -```python -for x, y in tqdm(list(dataset)): - scaler.learn_one(x) - x = scaler.transform_one(x) - score = ae.score_one(x) - metric.update(y_true=y, y_pred=score) - ae.learn_one(x=x, y=None) -print(f"ROCAUC: {metric.get():.4f}") - -``` diff --git a/docs/examples/anomaly/example_probability_weighted_autoencoder.ipynb b/docs/examples/anomaly/example_probability_weighted_autoencoder.ipynb index 96c6e6e..88e7f64 100644 --- a/docs/examples/anomaly/example_probability_weighted_autoencoder.ipynb +++ b/docs/examples/anomaly/example_probability_weighted_autoencoder.ipynb @@ -11,20 +11,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from river import compose, preprocessing, metrics, datasets\n", - "from river_torch.anomaly import ProbabilityWeightedAutoencoder\n", + "from deep_river.anomaly import ProbabilityWeightedAutoencoder\n", "from torch import nn, manual_seed" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n MinMaxScaler (),\n ProbabilityWeightedAutoencoder (\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=\n lr=0.01\n device=\"cpu\"\n seed=42\n skip_threshold=0.9\n window_size=250\n )\n)", + "text/html": "
MinMaxScaler
()\n\n
ProbabilityWeightedAutoencoder
(\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.01\n device=\"cpu\"\n seed=42\n skip_threshold=0.9\n window_size=250\n)\n\n
" + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "_ = manual_seed(42)\n", "dataset = datasets.CreditCard().take(5000)\n", @@ -53,9 +63,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROCAUC: 0.7403\n" + ] + } + ], "source": [ "for x,y in dataset:\n", " score = model_pipeline.score_one(x)\n", diff --git a/docs/examples/anomaly/example_probability_weighted_autoencoder.md b/docs/examples/anomaly/example_probability_weighted_autoencoder.md deleted file mode 100644 index b292f12..0000000 --- a/docs/examples/anomaly/example_probability_weighted_autoencoder.md +++ /dev/null @@ -1,44 +0,0 @@ -# Probability weighted Autoencoder - - -```python -from river import compose, preprocessing, metrics, datasets -from river_torch.anomaly import ProbabilityWeightedAutoencoder -from torch import nn, manual_seed -``` - - -```python -_ = manual_seed(42) -dataset = datasets.CreditCard().take(5000) -metric = metrics.ROCAUC(n_thresholds=50) - -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) - -model_pipeline = compose.Pipeline( - preprocessing.MinMaxScaler(), - ProbabilityWeightedAutoencoder(module=MyAutoEncoder, lr=0.01) -) -model_pipeline -``` - - -```python -for x,y in dataset: - score = model_pipeline.score_one(x) - metric.update(y_true=y, y_pred=score) - model_pipeline.learn_one(x=x) -print(f'ROCAUC: {metric.get():.4f}') -``` diff --git a/docs/examples/catastrophic_forgetting/label_shift.ipynb b/docs/examples/catastrophic_forgetting/label_shift.ipynb index b5a0708..93dbfa9 100644 --- a/docs/examples/catastrophic_forgetting/label_shift.ipynb +++ b/docs/examples/catastrophic_forgetting/label_shift.ipynb @@ -2,14 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 46, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from river.datasets import ImageSegments \n", "from river.preprocessing import MinMaxScaler \n", "from river.tree import HoeffdingTreeClassifier\n", - "from river_torch.classification import Classifier\n", + "from deep_river.classification import Classifier\n", "from torch import nn \n", "from tqdm import tqdm \n", "import matplotlib.pyplot as plt\n", @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -72,14 +72,14 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/lucascazzonelli/.local/lib/python3.10/site-packages/sklearn/manifold/_t_sne.py:982: FutureWarning: The PCA initialization in TSNE will change to have the standard deviation of PC1 equal to 1e-4 in 1.2. This will ensure better convergence.\n", + "/Users/kulbach/Documents/environments/deep-river39/lib/python3.9/site-packages/sklearn/manifold/_t_sne.py:982: FutureWarning: The PCA initialization in TSNE will change to have the standard deviation of PC1 equal to 1e-4 in 1.2. This will ensure better convergence.\n", " warnings.warn(\n" ] } @@ -93,29 +93,23 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] + "text/plain": "" }, - "execution_count": 82, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" + "text/plain": "
", + "image/png": "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\n" }, + "metadata": {}, "output_type": "display_data" } ], @@ -144,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -190,14 +184,14 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 10000/10000 [00:16<00:00, 589.76it/s]\n" + "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 10000/10000 [00:11<00:00, 888.76it/s]\n" ] } ], @@ -225,14 +219,14 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 10000/10000 [00:09<00:00, 1062.55it/s]\n" + "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 10000/10000 [00:15<00:00, 646.91it/s]\n" ] } ], @@ -251,29 +245,23 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] + "text/plain": "" }, - "execution_count": 92, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" + "text/plain": "
", + "image/png": "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\n" }, + "metadata": {}, "output_type": "display_data" } ], diff --git a/docs/examples/catastrophic_forgetting/real_world_exmpl.ipynb b/docs/examples/catastrophic_forgetting/real_world_exmpl.ipynb index 6fa9568..1dcea5a 100644 --- a/docs/examples/catastrophic_forgetting/real_world_exmpl.ipynb +++ b/docs/examples/catastrophic_forgetting/real_world_exmpl.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -11,7 +11,7 @@ "from river.metrics import Accuracy\n", "from river.utils import Rolling\n", "from river.tree import HoeffdingTreeClassifier\n", - "from river_torch.classification import Classifier\n", + "from deep_river.classification import Classifier\n", "from torch import nn \n", "from tqdm import tqdm \n", "import matplotlib.pyplot as plt\n", @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -47,21 +47,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading http://sites.labic.icmc.usp.br/vsouza/repository/creme/INSECTS-abrupt_imbalanced_norm.arff (104.95 MB)\n" - ] - }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 355275/355275 [04:27<00:00, 1327.40it/s]\n" + "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 52848/52848 [00:41<00:00, 1270.52it/s]\n" ] } ], @@ -91,14 +84,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 355275/355275 [04:27<00:00, 1327.32it/s]\n" + "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 52848/52848 [00:46<00:00, 1142.66it/s]\n" ] } ], @@ -109,24 +102,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] + "text/plain": "" }, + "execution_count": 5, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" diff --git a/docs/examples/catastrophic_forgetting/recurring_concepts.ipynb b/docs/examples/catastrophic_forgetting/recurring_concepts.ipynb index 20135b8..c13bd4f 100644 --- a/docs/examples/catastrophic_forgetting/recurring_concepts.ipynb +++ b/docs/examples/catastrophic_forgetting/recurring_concepts.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 44, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -11,7 +11,7 @@ "from river.metrics import MAE\n", "from river.utils import Rolling\n", "from river.tree import HoeffdingTreeRegressor\n", - "from river_torch.regression import Regressor\n", + "from deep_river.regression import Regressor\n", "from torch import nn \n", "from tqdm import tqdm \n", "import matplotlib.pyplot as plt\n", @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -48,14 +48,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 12500/12500 [00:14<00:00, 892.13it/s] \n" + "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 12500/12500 [00:09<00:00, 1363.65it/s]\n" ] } ], @@ -84,14 +84,14 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 12500/12500 [00:06<00:00, 1866.62it/s]\n" + "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 12500/12500 [00:03<00:00, 3890.17it/s]\n" ] } ], @@ -102,29 +102,23 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] + "text/plain": "" }, - "execution_count": 48, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" + "text/plain": "
", + "image/png": "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\n" }, + "metadata": {}, "output_type": "display_data" } ], diff --git a/docs/examples/classification/example_classification.ipynb b/docs/examples/classification/example_classification.ipynb index 940c1db..ae234f6 100644 --- a/docs/examples/classification/example_classification.ipynb +++ b/docs/examples/classification/example_classification.ipynb @@ -11,21 +11,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "from river import metrics, datasets, compose, preprocessing\n", - "from river_torch.classification import Classifier\n", + "from deep_river.classification import Classifier\n", "from torch import nn\n", "from tqdm import tqdm" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n StandardScaler (\n with_std=True\n ),\n Classifier (\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=\n lr=0.001\n output_is_logit=True\n is_class_incremental=False\n device=\"cpu\"\n seed=42\n )\n)", + "text/html": "
StandardScaler
(\n with_std=True\n)\n\n
Classifier
(\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=<class 'torch.optim.adam.Adam'>\n lr=0.001\n output_is_logit=True\n is_class_incremental=False\n device=\"cpu\"\n seed=42\n)\n\n
" + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dataset = datasets.Phishing()\n", "metric = metrics.Accuracy()\n", @@ -53,9 +63,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "1250it [00:00, 1367.42it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.6728\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x,y in tqdm(dataset.take(5000)):\n", " y_pred = model_pipeline.predict_one(x) # make a prediction\n", diff --git a/docs/examples/classification/example_mini_batches.ipynb b/docs/examples/classification/example_mini_batches.ipynb index 94a3267..1171e16 100644 --- a/docs/examples/classification/example_mini_batches.ipynb +++ b/docs/examples/classification/example_mini_batches.ipynb @@ -12,22 +12,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "from river import datasets\n", - "from river_torch import classification\n", + "from deep_river import classification\n", "from torch import nn\n", "from river import compose\n", "from river import preprocessing\n", - "from itertools import islice" + "from itertools import islice\n", + "from sklearn import metrics" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -62,9 +63,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n StandardScaler (\n with_std=True\n ),\n Classifier (\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=\n lr=0.001\n output_is_logit=True\n is_class_incremental=False\n device=\"cpu\"\n seed=42\n )\n)", + "text/html": "
StandardScaler
(\n with_std=True\n)\n\n
Classifier
(\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.001\n output_is_logit=True\n is_class_incremental=False\n device=\"cpu\"\n seed=42\n)\n\n
" + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "model = compose.Pipeline(\n", " preprocessing.StandardScaler(),\n", @@ -75,17 +86,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ + "y_trues = []\n", + "y_preds = []\n", "for batch in batcher(dataset,5):\n", " x,y = zip(*batch)\n", " x = pd.DataFrame(x)\n", - " y = list(y)\n", - " y_pred = model.predict_proba_many(X=x)\n", + " y_trues.extend(y)\n", + " y = pd.Series(y)\n", + " y_preds.extend(model.predict_many(X=x))\n", " model = model.learn_many(x, y) # make the model learn" ] + }, + { + "cell_type": "code", + "execution_count": 23, + "outputs": [ + { + "data": { + "text/plain": "0.4192" + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "metrics.accuracy_score(\n", + " y_pred=[str(i) for i in y_preds],\n", + " y_true=[str(i) for i in y_trues]\n", + ")" + ], + "metadata": { + "collapsed": false + } } ], "metadata": { diff --git a/docs/examples/classification/example_rnn_classification.ipynb b/docs/examples/classification/example_rnn_classification.ipynb index 042a790..dab5d14 100644 --- a/docs/examples/classification/example_rnn_classification.ipynb +++ b/docs/examples/classification/example_rnn_classification.ipynb @@ -12,11 +12,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "from river_torch.classification import RollingClassifier\n", + "from deep_river.classification import RollingClassifier\n", "from river import metrics, compose, preprocessing, datasets\n", "import torch\n", "from tqdm import tqdm" @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "outputs": [], "source": [ "class RnnModule(torch.nn.Module):\n", @@ -65,8 +65,18 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 3, + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n StandardScaler (\n with_std=True\n ),\n RollingClassifier (\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=\n lr=0.01\n output_is_logit=True\n is_class_incremental=False\n device=\"cpu\"\n seed=42\n window_size=20\n append_predict=True\n )\n)", + "text/html": "
StandardScaler
(\n with_std=True\n)\n\n
RollingClassifier
(\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.01\n output_is_logit=True\n is_class_incremental=False\n device=\"cpu\"\n seed=42\n window_size=20\n append_predict=True\n)\n\n
" + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dataset = datasets.Keystroke()\n", "metric = metrics.Accuracy()\n", @@ -90,14 +100,36 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 4, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "20400it [00:30, 666.50it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.02\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x,y in tqdm(dataset):\n", " y_pred = model_pipeline.predict_one(x) # make a prediction\n", " metric = metric.update(y, y_pred) # update the metric\n", " model = model_pipeline.learn_one(x, y) # make the model learn\n", - "print(f'Accuracy: {metric.get():.2f }')" + "print(f'Accuracy: {metric.get():.2f}')" ], "metadata": { "collapsed": false @@ -114,8 +146,18 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 5, + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n StandardScaler (\n with_std=True\n ),\n RollingClassifier (\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=\n lr=0.01\n output_is_logit=True\n is_class_incremental=True\n device=\"cpu\"\n seed=42\n window_size=20\n append_predict=True\n )\n)", + "text/html": "
StandardScaler
(\n with_std=True\n)\n\n
RollingClassifier
(\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.01\n output_is_logit=True\n is_class_incremental=True\n device=\"cpu\"\n seed=42\n window_size=20\n append_predict=True\n)\n\n
" + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dataset = datasets.Keystroke()\n", "metric = metrics.Accuracy()\n", @@ -139,8 +181,30 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 6, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "20400it [00:31, 652.13it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.09\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x,y in tqdm(dataset):\n", " y_pred = model_pipeline.predict_one(x) # make a prediction\n", @@ -163,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -192,9 +256,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n StandardScaler (\n with_std=True\n ),\n RollingClassifier (\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=\n lr=0.01\n output_is_logit=True\n is_class_incremental=False\n device=\"cpu\"\n seed=42\n window_size=20\n append_predict=True\n )\n)", + "text/html": "
StandardScaler
(\n with_std=True\n)\n\n
RollingClassifier
(\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.01\n output_is_logit=True\n is_class_incremental=False\n device=\"cpu\"\n seed=42\n window_size=20\n append_predict=True\n)\n\n
" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dataset = datasets.Keystroke()\n", "metric = metrics.Accuracy()\n", @@ -214,15 +288,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "20400it [00:59, 344.86it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.02\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x,y in tqdm(dataset):\n", " y_pred = model_pipeline.predict_one(x) # make a prediction\n", " metric = metric.update(y, y_pred) # update the metric\n", " model = model_pipeline.learn_one(x, y) # make the model learn\n", - "print(f'Accuracy: {metric.get()}')" + "print(f'Accuracy: {metric.get():.2f}')" ] }, { @@ -236,8 +332,18 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 10, + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n StandardScaler (\n with_std=True\n ),\n RollingClassifier (\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=\n lr=0.01\n output_is_logit=True\n is_class_incremental=True\n device=\"cpu\"\n seed=42\n window_size=20\n append_predict=True\n )\n)", + "text/html": "
StandardScaler
(\n with_std=True\n)\n\n
RollingClassifier
(\n module=None\n loss_fn=\"binary_cross_entropy\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.01\n output_is_logit=True\n is_class_incremental=True\n device=\"cpu\"\n seed=42\n window_size=20\n append_predict=True\n)\n\n
" + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dataset = datasets.Keystroke()\n", "metric = metrics.Accuracy()\n", @@ -261,27 +367,40 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 11, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "20400it [01:07, 300.25it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.13857843137254902:.2f\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x,y in tqdm(dataset):\n", " y_pred = model_pipeline.predict_one(x) # make a prediction\n", " metric = metric.update(y, y_pred) # update the metric\n", " model = model_pipeline.learn_one(x, y) # make the model learn\n", - "print(f'Accuracy: {metric.get()}')" + "print(f'Accuracy: {metric.get()}:.2f')" ], "metadata": { "collapsed": false } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false - } } ], "metadata": { diff --git a/docs/examples/regression/bike-sharing-forecasting.ipynb b/docs/examples/regression/bike-sharing-forecasting.ipynb new file mode 100644 index 0000000..87603d8 --- /dev/null +++ b/docs/examples/regression/bike-sharing-forecasting.ipynb @@ -0,0 +1,520 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bike-sharing forecasting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this tutorial we're going to forecast the number of bikes in 5 bike stations from the city of Toulouse. We'll do so by building a simple model step by step. The dataset contains 182,470 observations. Let's first take a peak at the data." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-26T10:45:46.256749Z", + "iopub.status.busy": "2022-10-26T10:45:46.255828Z", + "iopub.status.idle": "2022-10-26T10:45:46.883494Z", + "shell.execute_reply": "2022-10-26T10:45:46.882486Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'clouds': 75,\n", + " 'description': 'light rain',\n", + " 'humidity': 81,\n", + " 'moment': datetime.datetime(2016, 4, 1, 0, 0, 7),\n", + " 'pressure': 1017.0,\n", + " 'station': 'metro-canal-du-midi',\n", + " 'temperature': 6.54,\n", + " 'wind': 9.3}\n", + "Number of available bikes: 1\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "from river import datasets\n", + "\n", + "dataset = datasets.Bikes()\n", + "\n", + "for x, y in dataset:\n", + " pprint(x)\n", + " print(f'Number of available bikes: {y}')\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start by using a simple linear regression on the numeric features. We can select the numeric features and discard the rest of the features using a `Select`. Linear regression is very likely to go haywire if we don't scale the data, so we'll use a `StandardScaler` to do just that. We'll evaluate the model by measuring the mean absolute error. Finally we'll print the score every 20,000 observations. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-26T10:45:46.891550Z", + "iopub.status.busy": "2022-10-26T10:45:46.890567Z", + "iopub.status.idle": "2022-10-26T10:46:08.203607Z", + "shell.execute_reply": "2022-10-26T10:46:08.204035Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5,000] MAE: 4.258099\n", + "[10,000] MAE: 4.495612\n", + "[15,000] MAE: 4.752074\n", + "[20,000] MAE: 4.912727\n", + "[25,000] MAE: 4.934188\n", + "[30,000] MAE: 5.164331\n", + "[35,000] MAE: 5.320877\n", + "[40,000] MAE: 5.333554\n", + "[45,000] MAE: 5.354958\n", + "[50,000] MAE: 5.378699\n" + ] + }, + { + "data": { + "text/plain": "MAE: 5.378699" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from river import compose\n", + "from river import linear_model\n", + "from river import metrics\n", + "from river import evaluate\n", + "from river import preprocessing\n", + "from river import optim\n", + "\n", + "model = compose.Select('clouds', 'humidity', 'pressure', 'temperature', 'wind')\n", + "model |= preprocessing.StandardScaler()\n", + "model |= linear_model.LinearRegression(optimizer=optim.SGD(0.001))\n", + "\n", + "metric = metrics.MAE()\n", + "\n", + "evaluate.progressive_val_score(dataset.take(50000), model, metric, print_every=5_000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model doesn't seem to be doing that well, but then again we didn't provide a lot of features. Generally, a good idea for this kind of problem is to look at an average of the previous values. For example, for each station we can look at the average number of bikes per hour. To do so we first have to extract the hour from the `moment` field. We can then use a `TargetAgg` to aggregate the values of the target." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-26T10:46:08.214992Z", + "iopub.status.busy": "2022-10-26T10:46:08.214309Z", + "iopub.status.idle": "2022-10-26T10:46:37.420954Z", + "shell.execute_reply": "2022-10-26T10:46:37.421356Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5,000] MAE: 69.042914\n", + "[10,000] MAE: 36.269638\n", + "[15,000] MAE: 25.241059\n", + "[20,000] MAE: 19.781737\n", + "[25,000] MAE: 16.605912\n", + "[30,000] MAE: 14.402878\n", + "[35,000] MAE: 12.857216\n", + "[40,000] MAE: 11.647737\n", + "[45,000] MAE: 10.646566\n", + "[50,000] MAE: 9.94726\n" + ] + }, + { + "data": { + "text/plain": "MAE: 9.94726" + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from river import feature_extraction\n", + "from river import stats\n", + "\n", + "def get_hour(x):\n", + " x['hour'] = x['moment'].hour\n", + " return x\n", + "\n", + "model = compose.Select('clouds', 'humidity', 'pressure', 'temperature', 'wind')\n", + "model += (\n", + " get_hour |\n", + " feature_extraction.TargetAgg(by=['station', 'hour'], how=stats.Mean())\n", + ")\n", + "model |= preprocessing.StandardScaler()\n", + "model |= linear_model.LinearRegression(optimizer=optim.SGD(1e-2))\n", + "\n", + "metric = metrics.MAE()\n", + "\n", + "evaluate.progressive_val_score(dataset.take(50000), model, metric, print_every=5_000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By adding a single feature, we've managed to significantly reduce the mean absolute error. At this point you might think that the model is getting slightly complex, and is difficult to understand and test. Pipelines have the advantage of being terse, but they aren't always to debug. Thankfully `river` has some ways to relieve the pain.\n", + "\n", + "The first thing we can do it to visualize the pipeline, to get an idea of how the data flows through it." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-26T10:46:37.433325Z", + "iopub.status.busy": "2022-10-26T10:46:37.431098Z", + "iopub.status.idle": "2022-10-26T10:46:37.486808Z", + "shell.execute_reply": "2022-10-26T10:46:37.487684Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n TransformerUnion (\n Select (\n clouds\n humidity\n pressure\n temperature\n wind\n ),\n Pipeline (\n FuncTransformer (\n func=\"get_hour\"\n ),\n TargetAgg (\n by=['station', 'hour']\n how=Mean ()\n target_name=\"y\"\n )\n )\n ),\n StandardScaler (\n with_std=True\n ),\n LinearRegression (\n optimizer=SGD (\n lr=Constant (\n learning_rate=0.01\n )\n )\n loss=Squared ()\n l2=0.\n l1=0.\n intercept_init=0.\n intercept_lr=Constant (\n learning_rate=0.01\n )\n clip_gradient=1e+12\n initializer=Zeros ()\n )\n)", + "text/html": "
['clouds', 'humidity', 'pressure', 'temperature', 'wind']
(\n clouds\n humidity\n pressure\n temperature\n wind\n)\n\n
get_hour
\ndef get_hour(x):\n x['hour'] = x['moment'].hour\n return x\n\n
y_mean_by_station_and_hour
(\n by=['station', 'hour']\n how=Mean ()\n target_name=\"y\"\n)\n\n
StandardScaler
(\n with_std=True\n)\n\n
LinearRegression
(\n optimizer=SGD (\n lr=Constant (\n learning_rate=0.01\n )\n )\n loss=Squared ()\n l2=0.\n l1=0.\n intercept_init=0.\n intercept_lr=Constant (\n learning_rate=0.01\n )\n clip_gradient=1e+12\n initializer=Zeros ()\n)\n\n
" + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `debug_one` method shows what happens to an input set of features, step by step.\n", + "\n", + "And now comes the catch. Up until now we've been using the `progressive_val_score` method from the `evaluate` module. What this does is that it sequentially predicts the output of an observation and updates the model immediately afterwards. This way of proceeding is often used for evaluating online learning models. But in some cases it is the wrong approach.\n", + "\n", + "When evaluating a machine learning model, the goal is to simulate production conditions in order to get a trust-worthy assessment of the performance of the model. In our case, we typically want to forecast the number of bikes available in a station, say, 30 minutes ahead. Then, once the 30 minutes have passed, the true number of available bikes will be available and we will be able to update the model using the features available 30 minutes ago.\n", + "\n", + "What we really want is to evaluate the model by forecasting 30 minutes ahead and only updating the model once the true values are available. This can be done using the `moment` and `delay` parameters in the `progressive_val_score` method. The idea is that each observation in the stream of the data is shown twice to the model: once for making a prediction, and once for updating the model when the true value is revealed. The `moment` parameter determines which variable should be used as a timestamp, while the `delay` parameter controls the duration to wait before revealing the true values to the model." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-26T10:46:38.743022Z", + "iopub.status.busy": "2022-10-26T10:46:38.742445Z", + "iopub.status.idle": "2022-10-26T10:47:10.543114Z", + "shell.execute_reply": "2022-10-26T10:47:10.543867Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5,000] MAE: 4.675207\n", + "[10,000] MAE: 4.352476\n", + "[15,000] MAE: 4.193511\n", + "[20,000] MAE: 4.203433\n", + "[25,000] MAE: 4.226929\n", + "[30,000] MAE: 4.191629\n", + "[35,000] MAE: 4.227425\n", + "[40,000] MAE: 4.195404\n", + "[45,000] MAE: 4.102599\n", + "[50,000] MAE: 4.117846\n" + ] + }, + { + "data": { + "text/plain": "MAE: 4.117846" + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import datetime as dt\n", + "\n", + "evaluate.progressive_val_score(\n", + " dataset=dataset.take(50000),\n", + " model=model.clone(),\n", + " metric=metrics.MAE(),\n", + " moment='moment',\n", + " delay=dt.timedelta(minutes=30),\n", + " print_every=5_000\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The performance is a bit worse, which is to be expected. Indeed, the task is more difficult: the model is only shown the ground truth 30 minutes after making a prediction." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Goin' Deep\n", + "## Rebuilding Linear Regression in PyTorch" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from deep_river.regression import Regressor\n", + "from river import feature_extraction\n", + "from river import stats\n", + "import torch\n", + "\n", + "class LinearRegression(torch.nn.Module):\n", + " def __init__(self, n_features, outputSize=1):\n", + " super(LinearRegression, self).__init__()\n", + " self.linear = torch.nn.Linear(n_features, outputSize)\n", + "\n", + " def forward(self, x):\n", + " out = self.linear(x)\n", + " return out\n", + "\n", + "model = compose.Select('clouds', 'humidity', 'pressure', 'temperature', 'wind')\n", + "model += (\n", + " get_hour |\n", + " feature_extraction.TargetAgg(by=['station', 'hour'], how=stats.Mean())\n", + ")\n", + "model |= preprocessing.StandardScaler()\n", + "model |= Regressor(\n", + " module=LinearRegression,\n", + " loss_fn='mse',\n", + " optimizer_fn='sgd',\n", + " lr=1e-2,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'NoneType' object is not callable", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mTypeError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[13], line 3\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mdatetime\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m \u001B[38;5;21;01mdt\u001B[39;00m\n\u001B[0;32m----> 3\u001B[0m \u001B[43mevaluate\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mprogressive_val_score\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 4\u001B[0m \u001B[43m \u001B[49m\u001B[43mdataset\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdataset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtake\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m50000\u001B[39;49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 5\u001B[0m \u001B[43m \u001B[49m\u001B[43mmodel\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmodel\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mclone\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 6\u001B[0m \u001B[43m \u001B[49m\u001B[43mmetric\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmetrics\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mMAE\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 7\u001B[0m \u001B[43m \u001B[49m\u001B[43mmoment\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mmoment\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 8\u001B[0m \u001B[43m \u001B[49m\u001B[43mdelay\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdt\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtimedelta\u001B[49m\u001B[43m(\u001B[49m\u001B[43mminutes\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m30\u001B[39;49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 9\u001B[0m \u001B[43m \u001B[49m\u001B[43mprint_every\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m5_000\u001B[39;49m\n\u001B[1;32m 10\u001B[0m \u001B[43m)\u001B[49m\n", + "File \u001B[0;32m~/Documents/environments/deep-river39/lib/python3.9/site-packages/river/evaluate/progressive_validation.py:341\u001B[0m, in \u001B[0;36mprogressive_val_score\u001B[0;34m(dataset, model, metric, moment, delay, print_every, show_time, show_memory, **print_kwargs)\u001B[0m\n\u001B[1;32m 190\u001B[0m \u001B[38;5;124;03m\"\"\"Evaluates the performance of a model on a streaming dataset.\u001B[39;00m\n\u001B[1;32m 191\u001B[0m \n\u001B[1;32m 192\u001B[0m \u001B[38;5;124;03mThis method is the canonical way to evaluate a model's performance. When used correctly, it\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 327\u001B[0m \n\u001B[1;32m 328\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 330\u001B[0m checkpoints \u001B[38;5;241m=\u001B[39m iter_progressive_val_score(\n\u001B[1;32m 331\u001B[0m dataset\u001B[38;5;241m=\u001B[39mdataset,\n\u001B[1;32m 332\u001B[0m model\u001B[38;5;241m=\u001B[39mmodel,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 338\u001B[0m measure_memory\u001B[38;5;241m=\u001B[39mshow_memory,\n\u001B[1;32m 339\u001B[0m )\n\u001B[0;32m--> 341\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m checkpoint \u001B[38;5;129;01min\u001B[39;00m checkpoints:\n\u001B[1;32m 343\u001B[0m msg \u001B[38;5;241m=\u001B[39m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m[\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mcheckpoint[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mStep\u001B[39m\u001B[38;5;124m'\u001B[39m]\u001B[38;5;132;01m:\u001B[39;00m\u001B[38;5;124m,d\u001B[39m\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m] \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mmetric\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 344\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m show_time:\n", + "File \u001B[0;32m~/Documents/environments/deep-river39/lib/python3.9/site-packages/river/evaluate/progressive_validation.py:167\u001B[0m, in \u001B[0;36miter_progressive_val_score\u001B[0;34m(dataset, model, metric, moment, delay, step, measure_time, measure_memory)\u001B[0m\n\u001B[1;32m 80\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21miter_progressive_val_score\u001B[39m(\n\u001B[1;32m 81\u001B[0m dataset: base\u001B[38;5;241m.\u001B[39mtyping\u001B[38;5;241m.\u001B[39mDataset,\n\u001B[1;32m 82\u001B[0m model,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 88\u001B[0m measure_memory\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mFalse\u001B[39;00m,\n\u001B[1;32m 89\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m typing\u001B[38;5;241m.\u001B[39mGenerator:\n\u001B[1;32m 90\u001B[0m \u001B[38;5;124;03m\"\"\"Evaluates the performance of a model on a streaming dataset and yields results.\u001B[39;00m\n\u001B[1;32m 91\u001B[0m \n\u001B[1;32m 92\u001B[0m \u001B[38;5;124;03m This does exactly the same as `evaluate.progressive_val_score`. The only difference is that\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 164\u001B[0m \n\u001B[1;32m 165\u001B[0m \u001B[38;5;124;03m \"\"\"\u001B[39;00m\n\u001B[0;32m--> 167\u001B[0m \u001B[38;5;28;01myield from\u001B[39;00m _progressive_validation(\n\u001B[1;32m 168\u001B[0m dataset,\n\u001B[1;32m 169\u001B[0m model,\n\u001B[1;32m 170\u001B[0m metric,\n\u001B[1;32m 171\u001B[0m checkpoints\u001B[38;5;241m=\u001B[39mitertools\u001B[38;5;241m.\u001B[39mcount(step, step) \u001B[38;5;28;01mif\u001B[39;00m step \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28miter\u001B[39m([]),\n\u001B[1;32m 172\u001B[0m moment\u001B[38;5;241m=\u001B[39mmoment,\n\u001B[1;32m 173\u001B[0m delay\u001B[38;5;241m=\u001B[39mdelay,\n\u001B[1;32m 174\u001B[0m measure_time\u001B[38;5;241m=\u001B[39mmeasure_time,\n\u001B[1;32m 175\u001B[0m measure_memory\u001B[38;5;241m=\u001B[39mmeasure_memory,\n\u001B[1;32m 176\u001B[0m )\n", + "File \u001B[0;32m~/Documents/environments/deep-river39/lib/python3.9/site-packages/river/evaluate/progressive_validation.py:47\u001B[0m, in \u001B[0;36m_progressive_validation\u001B[0;34m(dataset, model, metric, checkpoints, moment, delay, measure_time, measure_memory)\u001B[0m\n\u001B[1;32m 45\u001B[0m \u001B[38;5;66;03m# Case 1: no ground truth, just make a prediction\u001B[39;00m\n\u001B[1;32m 46\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m y \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m---> 47\u001B[0m preds[i] \u001B[38;5;241m=\u001B[39m \u001B[43mpred_func\u001B[49m\u001B[43m(\u001B[49m\u001B[43mx\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 48\u001B[0m \u001B[38;5;28;01mcontinue\u001B[39;00m\n\u001B[1;32m 50\u001B[0m \u001B[38;5;66;03m# Case 2: there's a ground truth, model and metric can be updated\u001B[39;00m\n", + "File \u001B[0;32m~/Documents/environments/deep-river39/lib/python3.9/site-packages/river/compose/pipeline.py:594\u001B[0m, in \u001B[0;36mPipeline.predict_one\u001B[0;34m(self, x, **params)\u001B[0m\n\u001B[1;32m 585\u001B[0m \u001B[38;5;124;03m\"\"\"Call `transform_one` on the first steps and `predict_one` on the last step.\u001B[39;00m\n\u001B[1;32m 586\u001B[0m \n\u001B[1;32m 587\u001B[0m \u001B[38;5;124;03mParameters\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 591\u001B[0m \n\u001B[1;32m 592\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 593\u001B[0m x, last_step \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_transform_one(x)\n\u001B[0;32m--> 594\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mlast_step\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mpredict_one\u001B[49m\u001B[43m(\u001B[49m\u001B[43mx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mparams\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m~/Documents/projects/IncrementalLearning/deep-river/deep_river/regression/regressor.py:177\u001B[0m, in \u001B[0;36mRegressor.predict_one\u001B[0;34m(self, x)\u001B[0m\n\u001B[1;32m 175\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodule_initialized:\n\u001B[1;32m 176\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mkwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mn_features\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlen\u001B[39m(x)\n\u001B[0;32m--> 177\u001B[0m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43minitialize_module\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 178\u001B[0m x_t \u001B[38;5;241m=\u001B[39m dict2tensor(x, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mdevice)\n\u001B[1;32m 179\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodule\u001B[38;5;241m.\u001B[39meval()\n", + "File \u001B[0;32m~/Documents/projects/IncrementalLearning/deep-river/deep_river/base.py:142\u001B[0m, in \u001B[0;36mDeepEstimator.initialize_module\u001B[0;34m(self, **kwargs)\u001B[0m\n\u001B[1;32m 127\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 128\u001B[0m \u001B[38;5;124;03mParameters\u001B[39;00m\n\u001B[1;32m 129\u001B[0m \u001B[38;5;124;03m----------\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 139\u001B[0m \u001B[38;5;124;03m The initialized component.\u001B[39;00m\n\u001B[1;32m 140\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 141\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodule_cls, torch\u001B[38;5;241m.\u001B[39mnn\u001B[38;5;241m.\u001B[39mModule):\n\u001B[0;32m--> 142\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodule \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmodule_cls\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 143\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_filter_kwargs\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmodule_cls\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 144\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 146\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodule\u001B[38;5;241m.\u001B[39mto(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mdevice)\n\u001B[1;32m 147\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39moptimizer \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39moptimizer_fn(\n\u001B[1;32m 148\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodule\u001B[38;5;241m.\u001B[39mparameters(), lr\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mlr\n\u001B[1;32m 149\u001B[0m )\n", + "\u001B[0;31mTypeError\u001B[0m: 'NoneType' object is not callable" + ] + } + ], + "source": [ + "import datetime as dt\n", + "\n", + "evaluate.progressive_val_score(\n", + " dataset=dataset.take(50000),\n", + " model=model.clone(),\n", + " metric=metrics.MAE(),\n", + " moment='moment',\n", + " delay=dt.timedelta(minutes=30),\n", + " print_every=5_000\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building RNN Models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from deep_river.regression import Regressor, RollingRegressor\n", + "from river import feature_extraction\n", + "from river import stats\n", + "import torch\n", + "\n", + "class RnnModule(torch.nn.Module):\n", + "\n", + " def __init__(self, n_features, hidden_size):\n", + " super().__init__()\n", + " self.n_features=n_features\n", + " self.rnn = torch.nn.RNN(input_size=n_features, hidden_size=hidden_size, num_layers=1)\n", + " self.fc = torch.nn.Linear(in_features=hidden_size,out_features=1)\n", + "\n", + " def forward(self, X, **kwargs):\n", + " output, hn = self.rnn(X) # lstm with input, hidden, and internal state\n", + " return self.fc(output[-1, :])\n", + "\n", + "model = compose.Select('clouds', 'humidity', 'pressure', 'temperature', 'wind')\n", + "model += (\n", + " get_hour |\n", + " feature_extraction.TargetAgg(by=['station', 'hour'], how=stats.Mean())\n", + ")\n", + "model |= preprocessing.StandardScaler()\n", + "model |= RollingRegressor(\n", + " module=RnnModule,\n", + " loss_fn='mse',\n", + " optimizer_fn='sgd',\n", + " lr=1e-2,\n", + " hidden_size=20,\n", + " window_size=32,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime as dt\n", + "\n", + "evaluate.progressive_val_score(\n", + " dataset=dataset.take(50000),\n", + " model=model.clone(),\n", + " metric=metrics.MAE(),\n", + " moment='moment',\n", + " delay=dt.timedelta(minutes=30),\n", + " print_every=5_000\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building LSTM Models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class LstmModule(torch.nn.Module):\n", + "\n", + " def __init__(self, n_features, hidden_size=1):\n", + " super().__init__()\n", + " self.n_features=n_features\n", + " self.hidden_size = hidden_size\n", + " self.lstm = torch.nn.LSTM(input_size=n_features, hidden_size=hidden_size, num_layers=1, bidirectional=False)\n", + " self.fc = torch.nn.Linear(in_features=hidden_size,out_features=1)\n", + "\n", + " def forward(self, X, **kwargs):\n", + " output, (hn, cn) = self.lstm(X) # lstm with input, hidden, and internal state\n", + " return self.fc(output[-1, :])\n", + "\n", + "model = compose.Select('clouds', 'humidity', 'pressure', 'temperature', 'wind')\n", + "model += (\n", + " get_hour |\n", + " feature_extraction.TargetAgg(by=['station', 'hour'], how=stats.Mean())\n", + ")\n", + "model |= preprocessing.StandardScaler()\n", + "model |= RollingRegressor(\n", + " module=LstmModule,\n", + " loss_fn='mse',\n", + " optimizer_fn='sgd',\n", + " lr=1e-2,\n", + " hidden_size=20,\n", + " window_size=32,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime as dt\n", + "\n", + "evaluate.progressive_val_score(\n", + " dataset=dataset.take(50000),\n", + " model=model.clone(),\n", + " metric=metrics.MAE(),\n", + " moment='moment',\n", + " delay=dt.timedelta(minutes=30),\n", + " print_every=5_000\n", + ")" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "e6e87bad9c8c768904c061eafcb4f6739260ff8bb57f302c215ab258ded773dc" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/regression/example_mini_batches.ipynb b/docs/examples/regression/example_mini_batches.ipynb index 77c3d1f..dfbea93 100644 --- a/docs/examples/regression/example_mini_batches.ipynb +++ b/docs/examples/regression/example_mini_batches.ipynb @@ -2,22 +2,23 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "from river import datasets\n", - "from river_torch import regression\n", + "from deep_river import regression\n", "from torch import nn\n", "from river import compose\n", "from river import preprocessing\n", - "from itertools import islice" + "from itertools import islice\n", + "from sklearn import metrics" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -43,9 +44,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n Select (\n clouds\n humidity\n pressure\n temperature\n wind\n ),\n StandardScaler (\n with_std=True\n ),\n Regressor (\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=\n lr=0.001\n device=\"cpu\"\n seed=42\n )\n)", + "text/html": "
['clouds', 'humidity', 'pressure', 'temperature', 'wind']
(\n clouds\n humidity\n pressure\n temperature\n wind\n)\n\n
StandardScaler
(\n with_std=True\n)\n\n
Regressor
(\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.001\n device=\"cpu\"\n seed=42\n)\n\n
" + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dataset = datasets.Bikes()\n", "\n", @@ -57,16 +68,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/kulbach/Documents/environments/deep-river39/lib/python3.9/site-packages/river/preprocessing/scale.py:238: RuntimeWarning: invalid value encountered in scalar power\n", + " stds = np.array([self.vars[c] ** 0.5 for c in X.columns])\n" + ] + } + ], "source": [ + "y_trues = []\n", + "y_preds = []\n", "for batch in batcher(dataset.take(5000),5):\n", " x,y = zip(*batch)\n", " x = pd.DataFrame(x)\n", - " y_pred = model_pipeline.predict_many(X=x)\n", + " y_trues.extend(y)\n", + " y_preds.extend(model_pipeline.predict_many(X=x))\n", " model_pipeline.learn_many(X=x, y=y)" ] + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [ + { + "data": { + "text/plain": "102.4412" + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "metrics.mean_squared_error(y_true=y_trues,y_pred=y_preds)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false + } } ], "metadata": { diff --git a/docs/examples/regression/example_regression.ipynb b/docs/examples/regression/example_regression.ipynb index 01e8660..67d3cac 100644 --- a/docs/examples/regression/example_regression.ipynb +++ b/docs/examples/regression/example_regression.ipynb @@ -11,12 +11,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from river import metrics, compose, preprocessing, datasets, stats, feature_extraction\n", - "from river_torch.regression import Regressor\n", + "from deep_river.regression import Regressor\n", "from torch import nn\n", "from pprint import pprint\n", "from tqdm import tqdm" @@ -24,9 +24,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'clouds': 75,\n", + " 'description': 'light rain',\n", + " 'humidity': 81,\n", + " 'moment': datetime.datetime(2016, 4, 1, 0, 0, 7),\n", + " 'pressure': 1017.0,\n", + " 'station': 'metro-canal-du-midi',\n", + " 'temperature': 6.54,\n", + " 'wind': 9.3}\n", + "Number of available bikes: 1\n" + ] + } + ], "source": [ "dataset = datasets.Bikes()\n", "\n", @@ -38,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -63,9 +79,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n TransformerUnion (\n Select (\n clouds\n humidity\n pressure\n temperature\n wind\n ),\n Pipeline (\n FuncTransformer (\n func=\"get_hour\"\n ),\n TargetAgg (\n by=['station', 'hour']\n how=Mean ()\n target_name=\"y\"\n )\n )\n ),\n StandardScaler (\n with_std=True\n ),\n Regressor (\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=\n lr=0.001\n device=\"cpu\"\n seed=42\n )\n)", + "text/html": "
['clouds', 'humidity', 'pressure', 'temperature', 'wind']
(\n clouds\n humidity\n pressure\n temperature\n wind\n)\n\n
get_hour
\ndef get_hour(x):\n x['hour'] = x['moment'].hour\n return x\n\n
y_mean_by_station_and_hour
(\n by=['station', 'hour']\n how=Mean ()\n target_name=\"y\"\n)\n\n
StandardScaler
(\n with_std=True\n)\n\n
Regressor
(\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.001\n device=\"cpu\"\n seed=42\n)\n\n
" + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "metric = metrics.MAE()\n", "\n", @@ -81,9 +107,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "5000it [00:04, 1029.49it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAE: 6.83\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x, y in tqdm(dataset.take(5000)):\n", " y_pred = model_pipeline.predict_one(x)\n", diff --git a/docs/examples/regression/example_rnn_regression.ipynb b/docs/examples/regression/example_rnn_regression.ipynb index b6368cb..da5a93c 100644 --- a/docs/examples/regression/example_rnn_regression.ipynb +++ b/docs/examples/regression/example_rnn_regression.ipynb @@ -11,11 +11,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "from river_torch.regression import RollingRegressor\n", + "from deep_river.regression import RollingRegressor\n", "from river import metrics, compose, preprocessing, datasets, stats, feature_extraction\n", "from torch import nn\n", "from tqdm import tqdm" @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "outputs": [], "source": [ "def get_hour(x):\n", @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "outputs": [], "source": [ "class RnnModule(nn.Module):\n", @@ -66,8 +66,18 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 4, + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n TransformerUnion (\n Select (\n clouds\n humidity\n pressure\n temperature\n wind\n ),\n Pipeline (\n FuncTransformer (\n func=\"get_hour\"\n ),\n TargetAgg (\n by=['station', 'hour']\n how=Mean ()\n target_name=\"y\"\n )\n )\n ),\n StandardScaler (\n with_std=True\n ),\n RollingRegressor (\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=\n lr=0.01\n window_size=20\n append_predict=True\n device=\"cpu\"\n seed=42\n )\n)", + "text/html": "
['clouds', 'humidity', 'pressure', 'temperature', 'wind']
(\n clouds\n humidity\n pressure\n temperature\n wind\n)\n\n
get_hour
\ndef get_hour(x):\n x['hour'] = x['moment'].hour\n return x\n\n
y_mean_by_station_and_hour
(\n by=['station', 'hour']\n how=Mean ()\n target_name=\"y\"\n)\n\n
StandardScaler
(\n with_std=True\n)\n\n
RollingRegressor
(\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.01\n window_size=20\n append_predict=True\n device=\"cpu\"\n seed=42\n)\n\n
" + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dataset = datasets.Bikes()\n", "metric = metrics.MAE()\n", @@ -95,8 +105,30 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 5, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "5000it [00:11, 451.42it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAE: 3.94\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x, y in tqdm(dataset.take(5000)):\n", " y_pred = model_pipeline.predict_one(x)\n", @@ -119,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -139,9 +171,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": "Pipeline (\n TransformerUnion (\n Select (\n clouds\n humidity\n pressure\n temperature\n wind\n ),\n Pipeline (\n FuncTransformer (\n func=\"get_hour\"\n ),\n TargetAgg (\n by=['station', 'hour']\n how=Mean ()\n target_name=\"y\"\n )\n )\n ),\n StandardScaler (\n with_std=True\n ),\n RollingRegressor (\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=\n lr=0.01\n window_size=20\n append_predict=True\n device=\"cpu\"\n seed=42\n )\n)", + "text/html": "
['clouds', 'humidity', 'pressure', 'temperature', 'wind']
(\n clouds\n humidity\n pressure\n temperature\n wind\n)\n\n
get_hour
\ndef get_hour(x):\n x['hour'] = x['moment'].hour\n return x\n\n
y_mean_by_station_and_hour
(\n by=['station', 'hour']\n how=Mean ()\n target_name=\"y\"\n)\n\n
StandardScaler
(\n with_std=True\n)\n\n
RollingRegressor
(\n module=None\n loss_fn=\"mse_loss\"\n optimizer_fn=<class 'torch.optim.sgd.SGD'>\n lr=0.01\n window_size=20\n append_predict=True\n device=\"cpu\"\n seed=42\n)\n\n
" + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dataset = datasets.Bikes()\n", "metric = metrics.MAE()\n", @@ -166,9 +208,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "5000it [00:22, 225.22it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAE: 2.81\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ "for x, y in tqdm(dataset.take(5000)):\n", " y_pred = model_pipeline.predict_one(x)\n", diff --git a/docs/getting_started.md b/docs/getting_started.md index 346e499..d52f4ee 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -1,33 +1,33 @@ # Getting started We build the development of neural networks on top of the river API 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
Documentation. +For further examples check out the Documentation. ##πŸ’ˆInstallation River is meant to work with Python 3.8 and above. Installation can be done via `pip`: ```sh -pip install river-torch +pip install deep-river ``` or ```sh -pip install "river[torch]" +pip install "river[deep]" ``` You can install the latest development version from GitHub, as so: ```sh -pip install git+https://github.com/online-ml/river-torch --upgrade +pip install git+https://github.com/online-ml/deep-river --upgrade ``` Or, through SSH: ```sh -pip install git+ssh://git@github.com/online-ml/river-torch.git --upgrade +pip install git+ssh://git@github.com/online-ml/deep-river.git --upgrade ``` -Feel welcome to [open an issue on GitHub](https://github.com/online-ml/river-torch/issues/new) if you are having any trouble. +Feel welcome to [open an issue on GitHub](https://github.com/online-ml/deep-river/issues/new) if you are having any trouble. ## πŸ’» Usage @@ -36,7 +36,7 @@ Feel welcome to [open an issue on GitHub](https://github.com/online-ml/river-tor ```python >>> from river import metrics, datasets, preprocessing, compose ->>> from river_torch import classification +>>> from deep_river import classification >>> from torch import nn >>> from torch import optim >>> from torch import manual_seed @@ -60,7 +60,7 @@ Feel welcome to [open an issue on GitHub](https://github.com/online-ml/river-tor >>> model_pipeline = compose.Pipeline( ... preprocessing.StandardScaler(), ... classification.Classifier(module=MyModule, loss_fn='binary_cross_entropy', optimizer_fn='adam') -... ) +... ) >>> dataset = datasets.Phishing() >>> metric = metrics.Accuracy() @@ -68,8 +68,8 @@ Feel welcome to [open an issue on GitHub](https://github.com/online-ml/river-tor >>> for x, y in dataset: ... y_pred = model_pipeline.predict_one(x) # make a prediction ... metric = metric.update(y, y_pred) # update the metric -... model_pipeline = model_pipeline.learn_one(x,y) # make the model learn ->>> print(f"Accuracy: {metric.get():.4f}") +... model_pipeline = model_pipeline.learn_one(x, y) # make the model learn +>>> print(f"Accuracy: {metric.get():.4f}") Accuracy: 0.6728 ``` @@ -78,7 +78,7 @@ Accuracy: 0.6728 ```python >>> from river import metrics, compose, preprocessing, datasets ->>> from river_torch.regression import Regressor +>>> from deep_river.regression import Regressor >>> from torch import nn >>> from pprint import pprint >>> from tqdm import tqdm @@ -89,16 +89,17 @@ Accuracy: 0.6728 >>> class MyModule(nn.Module): ... def __init__(self, n_features): ... super(MyModule, self).__init__() -... self.dense0 = nn.Linear(n_features,5) +... self.dense0 = nn.Linear(n_features, 5) ... self.nonlin = nn.ReLU() ... self.dense1 = nn.Linear(5, 1) ... 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.Select('clouds', 'humidity', 'pressure', 'temperature', 'wind') >>> model_pipeline |= preprocessing.StandardScaler() >>> model_pipeline |= Regressor(module=MyModule, loss_fn="mse", optimizer_fn='sgd') @@ -108,12 +109,13 @@ Accuracy: 0.6728 ... model_pipeline.learn_one(x=x, y=y) print(f'MAE: {metric.get():.2f}') MAE: 6.83 + ``` ### Anomaly Detection ```python ->>> from river_torch.anomaly import Autoencoder +>>> from deep_river.anomaly import Autoencoder >>> from river import metrics >>> from river.datasets import CreditCard >>> from torch import nn @@ -125,6 +127,7 @@ MAE: 6.83 >>> metric = metrics.ROCAUC(n_thresholds=50) >>> class MyAutoEncoder(nn.Module): + ... def __init__(self, n_features, latent_dim=3): ... super(MyAutoEncoder, self).__init__() ... self.linear1 = nn.Linear(n_features, latent_dim) @@ -143,10 +146,12 @@ MAE: 6.83 >>> model = Pipeline(scaler, ae) >>> for x, y in dataset: -... score = model.score_one(x) -... model = model.learn_one(x=x) -... metric = metric.update(y, score) -... +... score = model.score_one(x) +... model = model.learn_one(x=x) +... metric = metric.update(y, score) +... + >>> print(f"ROCAUC: {metric.get():.4f}") ROCAUC: 0.7447 + ``` diff --git a/docs/img/logo.png b/docs/img/logo.png index 6f42419..62c68e9 100644 Binary files a/docs/img/logo.png and b/docs/img/logo.png differ diff --git a/docs/index.md b/docs/index.md index a4ab23f..7cffd46 100644 --- a/docs/index.md +++ b/docs/index.md @@ -2,5 +2,5 @@ hide: - navigation template: home.html -title: river-torch +title: deep-river --- diff --git a/docs/overrides/home.html b/docs/overrides/home.html index c947663..5fe3473 100644 --- a/docs/overrides/home.html +++ b/docs/overrides/home.html @@ -10,7 +10,7 @@
-

river-torch

+

deep-river

A Python package for online deep learning that wraps PyTorch for river.

Get started diff --git a/docs/scripts/gen_ref_pages.py b/docs/scripts/gen_ref_pages.py index 1b34eb6..acc82bf 100644 --- a/docs/scripts/gen_ref_pages.py +++ b/docs/scripts/gen_ref_pages.py @@ -6,9 +6,9 @@ nav = mkdocs_gen_files.Nav() -for path in sorted(Path("river_torch").rglob("*.py")): - module_path = path.relative_to("river_torch").with_suffix("") - doc_path = path.relative_to("river_torch").with_suffix(".md") +for path in sorted(Path("deep_river").rglob("*.py")): + module_path = path.relative_to("deep_river").with_suffix("") + doc_path = path.relative_to("deep_river").with_suffix(".md") full_doc_path = Path("reference", doc_path) parts = list(module_path.parts) @@ -27,7 +27,7 @@ with mkdocs_gen_files.open(full_doc_path, "w+") as fd: identifier = ".".join(parts) - print(f"::: river_torch.{identifier}", file=fd) + print(f"::: deep_river.{identifier}", file=fd) mkdocs_gen_files.set_edit_path(full_doc_path, path) diff --git a/mkdocs.yml b/mkdocs.yml index d194f23..e0df26e 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,13 +1,13 @@ # Project information -site_name: river-torch -site_description: river-torch is a Python library for incremental deep learning and serves as extension for river. +site_name: deep-river +site_description: deep-river is a Python library for incremental deep learning and serves as extension for river. site_author: Cedric Kulbach -site_url: https://github.com/kulbachcedric/river-torch +site_url: https://github.com/kulbachcedric/deep-river # Repository -repo_name: river-torch -repo_url: https://github.com/online-ml/river-torch -edit_uri: "https://github.com/online-ml/river-torch" +repo_name: deep-river +repo_url: https://github.com/online-ml/deep-river +edit_uri: "https://github.com/online-ml/deep-river" # Copyright copyright: Copyright © 2019 - 2022 @@ -42,7 +42,7 @@ theme: extra: social: - icon: fontawesome/brands/github-alt - link: https://github.com/online-ml/river-torch + link: https://github.com/online-ml/deep-river version: - provider: mike diff --git a/river_torch/classification/__init__.py b/river_torch/classification/__init__.py deleted file mode 100644 index 787f3c5..0000000 --- a/river_torch/classification/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -from river_torch.classification.classifier import Classifier -from river_torch.classification.rolling_classifier import RollingClassifier - -__all__ = [ - "Classifier", - "RollingClassifier", -] diff --git a/river_torch/regression/__init__.py b/river_torch/regression/__init__.py deleted file mode 100644 index 1cdd3b5..0000000 --- a/river_torch/regression/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -from river_torch.regression.regressor import Regressor -from river_torch.regression.rolling_regressor import RollingRegressor - -__all__ = [ - "Regressor", - "RollingRegressor", -] diff --git a/setup.py b/setup.py index 16ccc13..f25071e 100644 --- a/setup.py +++ b/setup.py @@ -3,10 +3,10 @@ import setuptools # Package meta-data. -NAME = "river_torch" +NAME = "deep_river" DESCRIPTION = "Online Deep Learning for river" LONG_DESCRIPTION_CONTENT_TYPE = "text/markdown" -URL = "https://github.com/kulbachcedric/IncrementalTorch" +URL = "https://online-ml.github.io/deep-river/" EMAIL = "cedric.kulbach@googlemail.com" AUTHOR = "Cedric Kulbach" REQUIRES_PYTHON = ">=3.6.0"