From 7767164f017f49d967dee9c172a06b77cfa85394 Mon Sep 17 00:00:00 2001
From: Pietro Tanure <pietro.tanure-onnis@ensta-paris.fr>
Date: Fri, 25 Aug 2023 00:09:40 +0200
Subject: [PATCH 01/43] Merge branch 'ilof-pietro' of
 https://github.com/pietro-tanure/river into ilof-pietro

---
 river/anomaly/__init__.py         |   2 +
 river/anomaly/ilof.py             | 492 +++++++++++++++++++
 river/anomaly/ilof_notebook.ipynb | 779 ++++++++++++++++++++++++++++++
 3 files changed, 1273 insertions(+)
 create mode 100644 river/anomaly/ilof.py
 create mode 100644 river/anomaly/ilof_notebook.ipynb

diff --git a/river/anomaly/__init__.py b/river/anomaly/__init__.py
index 932023896e..60ff843329 100644
--- a/river/anomaly/__init__.py
+++ b/river/anomaly/__init__.py
@@ -17,6 +17,7 @@
 from .filter import QuantileFilter, ThresholdFilter
 from .gaussian import GaussianScorer
 from .hst import HalfSpaceTrees
+from .ilof import ILOF
 from .svm import OneClassSVM
 
 __all__ = [
@@ -27,4 +28,5 @@
     "OneClassSVM",
     "QuantileFilter",
     "ThresholdFilter",
+    "ILOF",
 ]
diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
new file mode 100644
index 0000000000..eca4a1008b
--- /dev/null
+++ b/river/anomaly/ilof.py
@@ -0,0 +1,492 @@
+from __future__ import annotations
+
+import functools
+
+import pandas as pd
+
+from river import anomaly, utils
+from river.neighbors.base import DistanceFunc
+from river.utils import VectorDict
+
+
+class ILOF(anomaly.base.AnomalyDetector):
+    """Incremental Local Outlier Factor (ILOF).
+
+    ILOF Algorithm as described in the reference paper
+    ----------
+
+    The Incremental Local Outlier Factor (ILOF) is an online version of the Local Outlier Factor (LOF) used to identify outliers based on density of local neighbors.
+
+    We consider:
+        - NewPoints: new points;
+        - kNN(p): the neighboors of p (the k closest points to p)
+        - RkNN(p): the rev-neighboors of p (points that have p as one of their neighboors)
+        - Set_upd_lrd: Set of points that need to update the local reachability distance
+        - Set_upd_lof: Set of points that need to update the local outlier factor
+
+    The algorithm here implemented based on the original one in the paper is:
+        1) Insert NewPoints and calculate its distance to existing points
+        2) Update the neighboors and reverse-neighboors of all the points
+        3) Define sets of affected points that required update
+        4) Calculate the reachability-distance from new point to neighboors (NewPoints -> kNN(NewPoints)) and from rev-neighboors to new point (RkNN(NewPoints) -> NewPoints)
+        5) Update the reachability-distance for affected points: RkNN(RkNN(NewPoints)) -> RkNN(NewPoints)
+        6) Update local reachability distance of affected points: lrd(Set_upd_lrd)
+        7) Update local outlier factor: lof(Set_upd_lof)
+
+    Parameters
+    ----------
+    n_neighbors : int
+        The number of nearest neighbors to use for density estimation.
+    window_size : int
+        The size of the batch of data to be taken in at once for the model to learn
+    distance_func : function that takes in dictionaries
+        A distance function to use. By default, the Euclidean distance is used.
+    verbose: boolean
+        Whether or not to print messages
+
+    Attributes
+    ----------
+    X
+        A list of stored observations.
+    X_batch
+        A buffer to hold incoming observations until it's time to update the model.
+    X_score
+        A buffer to hold incoming observations until it's time to score them.
+    dist_dict
+        A dictionary to hold distances between observations.
+    neighborhoods
+        A dictionary to hold neighborhoods for each observation.
+    rev_neighborhoods
+        A dictionary to hold reverse neighborhoods for each observation.
+    k_dist
+        A dictionary to hold k-distances for each observation.
+    reach_dist
+        A dictionary to hold reachability distances for each observation.
+    lof
+        A dictionary to hold Local Outlier Factors for each observation.
+    local_reach
+        A dictionary to hold local reachability distances for each observation.
+    skip_first
+        A boolean value indicating whether to skip the first window of data.
+
+    Example
+    ----------
+    from river import datasets
+    import pandas as pd
+    import ilof as ilof
+    dataset = pd.DataFrame(datasets.CreditCard())
+    #Define model
+    k = 20 #k-neighboors
+    ilof_river = ilof.ILOF(k, verbose=False)
+    ilof_river.learn_many(dataset[0:30])
+    for i in dataset[0][40:90]:
+        ilof_river.learn_one(i)
+    lof_score = []
+    for x in dataset[0][100:120]:
+        lof_score.append(ilof_river.score_one(x))
+
+    References
+    ----------
+    Pokrajac, David & Lazarevic, Aleksandar & Latecki, Longin Jan. (2007). Incremental Local Outlier Detection for Data Streams. Proceedings of the 2007 IEEE Symposium on Computational Intelligence and Data Mining, CIDM 2007. 504-515. 10.1109/CIDM.2007.368917.
+    """
+
+    def __init__(
+        self,
+        n_neighbors: int = 10,
+        verbose=True,
+        distance_func: DistanceFunc = None,
+    ):
+        self.n_neighbors = n_neighbors
+        self.X: list = []
+        self.X_batch: list = []
+        self.X_score: list = []
+        self.dist_dict: dict = {}
+        self.neighborhoods: dict = {}
+        self.rev_neighborhoods: dict = {}
+        self.k_dist: dict = {}
+        self.reach_dist: dict = {}
+        self.lof: dict = {}
+        self.local_reach: dict = {}
+        self.verbose = verbose
+        self.distance = (
+            distance_func
+            if distance_func is not None
+            else functools.partial(utils.math.minkowski_distance, p=2)
+        )
+
+    def learn_many(self, X_batch: pd.Series):
+        """
+        Update the model with many incoming observations
+
+        Parameters
+        ----------
+        X_batch
+            A Panda Series
+        """
+        X_batch = X_batch[0].tolist()
+        self.learn(X_batch)
+
+    def learn_one(self, x: dict):
+        """
+        Update the model with one incoming observation
+
+        Parameters
+        ----------
+        x
+            A dictionary of feature values.
+        """
+        self.X_batch.append(x)
+        if len(self.X) or len(self.X_batch) > 1:
+            self.learn(self.X_batch)
+            self.X_batch = []
+
+    def learn(self, X_batch: list):
+        X_batch, equal = self.check_equal(X_batch, self.X)
+        if equal != 0 and self.verbose:
+            print("%i samples are equal to previous data" % equal)
+
+        if len(X_batch) == 0:
+            if self.verbose:
+                print("No new data was added")
+        else:
+            # Increase size of objects to acomodate new data
+            (
+                nm,
+                self.X,
+                self.neighborhoods,
+                self.rev_neighborhoods,
+                self.k_dist,
+                self.reach_dist,
+                self.dist_dict,
+                self.local_reach,
+                self.lof,
+            ) = self.expand_objects(
+                X_batch,
+                self.X,
+                self.neighborhoods,
+                self.rev_neighborhoods,
+                self.k_dist,
+                self.reach_dist,
+                self.dist_dict,
+                self.local_reach,
+                self.lof,
+            )
+
+            # Calculate neighborhoods, reverse neighborhoods, k-distances and distances between neighboors
+            (
+                self.neighborhoods,
+                self.rev_neighborhoods,
+                self.k_dist,
+                self.dist_dict,
+            ) = self.initial_calculations(
+                self.X, nm, self.neighborhoods, self.rev_neighborhoods, self.k_dist, self.dist_dict
+            )
+
+            # Define sets of particles
+            (
+                Set_new_points,
+                Set_neighbors,
+                Set_rev_neighbors,
+                Set_upd_lrd,
+                Set_upd_lof,
+            ) = self.define_sets(nm, self.neighborhoods, self.rev_neighborhoods)
+
+            # Calculate new reachability distance of all affected points
+            self.reach_dist = self.calc_reach_dist_newpoints(
+                Set_new_points,
+                self.neighborhoods,
+                self.rev_neighborhoods,
+                self.reach_dist,
+                self.dist_dict,
+                self.k_dist,
+            )
+            self.reach_dist = self.calc_reach_dist_otherpoints(
+                Set_rev_neighbors,
+                self.neighborhoods,
+                self.rev_neighborhoods,
+                self.reach_dist,
+                self.dist_dict,
+                self.k_dist,
+            )
+
+            # Calculate new local reachability distance of all affected points
+            self.local_reach = self.calc_local_reach_dist(
+                Set_upd_lrd, self.neighborhoods, self.reach_dist, self.local_reach
+            )
+
+            # Calculate new Local Outlier Factor of all affected points
+            self.lof = self.calc_lof(Set_upd_lof, self.neighborhoods, self.local_reach, self.lof)
+
+    def score_one(self, x: VectorDict, window_score=1):
+        """
+        Score incoming observations based on model constructed previously.
+        Perform same calculations as 'learn_one' function but doesn't add the new calculations to the atributes
+        Data samples that are equal to samples stored by the model are not considered.
+
+        Parameters
+        ----------
+        x
+            A dictionary of feature values.
+        window_score
+            The size of the batch of data to be taken in at once for the model to score
+
+        Returns
+        -------
+        lof : list
+            List of LOF calculated for incoming data
+        """
+
+        self.X_score.append(x)
+
+        if len(self.X_score) >= window_score:
+            self.X_score, equal = self.check_equal(self.X_score, self.X)
+            if equal != 0 and self.verbose:
+                print("%i samples are equal to previous data" % equal)
+
+            if len(self.X_score) == 0:
+                if self.verbose:
+                    print("No new data was added")
+            else:
+                Xs = self.X.copy()
+                (
+                    nm,
+                    Xs,
+                    neighborhoods,
+                    rev_neighborhoods,
+                    k_dist,
+                    reach_dist,
+                    dist_dict,
+                    local_reach,
+                    lof,
+                ) = self.expand_objects(
+                    self.X_score,
+                    Xs,
+                    self.neighborhoods,
+                    self.rev_neighborhoods,
+                    self.k_dist,
+                    self.reach_dist,
+                    self.dist_dict,
+                    self.local_reach,
+                    self.lof,
+                )
+
+                neighborhoods, rev_neighborhoods, k_dist, dist_dict = self.initial_calculations(
+                    Xs, nm, neighborhoods, rev_neighborhoods, k_dist, dist_dict
+                )
+                (
+                    Set_new_points,
+                    Set_neighbors,
+                    Set_rev_neighbors,
+                    Set_upd_lrd,
+                    Set_upd_lof,
+                ) = self.define_sets(nm, neighborhoods, rev_neighborhoods)
+                reach_dist = self.calc_reach_dist_newpoints(
+                    Set_new_points, neighborhoods, rev_neighborhoods, reach_dist, dist_dict, k_dist
+                )
+                reach_dist = self.calc_reach_dist_otherpoints(
+                    Set_rev_neighbors,
+                    neighborhoods,
+                    rev_neighborhoods,
+                    reach_dist,
+                    dist_dict,
+                    k_dist,
+                )
+                local_reach = self.calc_local_reach_dist(
+                    Set_upd_lrd, neighborhoods, reach_dist, local_reach
+                )
+                lof = self.calc_lof(Set_upd_lof, neighborhoods, local_reach, lof)
+                self.X_score = []
+
+                score_keys = list(range(nm[0], nm[0] + nm[1]))
+                return [lof[i] for i in score_keys]
+
+    def initial_calculations(
+        self,
+        X: list,
+        nm: tuple,
+        neighborhoods: dict,
+        rev_neighborhoods: dict,
+        k_distances: dict,
+        dist_dict: dict,
+    ):
+        """
+        Perform initial calculations on the incoming data before applying the ILOF algorithm.
+        Taking the new data, it updates the neighborhoods, reverse neighborhoods, k-distances and distances between particles.
+
+        Parameters
+        ----------
+        X
+            A list of stored observations.
+        nm : tuple of ints, (n, m)
+            A tuple representing the current size of the dataset.
+        neighborhoods : dict
+            A dictionary of particle neighborhoods.
+        rev_neighborhoods : dict
+            A dictionary of reverse particle neighborhoods.
+        k_distances : dict
+            A dictionary to hold k-distances for each observation.
+        dist_dict : dict of dicts
+            A dictionary of dictionaries storing distances between particles
+
+        Returns
+        -------
+        neighborhoods : dict
+            Updated dictionary of particle neighborhoods
+        rev_neighborhoods : dict
+            Updated dictionary of reverse particle neighborhoods
+        k_distances : dict
+            Updated dictionary to hold k-distances for each observation
+        dist_dict : dict of dicts
+            Updated dictionary of dictionaries storing distances between particles
+        """
+
+        n = nm[0]
+        m = nm[1]
+        k = self.n_neighbors
+
+        # Calculate distances all particles consdering new and old ones
+        new_distances = [
+            [i, j, self.distance(X[i], X[j])] for i in range(n + m) for j in range(i) if i >= n
+        ]
+        # Add new distances to distance dictionary
+        for i in range(len(new_distances)):
+            dist_dict[new_distances[i][0]][new_distances[i][1]] = new_distances[i][2]
+            dist_dict[new_distances[i][1]][new_distances[i][0]] = new_distances[i][2]
+
+        # Calculate new k-dist for each particle
+        for i, inner_dict in enumerate(dist_dict.values()):
+            k_distances[i] = sorted(inner_dict.values())[min(k, len(inner_dict.values())) - 1]
+
+        # Only keep particles that are neighbors in distance dictionary
+        dist_dict = {
+            k: {k2: v2 for k2, v2 in v.items() if v2 <= k_distances[k]}
+            for k, v in dist_dict.items()
+        }
+
+        # Define new neighborhoods for particles
+        for key, value in dist_dict.items():
+            neighborhoods[key] = [index for index in value]
+
+        # Define new reverse neighborhoods for particles
+        for particle_id, neighbor_ids in neighborhoods.items():
+            for neighbor_id in neighbor_ids:
+                rev_neighborhoods[neighbor_id].append(particle_id)
+
+        return neighborhoods, rev_neighborhoods, k_distances, dist_dict
+
+    def check_equal(self, X: list, Y: list):
+        """Check if new batch X has some data samples equal to previous data recorded Y"""
+        result = [x for x in X if not any(x == y for y in Y)]
+        return result, len(X) - len(result)
+
+    def expand_objects(
+        self,
+        new_particles: list,
+        X: list,
+        neighborhoods: dict,
+        rev_neighborhoods: dict,
+        k_dist: dict,
+        reach_dist: dict,
+        dist_dict: dict,
+        local_reach: dict,
+        lof: dict,
+    ):
+        """Expand size of dictionaries and lists to fit new data"""
+        n = len(X)
+        m = len(new_particles)
+        X.extend(new_particles)
+        neighborhoods.update({i: [] for i in range(n + m)})
+        rev_neighborhoods.update({i: [] for i in range(n + m)})
+        k_dist.update({i: float("inf") for i in range(n + m)})
+        reach_dist.update({i + n: {} for i in range(m)})
+        dist_dict.update({i + n: {} for i in range(m)})
+        local_reach.update({i + n: [] for i in range(m)})
+        lof.update({i + n: [] for i in range(m)})
+        return (
+            (n, m),
+            X,
+            neighborhoods,
+            rev_neighborhoods,
+            k_dist,
+            reach_dist,
+            dist_dict,
+            local_reach,
+            lof,
+        )
+
+    def define_sets(self, nm, neighborhoods: dict, rev_neighborhoods: dict):
+        """Define sets of points for the ILOF algorithm"""
+        # Define set of new points from batch
+        Set_new_points = set(range(nm[0], nm[0] + nm[1]))
+        Set_neighbors: set = set()
+        Set_rev_neighbors: set = set()
+
+        # Define neighbors and reverse neighbors of new data points
+        for i in Set_new_points:
+            Set_neighbors = set(Set_neighbors) | set(neighborhoods[i])
+            Set_rev_neighbors = set(Set_rev_neighbors) | set(rev_neighborhoods[i])
+
+        # Define points that need to update their local reachability distance because of new data points
+        Set_upd_lrd = Set_rev_neighbors
+        for j in Set_rev_neighbors:
+            Set_upd_lrd = Set_upd_lrd | set(rev_neighborhoods[j])
+        Set_upd_lrd = Set_upd_lrd | Set_new_points
+
+        # Define points that need to update their lof because of new data points
+        Set_upd_lof = Set_upd_lrd
+        for m in Set_upd_lrd:
+            Set_upd_lof = Set_upd_lof | set(rev_neighborhoods[m])
+        Set_upd_lof = Set_upd_lof
+
+        return Set_new_points, Set_neighbors, Set_rev_neighbors, Set_upd_lrd, Set_upd_lof
+
+    def calc_reach_dist_newpoints(
+        self,
+        Set: set,
+        neighborhoods: dict,
+        rev_neighborhoods: dict,
+        reach_dist: dict,
+        dist_dict: dict,
+        k_dist: dict,
+    ):
+        """Calculate reachability distance from new points to neighbors and from neighbors to new points"""
+        for c in Set:
+            for j in set(neighborhoods[c]):
+                reach_dist[c][j] = max(dist_dict[c][j], k_dist[j])
+            for j in set(rev_neighborhoods[c]):
+                reach_dist[j][c] = max(dist_dict[j][c], k_dist[c])
+        return reach_dist
+
+    def calc_reach_dist_otherpoints(
+        self,
+        Set: set,
+        neighborhoods: dict,
+        rev_neighborhoods: dict,
+        reach_dist: dict,
+        dist_dict: dict,
+        k_dist: dict,
+    ):
+        """Calculate reachability distance from reverse neighbors of reverse neighbors ( RkNN(RkNN(NewPoints)) ) to reverse neighbors ( RkNN(NewPoints) )
+        These values change because of the insertion of new points"""
+        for j in Set:
+            for i in set(rev_neighborhoods[j]):
+                reach_dist[i][j] = max(dist_dict[i][j], k_dist[j])
+        return reach_dist
+
+    def calc_local_reach_dist(
+        self, Set: set, neighborhoods: dict, reach_dist: dict, local_reach_dist: dict
+    ):
+        """Calculate local reachability distance of affected points"""
+        for i in Set:
+            local_reach_dist[i] = len(neighborhoods[i]) / sum(
+                [reach_dist[i][j] for j in neighborhoods[i]]
+            )
+        return local_reach_dist
+
+    def calc_lof(self, Set: set, neighborhoods: dict, local_reach: dict, lof: dict):
+        """Calculate local outlier factor of affected points"""
+        for i in Set:
+            lof[i] = sum([local_reach[j] for j in neighborhoods[i]]) / (
+                len(neighborhoods[i]) * local_reach[i]
+            )
+        return lof
diff --git a/river/anomaly/ilof_notebook.ipynb b/river/anomaly/ilof_notebook.ipynb
new file mode 100644
index 0000000000..7509df27ee
--- /dev/null
+++ b/river/anomaly/ilof_notebook.ipynb
@@ -0,0 +1,779 @@
+{
+ "cells": [
+  {
+   "attachments": {
+    "Screenshot from 2023-06-08 10-01-42.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Incremental Local Outlier factor\n",
+    "\n",
+    "##### Created by: Pietro TANURE ONNIS\n",
+    "##### Final project for the Online Machine Learning course at Telecom Paris 2023\n",
+    "\n",
+    "The Incremental Local Outlier Factor (ILOF) is an online version of the Local Outlier Factor (LOF) used to identify outliers based on density of local neighbors.\n",
+    "\n",
+    "We consider: \n",
+    "\n",
+    "    - NewPoints: new points; \n",
+    "    - kNN(p): the neighboors of p (the k closest points to p)\n",
+    "    - RkNN(p): the rev-neighboors of p (points that have p as one of their neighboors)\n",
+    "    - Set_upd_lrd: Set of points that need to update the local reachability distance\n",
+    "    - Set_upd_lof: Set of points that need to update the local outlier factor\n",
+    "\n",
+    "The algorithm here implemented based on the original one in the paper is:\n",
+    "\n",
+    "    1) Insert NewPoints and calculate its distance to existing points\n",
+    "    2) Update the neighboors and reverse-neighboors of all the points\n",
+    "    3) Define sets of affected points that required update\n",
+    "    4) Calculate the reachability-distance from new point to neighboors (NewPoints -> kNN(NewPoints)) and from rev-neighboors to new point (RkNN(NewPoints) -> NewPoints)\n",
+    "    5) Update the reachability-distance for affected points: RkNN(RkNN(NewPoints)) -> RkNN(NewPoints)\n",
+    "    6) Update local reachability distance of affected points: lrd(Set_upd_lrd)\n",
+    "    7) Update local outlier factor: lof(Set_upd_lof)\n",
+    "\n",
+    "Reference: Pokrajac, David & Lazarevic, Aleksandar & Latecki, Longin Jan. (2007). Incremental Local Outlier Detection for Data Streams. Proceedings of the 2007 IEEE Symposium on Computational Intelligence and Data Mining, CIDM 2007. 504-515. 10.1109/CIDM.2007.368917. \n",
+    "\n",
+    "![Screenshot from 2023-06-08 10-01-42.png](<attachment:Screenshot from 2023-06-08 10-01-42.png>)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate data with some outliers\n",
+    "\n",
+    "We create an artifical data centered around two cluster and add some data made from another distribuition (outliers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "\n",
+    "# Generate train data\n",
+    "X_inliers = 0.3 * np.random.randn(100, 2)\n",
+    "X_inliers = np.r_[X_inliers + 2, X_inliers - 2]\n",
+    "\n",
+    "# Generate some outliers\n",
+    "X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))\n",
+    "X = np.r_[X_inliers, X_outliers]\n",
+    "\n",
+    "n_outliers = len(X_outliers)\n",
+    "ground_truth = np.ones(len(X), dtype=int)\n",
+    "ground_truth[-n_outliers:] = -1\n",
+    "\n",
+    "#Visualize data\n",
+    "plt.title(\"Data with Outliers\")\n",
+    "plt.scatter(X[:, 0], X[:, 1], color=\"k\", s=3.0, label=\"Data points\")\n",
+    "plt.axis(\"tight\")\n",
+    "plt.xlim((-5, 5))\n",
+    "plt.ylim((-5, 5))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Online Machine Learning with River\n",
+    "\n",
+    "Using the built class ILOF we calculte the Local Outlier Factor in an online approach, at each step we send an instance of data to the model, that will learn it using the 'learn_one' function, updating the model incrementally. \n",
+    "\n",
+    "The class ILOF takes in the following argumetns: \n",
+    "\n",
+    "ILOF(*k_neighbors = int; batch_size = int; verbose = boolean; distance_func = function*)\n",
+    "\n",
+    "\n",
+    "Function to learn batch of data: \n",
+    "\n",
+    "learn_one(*x: dictionary*)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ilof_ as ilof\n",
+    "from river import utils\n",
+    "\n",
+    "#Convert to dictionary\n",
+    "Xdicts = tuple({f'feature_{i+1}': x[i] for i in range(2)} for x in X)\n",
+    "\n",
+    "#Define model\n",
+    "k = 20 #k-neighboors\n",
+    "ilof_river = ilof.ILOF(k, verbose=False)\n",
+    "\n",
+    "#Fit model on stream data\n",
+    "for x in Xdicts:\n",
+    "    ilof_river.learn_one(x)\n",
+    "\n",
+    "lof_scores_river = np.array([v for v in ilof_river.lof.values()])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also evaluate data without adding learning it, this way the programme outputs a LOF for the data but doesn't update the parameters of the model (neighborhoods, reverse neighborhoods, k-distances, reachability-distances, local outlier factor).\n",
+    "\n",
+    "The learn_one function can take in the following arguments:\n",
+    "*learn_one(k_neighbors, batch_size, verbose, distance_func)*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[4.1225951442931335], [4.856989240600968], [6.700737740891463], [4.67398123498832], [10.318743687776967], [1.695085624011412], [3.1578141066216476], [1.6190480666043154], [4.135136784137301], [5.1959975977883746]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Evaluate data without updating the model\n",
+    "X_score = np.random.uniform(low=-4, high=4, size=(10, 2))\n",
+    "\n",
+    "X_score_dict = tuple({f'feature_{i+1}': x[i] for i in range(2)} for x in X_score)\n",
+    "\n",
+    "lof_score = []\n",
+    "for x in X_score_dict:\n",
+    "    lof_score.append(ilof_river.score_one(x))\n",
+    "\n",
+    "print(lof_score)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Batch Machine Learning with Scikit-learn\n",
+    "\n",
+    "To compare our results we fit a model with the same data using scikit-learn\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.neighbors import LocalOutlierFactor\n",
+    "\n",
+    "#Define the model\n",
+    "lof_scikit = LocalOutlierFactor(n_neighbors=k)\n",
+    "\n",
+    "#Fit model on data\n",
+    "lof_scikit.fit_predict(X)\n",
+    "\n",
+    "#Get Local Outlier Factor\n",
+    "lof_scores_scikit = - lof_scikit.negative_outlier_factor_"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot results\n",
+    "\n",
+    "We observe that both the online river approach (river) and the batch approach (sklearn) give the same results, but the online has the advantage of being adapted to treat data streams"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "We observe that the difference is at machine error level:\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([-4.09616785e-12, -6.33715302e-11,  1.09381393e-11, -1.17567955e-10,\n",
+       "        1.33887346e-11,  1.18958177e-11, -6.57527366e-11, -7.40709716e-11,\n",
+       "       -7.44937445e-12, -6.17876861e-11, -9.02540265e-11, -2.53728150e-11,\n",
+       "        1.22162280e-11, -1.55155888e-11,  1.49403823e-11, -1.26576083e-10,\n",
+       "       -1.56268332e-11, -4.20663504e-11, -7.77566900e-11, -2.44553267e-11,\n",
+       "       -2.61148880e-11,  1.45454759e-11, -5.68558534e-11, -2.96740410e-11,\n",
+       "       -5.03610487e-11,  6.52056187e-12,  8.45368220e-12, -6.24331697e-11,\n",
+       "        3.10773629e-12, -1.87143634e-11,  1.69848580e-11, -6.51001475e-11,\n",
+       "       -5.37054845e-11, -7.33879624e-12, -4.45921078e-12, -6.28377350e-11,\n",
+       "       -6.90747459e-11, -3.41847439e-10,  1.80840898e-11, -8.69331274e-11,\n",
+       "        2.49876786e-11, -1.05403020e-10, -6.49036380e-12, -5.79656323e-11,\n",
+       "        7.16537940e-12, -7.47046869e-12,  6.71662725e-12, -4.13140633e-11,\n",
+       "       -7.85482790e-13,  1.55593316e-11, -4.18334256e-11,  5.83022519e-12,\n",
+       "        2.18497442e-11, -1.66783476e-10,  1.46855861e-11, -1.15608412e-10,\n",
+       "       -1.78021597e-10,  2.40570897e-11, -2.40685250e-11, -7.99027511e-11,\n",
+       "       -3.46016549e-11, -1.07650999e-10, -1.20261578e-10, -3.42865736e-11,\n",
+       "        9.95292737e-12, -3.97579747e-11, -1.71840320e-11, -1.03541176e-10,\n",
+       "        8.75211015e-12, -4.21567226e-11, -5.32438538e-11, -5.20865573e-11,\n",
+       "       -3.00426350e-13, -9.62636637e-11, -1.02473585e-11,  2.13062901e-12,\n",
+       "        8.63087379e-12, -3.78064247e-12, -1.60033098e-10, -3.17976756e-11,\n",
+       "       -2.91409119e-11, -9.17790288e-11, -5.40958389e-11, -8.77666828e-11,\n",
+       "        8.20443713e-12, -4.10795842e-11,  2.28256303e-11, -6.83730850e-12,\n",
+       "       -6.59496902e-11, -2.46087373e-10, -2.80828694e-11, -1.77728943e-11,\n",
+       "        1.73787651e-11, -2.39386289e-12, -5.03110886e-11,  5.85975712e-13,\n",
+       "       -2.67477152e-11,  1.17149623e-11, -5.93547433e-12, -2.51376697e-11,\n",
+       "       -3.91231492e-12, -6.39361897e-11,  1.17769128e-11, -1.36209932e-10,\n",
+       "        1.12351239e-11,  1.16284760e-11, -6.91506852e-11, -8.15103540e-11,\n",
+       "       -9.22262267e-12, -6.39255315e-11, -9.08870756e-11, -2.77369239e-11,\n",
+       "        1.16167076e-11, -1.39550593e-11,  1.46895829e-11, -1.41733292e-10,\n",
+       "       -1.54865010e-11, -4.47302195e-11, -7.35935757e-11, -2.80169221e-11,\n",
+       "       -2.83830737e-11,  1.49515955e-11, -6.71342981e-11, -3.07622816e-11,\n",
+       "       -5.31310551e-11,  6.80433487e-12,  5.86319882e-12, -6.18920470e-11,\n",
+       "        3.35398376e-13, -2.10242934e-11,  1.76045845e-11, -6.86697366e-11,\n",
+       "       -6.14872597e-11, -6.16851015e-12, -3.94029254e-12, -6.70448141e-11,\n",
+       "       -7.16353643e-11, -3.63674646e-10,  1.83564275e-11, -7.49840190e-11,\n",
+       "        2.55555577e-11, -1.05627285e-10, -1.05502274e-11, -5.96580563e-11,\n",
+       "        4.42612613e-12, -6.44362341e-12,  6.25999252e-12, -4.48610038e-11,\n",
+       "       -5.12034859e-13,  1.57456270e-11, -4.36486403e-11,  4.71545025e-12,\n",
+       "        2.25058860e-11, -1.84880333e-10,  1.47774015e-11, -1.19127597e-10,\n",
+       "       -1.85351290e-10,  2.46216381e-11, -2.55948596e-11, -7.39723838e-11,\n",
+       "       -3.54656304e-11, -1.09745102e-10, -1.43158596e-10, -3.35480532e-11,\n",
+       "        1.04337650e-11, -4.41688908e-11, -1.50348622e-11, -1.16774812e-10,\n",
+       "        7.96585020e-12, -4.48201476e-11, -5.69460035e-11, -5.68629588e-11,\n",
+       "        5.56110713e-13, -1.03254738e-10, -1.00581765e-11,  2.49988918e-12,\n",
+       "        6.66378064e-12, -3.26383365e-12, -1.77152959e-10, -3.82229803e-11,\n",
+       "       -3.23736593e-11, -9.27151689e-11, -5.59789992e-11, -9.92872451e-11,\n",
+       "        8.13549228e-12, -4.12598844e-11,  2.33668640e-11, -8.91531293e-12,\n",
+       "       -6.88478163e-11, -2.58987498e-10, -2.74111844e-11, -1.59048330e-11,\n",
+       "        1.83143500e-11, -2.21744845e-12, -6.28099794e-11, -1.59727787e-12,\n",
+       "       -2.83923995e-11,  1.20728982e-11, -7.79643017e-12, -2.67832423e-11,\n",
+       "       -4.55934845e-10, -1.07836184e-10, -3.60191432e-10, -1.28838495e-10,\n",
+       "       -7.21577020e-10, -1.42578749e-09, -2.53113752e-10, -9.60296287e-11,\n",
+       "       -2.22227037e-09, -9.43074063e-10, -1.70505743e-09, -1.32515510e-09,\n",
+       "       -1.30334055e-09, -1.82649540e-09, -1.89989269e-09, -1.57570668e-09,\n",
+       "       -1.35358125e-09, -1.53304036e-09, -1.98927808e-09, -1.32804345e-09])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from river.utils import dict2numpy\n",
+    "X_scores1 = lof_scores_scikit\n",
+    "X_scores2 = lof_scores_river\n",
+    "\n",
+    "fig, axs = plt.subplots(ncols=2, figsize=(10, 5))\n",
+    "\n",
+    "# First plot\n",
+    "radius1 = (X_scores1.max() - X_scores1) / (X_scores1.max() - X_scores1.min()) * (X_scores1 > 1.5)\n",
+    "axs[0].set_title(\"Local Outlier Factor - Sklearn \")\n",
+    "axs[0].scatter(X[:, 0], X[:, 1], color=\"k\", s=3.0, label=\"Data points\")\n",
+    "axs[0].axis(\"tight\")\n",
+    "axs[0].set_xlim((-5, 5))\n",
+    "axs[0].set_ylim((-5, 5))\n",
+    "axs[0].scatter(X[:, 0], X[:, 1], s=1000 * radius1, edgecolors=\"r\", facecolors=\"none\", label=\"Outlier scores\")\n",
+    "axs[0].legend(loc=\"upper left\")\n",
+    "\n",
+    "# Second plot\n",
+    "radius2 = (max(X_scores2) - X_scores2) / (max(X_scores2) - min(X_scores2)) * (X_scores2 > 1.5)\n",
+    "axs[1].set_title(\"Incremental Local Outlier Factor - River\")\n",
+    "axs[1].scatter(X[:, 0], X[:, 1], color=\"k\", s=3.0, label=\"Data points\")\n",
+    "axs[1].axis(\"tight\")\n",
+    "axs[1].set_xlim((-5, 5))\n",
+    "axs[1].set_ylim((-5, 5))\n",
+    "axs[1].scatter(X[:, 0], X[:, 1], s=1000 * radius2, edgecolors=\"r\", facecolors=\"none\", label=\"Outlier scores\")\n",
+    "axs[1].legend(loc=\"upper left\")\n",
+    "\n",
+    "plt.show()\n",
+    "\n",
+    "print('We observe that the difference is at machine error level:')\n",
+    "X_scores1 - X_scores2"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Time comparison\n",
+    "\n",
+    "Although not adapted to a batch approach River ILOF also allows to calculate a mini-batch approach using the function 'learn_many', here we compare the time of execution of ScikitLOF and RiverILOF considering both receiving a *batch_size*  number of data points:\n",
+    "\n",
+    "ScikitLOF has applies methods like tree search that optimize the search for neighboors so its execution time remains more of less constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from river import datasets\n",
+    "import pandas as pd\n",
+    "from river.utils import dict2numpy\n",
+    "import time \n",
+    "dataset = pd.DataFrame(datasets.CreditCard())\n",
+    "dataset_np = [dict2numpy(i) for i in dataset[0].to_dict().values()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "We observe again that the error is of machine precision level:     (the few errors at the scale of e-05 are because of the river minkowski-distance function error,     I submitted a correction request, for details see bottom of this document  \n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([ 1.15640830e-12,  1.39670502e-05,  1.18705046e-12,  1.55497837e-12,\n",
+       "        4.09583478e-12,  1.33378808e-05,  1.28123493e-05,  1.81729894e-05,\n",
+       "        2.78910228e-12,  1.16189877e-05,  1.14542134e-05,  9.35752947e-03,\n",
+       "        1.18571819e-12,  1.33008174e-05,  2.86748403e-12,  1.16448999e-05,\n",
+       "        1.14404267e-05,  1.10114258e-05,  3.12239123e-12,  1.07421263e-05,\n",
+       "        5.79758463e-13,  1.48459023e-12,  1.02679237e-05,  1.10608636e-05,\n",
+       "        9.62921621e-06,  4.63407090e-13,  1.60071956e-12, -1.26565425e-13,\n",
+       "        1.02962083e-12, -1.02362563e-13, -1.12798659e-13, -8.31557045e-14,\n",
+       "       -1.26343380e-13, -1.26343380e-13, -9.31477118e-14, -9.31477118e-14,\n",
+       "        5.65991698e-13, -1.12909682e-13,  5.81756865e-14, -6.90558721e-14,\n",
+       "        5.17141885e-13, -1.15241150e-13, -3.32289751e-13, -1.55431223e-13,\n",
+       "       -3.33177930e-13, -7.32747196e-14, -1.53210777e-13, -2.20934382e-13,\n",
+       "        5.41122702e-13, -7.88258347e-14, -1.08357767e-13,  3.73034936e-13,\n",
+       "       -1.61870517e-13, -2.10720330e-13, -1.11577414e-13,  1.06137321e-13,\n",
+       "        7.18092252e-13, -2.16826557e-13, -1.96176408e-13, -1.94289029e-14,\n",
+       "        5.29576383e-13,  5.44231327e-13,  7.85815857e-13,  7.86259946e-13,\n",
+       "        5.29798427e-13,  1.77857729e-13,  1.84563476e-12,  2.95319325e-13,\n",
+       "        1.70974346e-12,  1.01563202e-12,  9.39026634e-13,  3.55271368e-15,\n",
+       "        1.93178806e-13,  1.67421632e-13,  4.48752147e-13,  1.11022302e-13,\n",
+       "        1.40487622e-12,  5.26911847e-13,  6.88338275e-14,  1.00586206e-13,\n",
+       "        2.87547763e-13,  1.34336986e-13,  7.30526750e-13,  3.91464638e-13,\n",
+       "        1.56761799e-04,  2.69784195e-13,  2.46469511e-13,  1.66405849e-04,\n",
+       "        1.58040050e-04,  2.77333712e-13,  3.08864045e-13,  1.92956762e-13,\n",
+       "        1.82164776e-04,  1.60346254e-04, -3.75195624e-04,  6.79012402e-13,\n",
+       "        1.57798215e-04, -2.95809327e-04, -3.33431024e-04,  6.43923737e-03,\n",
+       "        1.54669151e-04, -3.04159366e-04,  1.56511402e-04,  1.89848137e-13,\n",
+       "        1.55735689e-04, -2.70298576e-04, -5.93150343e-06, -5.30967388e-06,\n",
+       "        4.09087888e-04,  4.07393126e-04,  1.70752301e-13, -5.79448265e-06,\n",
+       "        4.07393126e-04,  4.07393126e-04,  4.07393126e-04,  4.07393126e-04,\n",
+       "        1.30118138e-13,  9.82103288e-13,  1.80522264e-13, -5.32003883e-06,\n",
+       "        9.96536187e-13, -5.26649721e-06,  2.24709140e-13,  2.70457805e-04,\n",
+       "        3.94795308e-13,  2.55833616e-02,  2.01616501e-13, -7.19974911e-06,\n",
+       "       -4.16309377e-04,  2.26485497e-13,  1.36335387e-13, -1.56394049e-04,\n",
+       "       -1.60504680e-04,  1.44551038e-13,  3.40172335e-13,  3.41948692e-13,\n",
+       "       -6.06908744e-06, -1.60557147e-04,  9.34519349e-03,  3.09530179e-13,\n",
+       "        1.63424829e-13, -2.24538171e-04,  5.22248911e-13, -6.35571313e-04,\n",
+       "        4.31520099e-03, -1.72894609e-04, -1.73668432e-04,  4.70068429e-13,\n",
+       "        2.10026490e-02,  7.59392549e-13,  1.70530257e-13,  5.21804822e-13,\n",
+       "        3.11006829e-04,  3.11648281e-04,  3.11801549e-04,  3.29088527e-04,\n",
+       "        3.30327983e-04,  9.14823772e-14,  2.27151631e-13,  2.56017429e-13,\n",
+       "        1.31450406e-13,  1.53210777e-13,  1.17873899e-05,  3.31071287e-04,\n",
+       "        2.02060590e-12,  6.01740879e-13, -5.12563388e-04,  1.92068583e-13,\n",
+       "       -5.09268541e-04,  1.82076576e-13,  2.81108470e-13,  4.03899136e-13,\n",
+       "        2.44915199e-13,  2.04725126e-13,  1.65201186e-13,  1.01008091e-12,\n",
+       "        7.07878201e-13,  4.12336831e-13, -3.49806685e-04,  2.26929586e-13,\n",
+       "        9.29034627e-13,  4.90496532e-13, -3.37636089e-04,  3.67039732e-13,\n",
+       "        8.68860539e-13,  1.28319577e-12,  1.28341782e-13, -3.15081632e-04,\n",
+       "       -3.19684248e-04,  2.52020627e-13,  1.59494640e-12,  1.46549439e-13,\n",
+       "        4.73399098e-13,  1.38620889e-02, -3.05438289e-04, -3.01573389e-04,\n",
+       "       -2.90886979e-04, -3.03033530e-04, -2.91426910e-04,  6.49596881e-05,\n",
+       "       -2.87462398e-04,  1.91446858e-12,  1.39372554e-04, -2.83187516e-04,\n",
+       "        6.25721697e-13,  1.22379275e-04,  2.41584530e-13,  1.40776280e-13,\n",
+       "        1.62048153e-12, -2.77279167e-04,  1.76725301e-12,  1.20264974e-04,\n",
+       "        4.20552482e-13,  1.44328993e-13,  1.19077456e-04,  1.18444812e-04,\n",
+       "        1.17944021e-04,  2.42117437e-12, -1.16573418e-14, -3.04312131e-13,\n",
+       "        1.18190262e-04,  1.18190262e-04,  1.18186866e-04,  1.18186866e-04,\n",
+       "        1.26787469e-13,  1.36677821e-04, -2.38211696e-04,  1.59650071e-13,\n",
+       "        1.14530607e-12,  8.85291840e-13,  2.47801779e-13, -2.49588575e-04,\n",
+       "       -2.50087996e-04, -2.55130443e-04,  1.33448808e-13,  1.86295424e-13,\n",
+       "       -2.62012944e-04, -2.68561161e-04, -2.62749009e-04, -3.02303230e-04,\n",
+       "        1.00364161e-13, -3.37650827e-04,  1.50029701e-02,  1.08113518e-12,\n",
+       "        1.47952174e-02, -2.90580271e-04,  1.00053299e-12, -2.91386478e-04,\n",
+       "        1.34847689e-12,  5.00932629e-13, -2.95171897e-04,  6.53255228e-13,\n",
+       "       -3.02667832e-04, -2.98851904e-04,  7.90034704e-13,  4.60520511e-13,\n",
+       "        8.42437231e-13,  5.03597164e-13, -3.15720643e-04,  3.31956684e-13,\n",
+       "        5.34683409e-13, -3.06075277e-04, -3.06075277e-04,  1.41664458e-13,\n",
+       "        3.04645198e-13,  7.26085858e-14,  5.73319170e-13,  3.71258579e-13,\n",
+       "        1.19015908e-13,  3.38173933e-13,  1.11022302e-13,  5.12923037e-14,\n",
+       "        1.06670228e-12,  1.15463195e-14,  9.37694367e-13, -2.98649994e-14,\n",
+       "       -2.78665979e-14,  4.21440660e-13, -2.26485497e-14,  5.71764858e-13,\n",
+       "       -2.43138842e-14,  2.72448730e-13,  6.44595488e-13,  3.44169138e-13,\n",
+       "        8.35997938e-13, -4.45199433e-14, -6.62803146e-14,  3.33288952e-13,\n",
+       "        4.50528503e-13, -6.94999613e-14, -5.57331958e-14, -4.11892742e-14,\n",
+       "        9.54125667e-13,  5.40456568e-13, -8.16013923e-14, -9.27036226e-14,\n",
+       "        9.61453139e-14,  7.74047493e-13, -1.30562228e-13, -9.54791801e-14,\n",
+       "        4.21884749e-15,  1.77635684e-14, -2.06501483e-14, -2.59792188e-14,\n",
+       "       -3.81916720e-14, -3.16413562e-14,  6.26165786e-13,  9.61453139e-14,\n",
+       "        2.50910404e-14,  5.21804822e-15,  1.06559206e-12, -4.18554080e-14,\n",
+       "        4.15223411e-13,  4.17887946e-13,  2.96873637e-13,  5.50892665e-13,\n",
+       "        1.03472786e-12,  9.06164033e-13,  4.37649916e-13,  1.73638881e-13,\n",
+       "        1.11466392e-12,  3.01758618e-13,  2.29816166e-13, -2.22044605e-15,\n",
+       "       -2.88657986e-15,  7.31414929e-13, -2.57571742e-14, -3.37507799e-14,\n",
+       "       -1.86517468e-14,  9.34807787e-14,  2.33146835e-14,  1.27675648e-14,\n",
+       "        7.54951657e-14,  4.63185046e-13,  9.41469125e-14,  8.59312621e-14,\n",
+       "        5.26245714e-14,  8.12683254e-14, -5.19584376e-14, -1.96509475e-14,\n",
+       "       -7.96029909e-14,  1.24589228e-12,  3.65263375e-13,  4.01012556e-13,\n",
+       "        4.09894341e-13, -5.41788836e-14,  9.21485110e-14, -2.18047802e-13,\n",
+       "       -4.78506124e-14,  3.14193116e-13, -1.68753900e-13,  2.09943174e-12,\n",
+       "       -1.72306613e-13,  9.87210313e-13,  3.15747428e-13, -2.51243470e-13,\n",
+       "       -1.96620498e-13,  2.12030393e-12,  7.80930876e-13, -3.35287353e-14,\n",
+       "       -3.73034936e-14, -7.16093851e-14,  1.05560005e-12, -2.33146835e-15,\n",
+       "        5.35127498e-13,  4.10338430e-13, -2.55351296e-14, -1.18016708e-13,\n",
+       "       -1.08912879e-13, -1.32893696e-13,  2.20135021e-12, -2.63122857e-14,\n",
+       "       -3.04201109e-14,  6.73905376e-13,  1.53210777e-12, -3.90798505e-14,\n",
+       "        1.89404048e-13, -2.84217094e-14,  4.90940621e-13, -1.55431223e-15,\n",
+       "        5.88196158e-13, -6.69464484e-14,  4.00568467e-13, -3.74145159e-14,\n",
+       "        1.57096558e-12, -9.04831765e-14, -3.54161145e-14,  3.23518989e-13,\n",
+       "       -9.40358902e-14, -5.65103520e-14,  1.43218770e-14, -5.08482145e-14,\n",
+       "        4.03010958e-13,  1.71951342e-12, -4.99600361e-14,  7.59392549e-13,\n",
+       "        3.19522186e-13,  7.03215264e-13,  3.57491814e-14,  2.75557355e-13,\n",
+       "        1.69819714e-12,  2.54463117e-13,  4.22106794e-13,  2.44693155e-13,\n",
+       "        1.29674049e-13,  8.52207194e-13,  1.23456800e-13,  3.59934305e-13,\n",
+       "        1.76103576e-12, -7.46069873e-14,  7.31859018e-13, -4.46309656e-14,\n",
+       "       -4.98490138e-14, -4.76285678e-14,  1.48969725e-12,  5.50670620e-14,\n",
+       "        1.70974346e-13, -5.25135491e-14, -8.95949981e-14,  1.71196390e-13,\n",
+       "       -8.58202398e-14,  2.91322522e-13,  7.87148124e-13,  1.45439216e-14,\n",
+       "        3.69038133e-13, -4.09672296e-14, -1.33226763e-14, -3.20854454e-14,\n",
+       "        2.87769808e-13,  7.26529947e-13,  1.87627691e-14, -2.17603713e-14,\n",
+       "        6.86339874e-13,  6.21724894e-14,  1.28275168e-12,  5.12923037e-14,\n",
+       "        2.65121258e-13, -8.32667268e-15,  3.20410365e-13,  3.34177130e-13,\n",
+       "        1.66533454e-14,  7.10542736e-15,  6.88338275e-15, -1.27675648e-14,\n",
+       "        1.15396581e-12,  7.19424520e-14,  1.11999299e-12,  9.21485110e-14,\n",
+       "        2.31370478e-13,  1.75015558e-12,  4.43423076e-13,  1.05648823e-12,\n",
+       "        1.61270997e-12,  1.94066985e-13,  1.09690035e-13,  3.71036535e-13,\n",
+       "        9.06830167e-13,  2.65343303e-13,  2.26263452e-13,  1.51434421e-13,\n",
+       "        2.95097280e-13,  4.04787315e-13,  1.21658239e-12,  1.68753900e-13,\n",
+       "        4.18776125e-13,  1.00786046e-12,  1.02917674e-12,  4.97379915e-13,\n",
+       "        1.37667655e-13, -8.93729535e-14, -2.68673972e-14,  6.99440506e-14,\n",
+       "        9.57900426e-13, -9.35918010e-14, -1.14352972e-14, -1.74305015e-14,\n",
+       "       -1.28341782e-13, -5.66213743e-14,  3.70814490e-14, -1.52211577e-13,\n",
+       "       -9.52571355e-14,  8.90176821e-13, -1.35558231e-13,  3.69926312e-13,\n",
+       "        5.91082738e-13,  8.71080985e-13, -1.44328993e-14, -9.37028233e-14,\n",
+       "        1.00142117e-13,  1.82587279e-12, -3.41948692e-14, -6.78346268e-14,\n",
+       "        7.98472399e-13,  1.94422256e-12,  8.75743922e-13, -7.72715225e-14,\n",
+       "       -4.92939023e-14,  1.18238752e-12, -1.66977543e-13, -1.72750703e-13,\n",
+       "       -1.84297022e-13, -1.36113343e-13,  1.28652644e-12, -1.73083770e-13,\n",
+       "       -9.25926003e-14,  4.66293670e-14, -5.28466160e-14,  9.00612918e-13,\n",
+       "        5.26245714e-14,  4.75175455e-14,  5.24025268e-14,  1.82187598e-12,\n",
+       "        8.82405260e-13,  8.59312621e-14,  8.12683254e-14,  4.57411886e-14,\n",
+       "        1.14197540e-12,  2.68673972e-13,  1.59205982e-13,  5.24025268e-14,\n",
+       "        3.93018951e-14,  2.10942375e-14,  4.72955008e-14,  8.59312621e-14,\n",
+       "        3.08642001e-14,  6.41708908e-14,  7.94697641e-13,  6.04183370e-13,\n",
+       "        8.63753513e-13,  1.02851061e-12,  1.69420034e-13,  1.49658064e-13,\n",
+       "        2.25597319e-13,  9.03721542e-14,  1.03472786e-13,  1.28563826e-13,\n",
+       "        7.14095449e-13,  1.77191595e-13,  1.33670852e-13,  8.52429238e-13,\n",
+       "        1.37445610e-13,  3.09086090e-13,  5.19140286e-13,  1.45838897e-12,\n",
+       "        5.83977311e-14,  3.57491814e-14,  7.65609798e-13,  8.10018719e-13,\n",
+       "        6.41264819e-13,  4.50750548e-14,  8.82183215e-13,  4.66293670e-15,\n",
+       "        6.99440506e-13,  6.29274410e-13,  5.93969318e-13,  6.64801547e-13,\n",
+       "       -4.90718577e-14,  3.17967874e-13, -1.48436818e-13,  7.86481991e-13,\n",
+       "       -6.86117829e-14, -1.45994328e-13, -1.23900890e-13, -1.62647673e-13,\n",
+       "        6.07736084e-13,  5.29354338e-13, -1.01696429e-13, -6.72795153e-14,\n",
+       "        1.68753900e-14, -5.54001289e-14, -7.28306304e-14, -5.70654635e-14,\n",
+       "        5.81756865e-14,  7.53619389e-13, -8.97060204e-14, -6.83897383e-14,\n",
+       "       -8.89288643e-14,  6.91890989e-13,  8.86180018e-13,  2.50466314e-13,\n",
+       "        9.17044218e-13, -5.76205750e-14,  3.83915122e-13,  9.21485110e-14,\n",
+       "       -1.42885703e-13, -1.24344979e-14, -5.57331958e-14, -6.57252031e-14,\n",
+       "        2.10942375e-15,  7.87370169e-13,  4.75175455e-14,  4.58744154e-13,\n",
+       "        9.64561764e-13,  1.25899291e-13,  1.66977543e-13,  3.88356014e-13,\n",
+       "        1.23012711e-13,  9.45910017e-14,  2.44249065e-13,  1.00230935e-12,\n",
+       "        4.90940621e-13,  3.52606833e-13,  1.15907284e-13,  9.35918010e-13,\n",
+       "        5.37347944e-14,  8.06021916e-14,  8.74855743e-14,  6.37268016e-14,\n",
+       "        8.99058605e-13,  6.68354261e-14,  2.54907206e-13,  2.37587727e-14,\n",
+       "        1.73194792e-14,  6.63691324e-13,  1.69708692e-12, -1.33226763e-14,\n",
+       "       -6.40598685e-14,  7.32747196e-15, -4.81836793e-14,  2.70006240e-13,\n",
+       "        7.53175300e-13,  4.79616347e-14, -2.12052598e-14,  6.06181771e-14,\n",
+       "        1.61870517e-13, -2.91988655e-14, -2.04281037e-14, -7.54951657e-14,\n",
+       "        7.10542736e-15,  1.86295424e-13, -7.27196081e-14, -1.99840144e-14,\n",
+       "        6.23945340e-14,  1.38999923e-13, -6.61692923e-14,  9.08162434e-14,\n",
+       "       -4.79616347e-14,  1.23234756e-12,  8.19566637e-13, -1.23345778e-13,\n",
+       "        5.12256904e-13, -2.04281037e-14,  3.96349620e-13, -4.66293670e-14,\n",
+       "        2.58904009e-13,  1.16529009e-12, -1.00697228e-13,  7.03437308e-13,\n",
+       "       -7.00550729e-14, -2.50910404e-14, -1.72084569e-14,  3.75255382e-14,\n",
+       "        1.65423231e-13,  2.44027021e-13,  8.50430837e-14,  7.50066675e-13,\n",
+       "       -5.49560397e-14,  3.40172335e-13, -3.81916720e-14, -2.00950367e-14,\n",
+       "       -7.38298311e-14,  2.48023824e-13,  3.59046126e-13, -3.70814490e-14,\n",
+       "        2.84217094e-13,  7.37410133e-13,  6.21724894e-14,  3.55493412e-13,\n",
+       "        5.50670620e-14,  1.39666056e-13,  9.16156040e-13,  2.96429548e-14,\n",
+       "        3.26405569e-14,  1.44328993e-13,  4.82280882e-13,  3.41948692e-14,\n",
+       "        3.35953487e-13,  3.03090886e-13,  2.90878432e-14,  4.26325641e-14,\n",
+       "        7.34967642e-14,  2.53130850e-13,  3.28181926e-13,  4.13225010e-13,\n",
+       "        4.92939023e-14,  2.52908805e-13,  7.19424520e-14,  9.05941988e-14,\n",
+       "        1.37667655e-13,  4.52082816e-13,  3.84359211e-13, -2.89768209e-14,\n",
+       "        3.67927910e-13,  3.20188320e-13,  4.28101998e-13,  4.29212221e-13,\n",
+       "        5.54889468e-13,  1.07247544e-13,  2.40030218e-13,  7.03881398e-14,\n",
+       "        1.15685239e-13,  1.04583009e-13,  1.22790667e-13,  1.62092562e-13,\n",
+       "        8.41771097e-13,  1.69420034e-13,  5.42677014e-13,  4.29434266e-13,\n",
+       "        1.62980740e-13,  6.54143406e-13,  2.06501483e-13,  1.94511074e-13,\n",
+       "        8.22231172e-13,  5.83311177e-13,  9.64339719e-13,  8.65529870e-13,\n",
+       "        1.13686838e-13,  1.48547841e-13,  8.86180018e-13,  2.07389661e-13,\n",
+       "        7.99360578e-15,  6.17284002e-14, -2.02060590e-14,  1.62536651e-13,\n",
+       "        9.51239087e-13,  1.35313982e-12,  1.22590826e-12,  8.39328607e-14,\n",
+       "        1.18216548e-12, -2.07611706e-14, -1.81521465e-13, -1.28785871e-13,\n",
+       "        4.79838391e-13,  9.35029831e-13, -2.08055795e-13, -1.71751502e-13,\n",
+       "        1.42108547e-13, -1.88848936e-13,  2.00683914e-12, -1.43440815e-13,\n",
+       "        4.88942220e-13, -2.53019827e-13, -1.59205982e-13, -2.01838546e-13,\n",
+       "       -7.30526750e-14,  3.79696274e-13, -2.36921593e-13,  4.46975790e-13,\n",
+       "        2.53552734e-12, -1.84297022e-13, -5.07371922e-14,  7.41851025e-13,\n",
+       "       -8.01581024e-14, -7.90478794e-14,  3.17457172e-12, -2.64233080e-14,\n",
+       "       -7.54951657e-15,  3.68594044e-14,  1.44551038e-13,  4.92939023e-14,\n",
+       "        1.26343380e-13, -2.76445533e-14,  6.29274410e-13,  1.84074977e-13,\n",
+       "        7.41406936e-13,  4.39648318e-13,  1.61648472e-13,  1.31827882e-12,\n",
+       "        9.06830167e-13,  3.14637205e-13,  2.80220291e-13,  2.40918396e-13,\n",
+       "        6.31938946e-13,  3.30846461e-13,  1.13908882e-13,  2.08277839e-13,\n",
+       "        1.51079149e-12,  2.36033415e-13,  4.70956607e-13,  1.88515870e-13,\n",
+       "        2.24043006e-13,  2.07345252e-12,  1.56763491e-13,  1.80744308e-13,\n",
+       "        1.13020704e-13,  7.68274333e-14,  5.41788836e-14,  1.73527859e-12,\n",
+       "        3.26405569e-14,  6.63913369e-14,  2.86437540e-14,  5.05595565e-13,\n",
+       "        7.92699240e-14,  9.11715148e-13,  6.88338275e-14,  3.12194715e-13,\n",
+       "        6.17284002e-14,  4.95159469e-13,  2.02060590e-14,  1.04782849e-12,\n",
+       "       -1.78745907e-14,  1.04360964e-14,  1.04494191e-12,  1.05138120e-12,\n",
+       "        1.11999299e-12,  3.80584453e-13, -1.20459198e-13,  4.38316050e-13,\n",
+       "        8.99280650e-14,  1.38777878e-13, -6.32827124e-14, -9.10382880e-15,\n",
+       "        1.48991930e-13,  1.48547841e-13,  4.44311254e-13,  1.44328993e-14,\n",
+       "        2.06279438e-13,  1.79856130e-14,  6.28386232e-14,  1.05693232e-13,\n",
+       "        4.33653113e-13,  9.89874849e-13,  6.03517236e-13,  4.05897538e-13,\n",
+       "        6.14397422e-13,  3.30624417e-13,  9.05275854e-13,  3.03090886e-13,\n",
+       "        7.83817455e-13,  4.95603558e-13,  6.00186567e-13,  3.87911925e-13,\n",
+       "        8.27782287e-13,  9.02389274e-13,  8.79740725e-13,  3.63487018e-13,\n",
+       "        8.07354184e-13,  5.88418203e-13,  2.70672373e-13,  6.51922960e-13,\n",
+       "        7.19424520e-13,  4.84057239e-13,  3.40394379e-13,  1.08801856e-13,\n",
+       "        6.52811138e-14, -5.98410210e-14,  4.94715380e-13,  3.73923115e-13,\n",
+       "       -1.33337785e-13,  9.99200722e-13,  3.03090886e-14,  4.09006162e-13,\n",
+       "        1.14308563e-12, -2.00617301e-13, -1.39555034e-13, -5.17363929e-14,\n",
+       "       -1.10356169e-13, -2.79998247e-13, -1.82964754e-13, -1.57762692e-13,\n",
+       "       -1.05027098e-13, -2.20601315e-13,  1.17461596e-13, -1.93511873e-13,\n",
+       "        7.45847828e-13,  4.78728168e-13, -1.76192394e-13, -1.79856130e-13,\n",
+       "        4.99822406e-13, -1.25677246e-13, -1.25677246e-13,  8.32667268e-15,\n",
+       "        5.61772850e-13,  1.22346577e-13,  4.88720175e-13,  2.11164419e-13,\n",
+       "        7.60724816e-13,  4.28768132e-13,  1.58983937e-13,  1.90514271e-13,\n",
+       "        3.43947093e-13,  1.44151358e-12,  1.04583009e-13,  6.80344669e-13,\n",
+       "        2.16493490e-13,  3.59712260e-14,  1.49347201e-12,  2.22488694e-13,\n",
+       "        1.38178358e-12,  1.08801856e-14,  1.11022302e-15,  3.45501405e-13,\n",
+       "        2.18269847e-13,  4.09894341e-13,  1.48547841e-13,  3.16857651e-13,\n",
+       "        1.25144339e-12,  8.00470801e-13,  9.14823772e-14,  7.90478794e-14,\n",
+       "        4.57411886e-14,  6.92779167e-14,  1.46771484e-13,  2.04725126e-13,\n",
+       "        5.47339951e-13,  1.23234756e-13,  5.10702591e-13,  6.63913369e-14,\n",
+       "        2.73114864e-13,  7.13651360e-13,  2.00950367e-14,  1.41420209e-12,\n",
+       "        1.36135547e-12,  1.72972747e-13,  1.56896718e-12,  1.88737914e-14,\n",
+       "        1.96287431e-13,  2.83773005e-13,  2.08943973e-13,  1.38933309e-12,\n",
+       "        8.34887715e-14,  9.01501096e-14,  2.85105273e-13,  1.82520665e-13,\n",
+       "        4.42756942e-13,  6.43929354e-14,  5.73097125e-13,  7.37854222e-13,\n",
+       "        6.11510842e-13,  3.34621220e-13,  4.66293670e-15,  9.99200722e-15,\n",
+       "        1.15241150e-13,  4.81170659e-13,  2.04281037e-14,  5.53779245e-13,\n",
+       "       -1.13242749e-14,  1.11022302e-13,  3.55271368e-14,  1.39888101e-13,\n",
+       "        1.73372428e-12,  7.27862215e-13, -4.58522109e-14,  2.66475730e-12,\n",
+       "       -1.11466392e-13, -1.00697228e-13, -1.11133325e-13, -8.84847751e-14,\n",
+       "        4.67403893e-13, -1.42441614e-13,  2.68740585e-12, -1.99840144e-14,\n",
+       "        1.22790667e-13, -7.39408534e-14,  1.23900890e-13,  1.26876287e-12,\n",
+       "        8.65973959e-13,  7.48512363e-13,  7.79376563e-14, -1.61537450e-13,\n",
+       "        3.44169138e-14, -1.08135723e-13, -3.49831275e-13, -1.39999123e-13,\n",
+       "        4.22550883e-13, -2.65343303e-13, -2.37920794e-13, -1.22013510e-13,\n",
+       "       -1.39555034e-13,  2.35012010e-12, -1.91957561e-13,  1.01252340e-13,\n",
+       "        7.72271136e-13, -5.12923037e-14,  1.06137321e-12,  7.55395746e-13,\n",
+       "        2.77555756e-15,  8.32001135e-13,  1.55520041e-12,  1.22124533e-13,\n",
+       "        1.03939080e-12,  3.17523785e-14,  2.82662782e-13,  1.03916875e-13,\n",
+       "        1.14552812e-12,  1.16573418e-12,  6.48148202e-13,  2.19824159e-13,\n",
+       "        4.03632683e-12,  4.03677092e-13,  4.66826577e-12,  7.95807864e-13,\n",
+       "        3.24407168e-13,  3.04645198e-13,  3.57047725e-13,  7.15871806e-13,\n",
+       "        8.36664071e-13,  1.99174011e-12,  5.36015676e-12,  7.07878201e-13])"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "k = 20\n",
+    "batch_sizes = [20,50,100,200,400,1000]\n",
+    "\n",
+    "time_river = []\n",
+    "time_scikit = []\n",
+    "for batch_size in batch_sizes:\n",
+    "    #River\n",
+    "    start_time_r = time.time()\n",
+    "    ilof_river2 = ilof.ILOF(k, verbose=False)\n",
+    "    ilof_river2.learn_many(dataset[0:batch_size])\n",
+    "    time_river.append(time.time() - start_time_r)\n",
+    "    ilof_scores_river2 = np.array([v for v in ilof_river2.lof.values()])\n",
+    "\n",
+    "    #Scikit\n",
+    "    start_time_s = time.time()\n",
+    "    lof_scikit2 = LocalOutlierFactor(n_neighbors=k)\n",
+    "    lof_scikit2.fit_predict(dataset_np[0:batch_size])\n",
+    "    time_scikit.append(time.time() - start_time_s)\n",
+    "    lof_scores_scikit2 = - lof_scikit2.negative_outlier_factor_\n",
+    "\n",
+    "#Compare\n",
+    "print('We observe again that the error is of machine precision level: \\\n",
+    "    (the few errors at the scale of e-05 are because of the river minkowski-distance function error, \\\n",
+    "    I submitted a correction request, for details see bottom of this document  ')\n",
+    "ilof_scores_river2 - lof_scores_scikit2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "# Plotting the bar graph\n",
+    "plt.bar(np.array(range(len(time_river)))*1.5+0.25, time_river, width=0.4, label='River ILOF')\n",
+    "plt.bar(np.array(range(len(time_river)))*1.5-0.25, time_scikit, width=0.4, label='Scikit LOF')\n",
+    "plt.xticks(np.array(range(len(time_river)))*1.5, batch_sizes)\n",
+    "plt.xlabel('Batch size')\n",
+    "plt.ylabel('Execution Time (seconds)')\n",
+    "plt.title('Mini-batch mode Time Comparison')\n",
+    "plt.yscale('log')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RiverILOF time: [5.1155877113342285] ;  ScikitLOF time: [0.22044944763183594] \n",
+      " We observe that RiverILOF gets slower as the number of points learned increases,    since it calculates the distance of the new point to all other ones each iteration\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Time to add new points on existing model with 1000 points\n",
+    "#River\n",
+    "time_r = []\n",
+    "start_t_r = time.time()\n",
+    "for x in dataset[0][1200:1300]:\n",
+    "    ilof_river2.learn_one(x)\n",
+    "time_r.append(time.time() - start_t_r)\n",
+    "\n",
+    "#Scikit\n",
+    "time_s = []\n",
+    "start_t_s = time.time()\n",
+    "lof_scikit2.novelty = True\n",
+    "lof_scores_scikit2 = lof_scikit2.score_samples(dataset_np[1200:1300])\n",
+    "time_s.append(time.time() - start_t_s)\n",
+    "\n",
+    "print('RiverILOF time:', time_r,';  ScikitLOF time:', time_s, '\\n We observe that RiverILOF gets slower as the number of points learned increases,\\\n",
+    "since it calculates the distance of the new point to all other ones each iteration.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.974262055650739 195.28000000000003\n"
+     ]
+    }
+   ],
+   "source": [
+    "#River Minkowski_distance error\n",
+    "\n",
+    "import functools\n",
+    "from river import utils\n",
+    "#from river.neighbors.base import DistanceFunc\n",
+    "from river.utils import VectorDict\n",
+    "\n",
+    "distancefunc = functools.partial(utils.math.minkowski_distance, p=2)\n",
+    "a={1: 1.5, 2: 3.5}\n",
+    "b={1: -0.7, 2: -10.3}\n",
+    "print(((1.5+0.7)**2+(3.5+10.3)**2)**(1/2), distancefunc(a,b))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.16"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From fc3ee3e777078c36b45ecd4afb0280167c1925b3 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Sat, 26 Aug 2023 12:20:22 +0800
Subject: [PATCH 02/43] Update ilof_notebook.ipynb

---
 {river/anomaly => docs/examples}/ilof_notebook.ipynb | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {river/anomaly => docs/examples}/ilof_notebook.ipynb (100%)

diff --git a/river/anomaly/ilof_notebook.ipynb b/docs/examples/ilof_notebook.ipynb
similarity index 100%
rename from river/anomaly/ilof_notebook.ipynb
rename to docs/examples/ilof_notebook.ipynb

From e4cb46e0247a449271685bc8720549310517263e Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Mon, 28 Aug 2023 14:02:00 +0700
Subject: [PATCH 03/43] Modify name IncrementalLOF in __init__ file of anomaly
 module

---
 river/anomaly/__init__.py |  4 ++--
 river/anomaly/ilof.py     | 44 +++++++++++++++++++++++----------------
 2 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/river/anomaly/__init__.py b/river/anomaly/__init__.py
index 60ff843329..e1d5be039b 100644
--- a/river/anomaly/__init__.py
+++ b/river/anomaly/__init__.py
@@ -17,7 +17,7 @@
 from .filter import QuantileFilter, ThresholdFilter
 from .gaussian import GaussianScorer
 from .hst import HalfSpaceTrees
-from .ilof import ILOF
+from .ilof import IncrementalLOF
 from .svm import OneClassSVM
 
 __all__ = [
@@ -28,5 +28,5 @@
     "OneClassSVM",
     "QuantileFilter",
     "ThresholdFilter",
-    "ILOF",
+    "IncrementalLOF",
 ]
diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index eca4a1008b..782547ab94 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -9,10 +9,10 @@
 from river.utils import VectorDict
 
 
-class ILOF(anomaly.base.AnomalyDetector):
-    """Incremental Local Outlier Factor (ILOF).
+class IncrementalLOF(anomaly.base.AnomalyDetector):
+    """Incremental Local Outlier Factor (Incremental LOF).
 
-    ILOF Algorithm as described in the reference paper
+    Incremental LOF Algorithm as described in the reference paper
     ----------
 
     The Incremental Local Outlier Factor (ILOF) is an online version of the Local Outlier Factor (LOF) used to identify outliers based on density of local neighbors.
@@ -71,19 +71,27 @@ class ILOF(anomaly.base.AnomalyDetector):
 
     Example
     ----------
-    from river import datasets
-    import pandas as pd
-    import ilof as ilof
-    dataset = pd.DataFrame(datasets.CreditCard())
-    #Define model
-    k = 20 #k-neighboors
-    ilof_river = ilof.ILOF(k, verbose=False)
-    ilof_river.learn_many(dataset[0:30])
-    for i in dataset[0][40:90]:
-        ilof_river.learn_one(i)
-    lof_score = []
-    for x in dataset[0][100:120]:
-        lof_score.append(ilof_river.score_one(x))
+
+    >>> from river import anomaly
+    >>> from river import datasets
+    >>> import pandas as pd
+
+    >>> dataset = pd.DataFrame(datasets.CreditCard())
+
+    >>> k = 20 # Define number of nearest neighbors
+    >>> incremental_lof = anomaly.IncrementalLOF(k, verbose=False)
+
+    >>> incremental_lof.learn_many(dataset[0:50]) # learn_many for the first 30 observations
+
+    >>> for i in dataset[0][50:100]:
+    ...    incremental_lof.learn_one(i)
+
+    >>> ilof_scores = []
+    >>> for x in dataset[0][101:120]:
+    ...   ilof_scores.append(incremental_lof.score_one(x))
+
+    >>> [[round(ilof_score, 3) for ilof_score in ilof_scores[:5][i]] for i in range(5)]
+    [[1.207], [1.278], [1.721], [1.271], [1.167]]
 
     References
     ----------
@@ -310,7 +318,7 @@ def initial_calculations(
         dist_dict: dict,
     ):
         """
-        Perform initial calculations on the incoming data before applying the ILOF algorithm.
+        Perform initial calculations on the incoming data before applying the Incremental LOF algorithm.
         Taking the new data, it updates the neighborhoods, reverse neighborhoods, k-distances and distances between particles.
 
         Parameters
@@ -415,7 +423,7 @@ def expand_objects(
         )
 
     def define_sets(self, nm, neighborhoods: dict, rev_neighborhoods: dict):
-        """Define sets of points for the ILOF algorithm"""
+        """Define sets of points for the incremental LOF algorithm"""
         # Define set of new points from batch
         Set_new_points = set(range(nm[0], nm[0] + nm[1]))
         Set_neighbors: set = set()

From 30caddf7956eaccb68e6d6ce72e7fe84c2fc9f96 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Mon, 28 Aug 2023 14:02:52 +0700
Subject: [PATCH 04/43] Refactor code after precommit run

---
 river/linear_model/test_glm.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/river/linear_model/test_glm.py b/river/linear_model/test_glm.py
index 2d95f2ce73..64a3ed3c37 100644
--- a/river/linear_model/test_glm.py
+++ b/river/linear_model/test_glm.py
@@ -420,10 +420,7 @@ def test_lin_reg_sklearn_l1_non_regression():
 def test_log_reg_sklearn_l1_non_regression():
     """Checks that the river L1 implementation results are no worse than sklearn L1."""
 
-    (
-        X,
-        y,
-    ) = make_classification(
+    (X, y,) = make_classification(
         n_samples=1000,
         n_features=20,
         n_informative=4,

From 56c17e8e0dd1c2b599250783d60347d3da2ea2c1 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Mon, 28 Aug 2023 16:57:59 +0700
Subject: [PATCH 05/43] Remove window_score in score_one function of
 Incremental LOF (since score_one already assumes that one sample is taken
 into account at a certain time point).

---
 river/anomaly/ilof.py | 137 +++++++++++++++++++++---------------------
 1 file changed, 67 insertions(+), 70 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 782547ab94..a29868a864 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -225,9 +225,9 @@ def learn(self, X_batch: list):
             # Calculate new Local Outlier Factor of all affected points
             self.lof = self.calc_lof(Set_upd_lof, self.neighborhoods, self.local_reach, self.lof)
 
-    def score_one(self, x: VectorDict, window_score=1):
+    def score_one(self, x: VectorDict):
         """
-        Score incoming observations based on model constructed previously.
+        Score an incoming observation based on model constructed previously.
         Perform same calculations as 'learn_one' function but doesn't add the new calculations to the atributes
         Data samples that are equal to samples stored by the model are not considered.
 
@@ -235,8 +235,6 @@ def score_one(self, x: VectorDict, window_score=1):
         ----------
         x
             A dictionary of feature values.
-        window_score
-            The size of the batch of data to be taken in at once for the model to score
 
         Returns
         -------
@@ -246,67 +244,66 @@ def score_one(self, x: VectorDict, window_score=1):
 
         self.X_score.append(x)
 
-        if len(self.X_score) >= window_score:
-            self.X_score, equal = self.check_equal(self.X_score, self.X)
-            if equal != 0 and self.verbose:
-                print("%i samples are equal to previous data" % equal)
-
-            if len(self.X_score) == 0:
-                if self.verbose:
-                    print("No new data was added")
-            else:
-                Xs = self.X.copy()
-                (
-                    nm,
-                    Xs,
-                    neighborhoods,
-                    rev_neighborhoods,
-                    k_dist,
-                    reach_dist,
-                    dist_dict,
-                    local_reach,
-                    lof,
-                ) = self.expand_objects(
-                    self.X_score,
-                    Xs,
-                    self.neighborhoods,
-                    self.rev_neighborhoods,
-                    self.k_dist,
-                    self.reach_dist,
-                    self.dist_dict,
-                    self.local_reach,
-                    self.lof,
-                )
-
-                neighborhoods, rev_neighborhoods, k_dist, dist_dict = self.initial_calculations(
-                    Xs, nm, neighborhoods, rev_neighborhoods, k_dist, dist_dict
-                )
-                (
-                    Set_new_points,
-                    Set_neighbors,
-                    Set_rev_neighbors,
-                    Set_upd_lrd,
-                    Set_upd_lof,
-                ) = self.define_sets(nm, neighborhoods, rev_neighborhoods)
-                reach_dist = self.calc_reach_dist_newpoints(
-                    Set_new_points, neighborhoods, rev_neighborhoods, reach_dist, dist_dict, k_dist
-                )
-                reach_dist = self.calc_reach_dist_otherpoints(
-                    Set_rev_neighbors,
-                    neighborhoods,
-                    rev_neighborhoods,
-                    reach_dist,
-                    dist_dict,
-                    k_dist,
-                )
-                local_reach = self.calc_local_reach_dist(
-                    Set_upd_lrd, neighborhoods, reach_dist, local_reach
-                )
-                lof = self.calc_lof(Set_upd_lof, neighborhoods, local_reach, lof)
-                self.X_score = []
-
-                score_keys = list(range(nm[0], nm[0] + nm[1]))
-                return [lof[i] for i in score_keys]
+        self.X_score, equal = self.check_equal(self.X_score, self.X)
+        if equal != 0 and self.verbose:
+            print("The new observation is the same to one of the previously observed instances.")
+
+        if len(self.X_score) == 0:
+            if self.verbose:
+                print("No new data was added.")
+        else:
+            Xs = self.X.copy()
+            (
+                nm,
+                Xs,
+                neighborhoods,
+                rev_neighborhoods,
+                k_dist,
+                reach_dist,
+                dist_dict,
+                local_reach,
+                lof,
+            ) = self.expand_objects(
+                self.X_score,
+                Xs,
+                self.neighborhoods,
+                self.rev_neighborhoods,
+                self.k_dist,
+                self.reach_dist,
+                self.dist_dict,
+                self.local_reach,
+                self.lof,
+            )
+
+            neighborhoods, rev_neighborhoods, k_dist, dist_dict = self.initial_calculations(
+                Xs, nm, neighborhoods, rev_neighborhoods, k_dist, dist_dict
+            )
+            (
+                Set_new_points,
+                Set_neighbors,
+                Set_rev_neighbors,
+                Set_upd_lrd,
+                Set_upd_lof,
+            ) = self.define_sets(nm, neighborhoods, rev_neighborhoods)
+            reach_dist = self.calc_reach_dist_newpoints(
+                Set_new_points, neighborhoods, rev_neighborhoods, reach_dist, dist_dict, k_dist
+            )
+            reach_dist = self.calc_reach_dist_otherpoints(
+                Set_rev_neighbors,
+                neighborhoods,
+                rev_neighborhoods,
+                reach_dist,
+                dist_dict,
+                k_dist,
+            )
+            local_reach = self.calc_local_reach_dist(
+                Set_upd_lrd, neighborhoods, reach_dist, local_reach
+            )
+            lof = self.calc_lof(Set_upd_lof, neighborhoods, local_reach, lof)
+            self.X_score = []
+
+            score_keys = list(range(nm[0], nm[0] + nm[1]))
+            return [lof[i] for i in score_keys]
 
     def initial_calculations(
         self,
@@ -325,15 +322,15 @@ def initial_calculations(
         ----------
         X
             A list of stored observations.
-        nm : tuple of ints, (n, m)
+        nm
             A tuple representing the current size of the dataset.
-        neighborhoods : dict
+        neighborhoods
             A dictionary of particle neighborhoods.
-        rev_neighborhoods : dict
+        rev_neighborhoods
             A dictionary of reverse particle neighborhoods.
-        k_distances : dict
+        k_distances
             A dictionary to hold k-distances for each observation.
-        dist_dict : dict of dicts
+        dist_dict
             A dictionary of dictionaries storing distances between particles
 
         Returns

From cb7e45f2606822598ce27fb38b0dec240a0bf44a Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Mon, 28 Aug 2023 17:54:44 +0700
Subject: [PATCH 06/43] Remove learn_many and refactor Docstring test

---
 river/anomaly/ilof.py | 28 +++++++---------------------
 1 file changed, 7 insertions(+), 21 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index a29868a864..2e184d8fef 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -76,22 +76,20 @@ class IncrementalLOF(anomaly.base.AnomalyDetector):
     >>> from river import datasets
     >>> import pandas as pd
 
-    >>> dataset = pd.DataFrame(datasets.CreditCard())
+    >>> cc_df = pd.DataFrame(datasets.CreditCard())
 
     >>> k = 20 # Define number of nearest neighbors
     >>> incremental_lof = anomaly.IncrementalLOF(k, verbose=False)
 
-    >>> incremental_lof.learn_many(dataset[0:50]) # learn_many for the first 30 observations
-
-    >>> for i in dataset[0][50:100]:
-    ...    incremental_lof.learn_one(i)
+    >>> for x, _ in datasets.CreditCard().take(200):
+    ...    incremental_lof.learn_one(x)
 
     >>> ilof_scores = []
-    >>> for x in dataset[0][101:120]:
-    ...   ilof_scores.append(incremental_lof.score_one(x))
+    >>> for x in cc_df[0][201:206]:
+    ...    ilof_scores.append(incremental_lof.score_one(x))
 
-    >>> [[round(ilof_score, 3) for ilof_score in ilof_scores[:5][i]] for i in range(5)]
-    [[1.207], [1.278], [1.721], [1.271], [1.167]]
+    >>> [[round(ilof_score, 3) for ilof_score in ilof_scores[i]] for i in range(len(ilof_scores))]
+    [[1.149], [1.098], [1.158], [1.101], [1.092]]
 
     References
     ----------
@@ -122,18 +120,6 @@ def __init__(
             else functools.partial(utils.math.minkowski_distance, p=2)
         )
 
-    def learn_many(self, X_batch: pd.Series):
-        """
-        Update the model with many incoming observations
-
-        Parameters
-        ----------
-        X_batch
-            A Panda Series
-        """
-        X_batch = X_batch[0].tolist()
-        self.learn(X_batch)
-
     def learn_one(self, x: dict):
         """
         Update the model with one incoming observation

From ac4ab6254e6f6daa0f508f37066a79fe748aac50 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Mon, 28 Aug 2023 17:55:39 +0700
Subject: [PATCH 07/43] Remove import pandas since unused.

---
 river/anomaly/ilof.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 2e184d8fef..fe25c76f93 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -2,8 +2,6 @@
 
 import functools
 
-import pandas as pd
-
 from river import anomaly, utils
 from river.neighbors.base import DistanceFunc
 from river.utils import VectorDict

From ebec94fffbb11b11e832f89e7325dd729688e1f7 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Tue, 5 Sep 2023 17:59:53 +0700
Subject: [PATCH 08/43] Refactor

---
 river/anomaly/ilof.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index fe25c76f93..ac336eaf80 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -139,7 +139,7 @@ def learn(self, X_batch: list):
 
         if len(X_batch) == 0:
             if self.verbose:
-                print("No new data was added")
+                print("No new data was added.")
         else:
             # Increase size of objects to acomodate new data
             (
@@ -209,9 +209,9 @@ def learn(self, X_batch: list):
             # Calculate new Local Outlier Factor of all affected points
             self.lof = self.calc_lof(Set_upd_lof, self.neighborhoods, self.local_reach, self.lof)
 
-    def score_one(self, x: VectorDict):
+    def score_one(self, x: dict):
         """
-        Score an incoming observation based on model constructed previously.
+        Score a new incoming observation based on model constructed previously.
         Perform same calculations as 'learn_one' function but doesn't add the new calculations to the atributes
         Data samples that are equal to samples stored by the model are not considered.
 

From a3b4093daa217a9d6d1821a14db42b28ef27525b Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Tue, 5 Sep 2023 18:00:44 +0700
Subject: [PATCH 09/43] Change output of `score_one` to only return one single
 number, not list (to comply with the implementation of other incremental
 anomaly detection algorithms)

---
 river/anomaly/ilof.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index ac336eaf80..0c99070c27 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -286,8 +286,7 @@ def score_one(self, x: dict):
             lof = self.calc_lof(Set_upd_lof, neighborhoods, local_reach, lof)
             self.X_score = []
 
-            score_keys = list(range(nm[0], nm[0] + nm[1]))
-            return [lof[i] for i in score_keys]
+            return lof[nm[0]]
 
     def initial_calculations(
         self,

From bc78169de702b3255d65d7d3f6b5e25eb67e3808 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Tue, 5 Sep 2023 18:07:42 +0700
Subject: [PATCH 10/43] Refactor Docstring test

---
 river/anomaly/ilof.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 0c99070c27..101c6a297f 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -86,8 +86,8 @@ class IncrementalLOF(anomaly.base.AnomalyDetector):
     >>> for x in cc_df[0][201:206]:
     ...    ilof_scores.append(incremental_lof.score_one(x))
 
-    >>> [[round(ilof_score, 3) for ilof_score in ilof_scores[i]] for i in range(len(ilof_scores))]
-    [[1.149], [1.098], [1.158], [1.101], [1.092]]
+    >>> [round(ilof_score, 3) for ilof_score in ilof_scores]
+    [1.149, 1.098, 1.158, 1.101, 1.092]
 
     References
     ----------

From 52242653e59797360855836055fd3a356ece06c8 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Wed, 6 Sep 2023 07:59:12 +0700
Subject: [PATCH 11/43] Refactor from IncrementalLOF to LocalOutlierFactor

---
 river/anomaly/__init__.py | 4 ++--
 river/anomaly/ilof.py     | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/river/anomaly/__init__.py b/river/anomaly/__init__.py
index e1d5be039b..74882f55c6 100644
--- a/river/anomaly/__init__.py
+++ b/river/anomaly/__init__.py
@@ -17,7 +17,7 @@
 from .filter import QuantileFilter, ThresholdFilter
 from .gaussian import GaussianScorer
 from .hst import HalfSpaceTrees
-from .ilof import IncrementalLOF
+from .ilof import LocalOutlierFactor
 from .svm import OneClassSVM
 
 __all__ = [
@@ -28,5 +28,5 @@
     "OneClassSVM",
     "QuantileFilter",
     "ThresholdFilter",
-    "IncrementalLOF",
+    "LocalOutlierFactor",
 ]
diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 101c6a297f..b34a4e4005 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -7,7 +7,7 @@
 from river.utils import VectorDict
 
 
-class IncrementalLOF(anomaly.base.AnomalyDetector):
+class LocalOutlierFactor(anomaly.base.AnomalyDetector):
     """Incremental Local Outlier Factor (Incremental LOF).
 
     Incremental LOF Algorithm as described in the reference paper
@@ -77,7 +77,7 @@ class IncrementalLOF(anomaly.base.AnomalyDetector):
     >>> cc_df = pd.DataFrame(datasets.CreditCard())
 
     >>> k = 20 # Define number of nearest neighbors
-    >>> incremental_lof = anomaly.IncrementalLOF(k, verbose=False)
+    >>> incremental_lof = anomaly.LocalOutlierFactor(k, verbose=False)
 
     >>> for x, _ in datasets.CreditCard().take(200):
     ...    incremental_lof.learn_one(x)

From c64b803ecd4d46e4ce8bdf9964014d4cbc0423a0 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Wed, 6 Sep 2023 08:19:12 +0700
Subject: [PATCH 12/43] Refactor

---
 river/anomaly/ilof.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index b34a4e4005..3d8be4dd40 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -11,7 +11,6 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
     """Incremental Local Outlier Factor (Incremental LOF).
 
     Incremental LOF Algorithm as described in the reference paper
-    ----------
 
     The Incremental Local Outlier Factor (ILOF) is an online version of the Local Outlier Factor (LOF) used to identify outliers based on density of local neighbors.
 
@@ -33,13 +32,13 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
 
     Parameters
     ----------
-    n_neighbors : int
+    n_neighbors
         The number of nearest neighbors to use for density estimation.
-    window_size : int
+    window_size
         The size of the batch of data to be taken in at once for the model to learn
-    distance_func : function that takes in dictionaries
-        A distance function to use. By default, the Euclidean distance is used.
-    verbose: boolean
+    distance_func
+        Distance function to be used. By default, the Euclidean distance is used.
+    verbose
         Whether or not to print messages
 
     Attributes

From 05375fc87704571d0947cbde96a34d45459fea4a Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Wed, 6 Sep 2023 11:57:53 +0700
Subject: [PATCH 13/43] Refactor X_batch to x_batch to align with PEP8.

---
 river/anomaly/ilof.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 3d8be4dd40..5c2fffe883 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -45,7 +45,7 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
     ----------
     X
         A list of stored observations.
-    X_batch
+    x_batch
         A buffer to hold incoming observations until it's time to update the model.
     X_score
         A buffer to hold incoming observations until it's time to score them.
@@ -101,7 +101,7 @@ def __init__(
     ):
         self.n_neighbors = n_neighbors
         self.X: list = []
-        self.X_batch: list = []
+        self.x_batch: list = []
         self.X_score: list = []
         self.dist_dict: dict = {}
         self.neighborhoods: dict = {}
@@ -126,17 +126,17 @@ def learn_one(self, x: dict):
         x
             A dictionary of feature values.
         """
-        self.X_batch.append(x)
-        if len(self.X) or len(self.X_batch) > 1:
-            self.learn(self.X_batch)
-            self.X_batch = []
+        self.x_batch.append(x)
+        if len(self.X) or len(self.x_batch) > 1:
+            self.learn(self.x_batch)
+            self.x_batch = []
 
-    def learn(self, X_batch: list):
-        X_batch, equal = self.check_equal(X_batch, self.X)
+    def learn(self, x_batch: list):
+        x_batch, equal = self.check_equal(x_batch, self.X)
         if equal != 0 and self.verbose:
             print("%i samples are equal to previous data" % equal)
 
-        if len(X_batch) == 0:
+        if len(x_batch) == 0:
             if self.verbose:
                 print("No new data was added.")
         else:
@@ -152,7 +152,7 @@ def learn(self, X_batch: list):
                 self.local_reach,
                 self.lof,
             ) = self.expand_objects(
-                X_batch,
+                x_batch,
                 self.X,
                 self.neighborhoods,
                 self.rev_neighborhoods,

From 4d209b43a2529c578bbd1e612964af71c9860a03 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Wed, 6 Sep 2023 11:58:19 +0700
Subject: [PATCH 14/43] Verbose re-wording.

---
 river/anomaly/ilof.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 5c2fffe883..ac1790cdc7 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -134,7 +134,7 @@ def learn_one(self, x: dict):
     def learn(self, x_batch: list):
         x_batch, equal = self.check_equal(x_batch, self.X)
         if equal != 0 and self.verbose:
-            print("%i samples are equal to previous data" % equal)
+            print("At least one sample is equal to previously observed instances.")
 
         if len(x_batch) == 0:
             if self.verbose:

From e25c8002011c453b5e79fe8bd538037a3970b711 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Wed, 6 Sep 2023 17:46:40 +0700
Subject: [PATCH 15/43] Refactor X_score to x_scores

---
 river/anomaly/ilof.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index ac1790cdc7..27b4c2cded 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -47,7 +47,7 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
         A list of stored observations.
     x_batch
         A buffer to hold incoming observations until it's time to update the model.
-    X_score
+    x_scores
         A buffer to hold incoming observations until it's time to score them.
     dist_dict
         A dictionary to hold distances between observations.
@@ -102,7 +102,7 @@ def __init__(
         self.n_neighbors = n_neighbors
         self.X: list = []
         self.x_batch: list = []
-        self.X_score: list = []
+        self.x_scores: list = []
         self.dist_dict: dict = {}
         self.neighborhoods: dict = {}
         self.rev_neighborhoods: dict = {}
@@ -225,13 +225,13 @@ def score_one(self, x: dict):
             List of LOF calculated for incoming data
         """
 
-        self.X_score.append(x)
+        self.x_scores.append(x)
 
-        self.X_score, equal = self.check_equal(self.X_score, self.X)
+        self.x_scores, equal = self.check_equal(self.x_scores, self.X)
         if equal != 0 and self.verbose:
             print("The new observation is the same to one of the previously observed instances.")
 
-        if len(self.X_score) == 0:
+        if len(self.x_scores) == 0:
             if self.verbose:
                 print("No new data was added.")
         else:
@@ -247,7 +247,7 @@ def score_one(self, x: dict):
                 local_reach,
                 lof,
             ) = self.expand_objects(
-                self.X_score,
+                self.x_scores,
                 Xs,
                 self.neighborhoods,
                 self.rev_neighborhoods,
@@ -283,7 +283,7 @@ def score_one(self, x: dict):
                 Set_upd_lrd, neighborhoods, reach_dist, local_reach
             )
             lof = self.calc_lof(Set_upd_lof, neighborhoods, local_reach, lof)
-            self.X_score = []
+            self.x_scores = []
 
             return lof[nm[0]]
 

From 01798d65c88344c985699901793784761256ec03 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Thu, 7 Sep 2023 14:47:06 +0700
Subject: [PATCH 16/43] Remove type of returned output in DocString

---
 river/anomaly/ilof.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 27b4c2cded..dad288421d 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -317,13 +317,13 @@ def initial_calculations(
 
         Returns
         -------
-        neighborhoods : dict
+        neighborhoods
             Updated dictionary of particle neighborhoods
-        rev_neighborhoods : dict
+        rev_neighborhoods
             Updated dictionary of reverse particle neighborhoods
-        k_distances : dict
+        k_distances
             Updated dictionary to hold k-distances for each observation
-        dist_dict : dict of dicts
+        dist_dict
             Updated dictionary of dictionaries storing distances between particles
         """
 

From 38a2b4d5f5881cf79fc3d8b90840d315544eb21d Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Thu, 7 Sep 2023 14:47:40 +0700
Subject: [PATCH 17/43] Make check_equal static method and refactor related
 variable names according to PEP8

---
 river/anomaly/ilof.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index dad288421d..2420158f23 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -361,10 +361,12 @@ def initial_calculations(
 
         return neighborhoods, rev_neighborhoods, k_distances, dist_dict
 
-    def check_equal(self, X: list, Y: list):
-        """Check if new batch X has some data samples equal to previous data recorded Y"""
-        result = [x for x in X if not any(x == y for y in Y)]
-        return result, len(X) - len(result)
+    @staticmethod
+    def check_equal(x_list: list, y_list: list):
+        """Check if new list of observations (x_list) has any data sample that is equal to
+           any previous data recorded (y_list)."""
+        result = [x for x in x_list if not any(x == y for y in y_list)]
+        return result, len(x_list) - len(result)
 
     def expand_objects(
         self,

From 762915c8f13eca884765ea10ce09b8cfca0bb58f Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Thu, 7 Sep 2023 14:55:20 +0700
Subject: [PATCH 18/43] Refactor capital X variable to x_list to represent the
 stored list of observations.

---
 river/anomaly/ilof.py | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 2420158f23..dbea7413fc 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -43,7 +43,7 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
 
     Attributes
     ----------
-    X
+    x_list
         A list of stored observations.
     x_batch
         A buffer to hold incoming observations until it's time to update the model.
@@ -100,7 +100,7 @@ def __init__(
         distance_func: DistanceFunc = None,
     ):
         self.n_neighbors = n_neighbors
-        self.X: list = []
+        self.x_list: list = []
         self.x_batch: list = []
         self.x_scores: list = []
         self.dist_dict: dict = {}
@@ -127,12 +127,12 @@ def learn_one(self, x: dict):
             A dictionary of feature values.
         """
         self.x_batch.append(x)
-        if len(self.X) or len(self.x_batch) > 1:
+        if len(self.x_list) or len(self.x_batch) > 1:
             self.learn(self.x_batch)
             self.x_batch = []
 
     def learn(self, x_batch: list):
-        x_batch, equal = self.check_equal(x_batch, self.X)
+        x_batch, equal = self.check_equal(x_batch, self.x_list)
         if equal != 0 and self.verbose:
             print("At least one sample is equal to previously observed instances.")
 
@@ -140,10 +140,10 @@ def learn(self, x_batch: list):
             if self.verbose:
                 print("No new data was added.")
         else:
-            # Increase size of objects to acomodate new data
+            # Increase size of objects to accommodate new data
             (
                 nm,
-                self.X,
+                self.x_list,
                 self.neighborhoods,
                 self.rev_neighborhoods,
                 self.k_dist,
@@ -153,7 +153,7 @@ def learn(self, x_batch: list):
                 self.lof,
             ) = self.expand_objects(
                 x_batch,
-                self.X,
+                self.x_list,
                 self.neighborhoods,
                 self.rev_neighborhoods,
                 self.k_dist,
@@ -170,7 +170,7 @@ def learn(self, x_batch: list):
                 self.k_dist,
                 self.dist_dict,
             ) = self.initial_calculations(
-                self.X, nm, self.neighborhoods, self.rev_neighborhoods, self.k_dist, self.dist_dict
+                self.x_list, nm, self.neighborhoods, self.rev_neighborhoods, self.k_dist, self.dist_dict
             )
 
             # Define sets of particles
@@ -227,7 +227,7 @@ def score_one(self, x: dict):
 
         self.x_scores.append(x)
 
-        self.x_scores, equal = self.check_equal(self.x_scores, self.X)
+        self.x_scores, equal = self.check_equal(self.x_scores, self.x_list)
         if equal != 0 and self.verbose:
             print("The new observation is the same to one of the previously observed instances.")
 
@@ -235,10 +235,10 @@ def score_one(self, x: dict):
             if self.verbose:
                 print("No new data was added.")
         else:
-            Xs = self.X.copy()
+            x_list_copy = self.x_list.copy()
             (
                 nm,
-                Xs,
+                x_list_copy,
                 neighborhoods,
                 rev_neighborhoods,
                 k_dist,
@@ -248,7 +248,7 @@ def score_one(self, x: dict):
                 lof,
             ) = self.expand_objects(
                 self.x_scores,
-                Xs,
+                x_list_copy,
                 self.neighborhoods,
                 self.rev_neighborhoods,
                 self.k_dist,
@@ -259,7 +259,7 @@ def score_one(self, x: dict):
             )
 
             neighborhoods, rev_neighborhoods, k_dist, dist_dict = self.initial_calculations(
-                Xs, nm, neighborhoods, rev_neighborhoods, k_dist, dist_dict
+                x_list_copy, nm, neighborhoods, rev_neighborhoods, k_dist, dist_dict
             )
             (
                 Set_new_points,
@@ -289,7 +289,7 @@ def score_one(self, x: dict):
 
     def initial_calculations(
         self,
-        X: list,
+        x_list: list,
         nm: tuple,
         neighborhoods: dict,
         rev_neighborhoods: dict,
@@ -302,7 +302,7 @@ def initial_calculations(
 
         Parameters
         ----------
-        X
+        x_list
             A list of stored observations.
         nm
             A tuple representing the current size of the dataset.
@@ -331,9 +331,9 @@ def initial_calculations(
         m = nm[1]
         k = self.n_neighbors
 
-        # Calculate distances all particles consdering new and old ones
+        # Calculate distances all particles considering new and old ones
         new_distances = [
-            [i, j, self.distance(X[i], X[j])] for i in range(n + m) for j in range(i) if i >= n
+            [i, j, self.distance(x_list[i], x_list[j])] for i in range(n + m) for j in range(i) if i >= n
         ]
         # Add new distances to distance dictionary
         for i in range(len(new_distances)):
@@ -371,7 +371,7 @@ def check_equal(x_list: list, y_list: list):
     def expand_objects(
         self,
         new_particles: list,
-        X: list,
+        x_list: list,
         neighborhoods: dict,
         rev_neighborhoods: dict,
         k_dist: dict,
@@ -381,9 +381,9 @@ def expand_objects(
         lof: dict,
     ):
         """Expand size of dictionaries and lists to fit new data"""
-        n = len(X)
+        n = len(x_list)
         m = len(new_particles)
-        X.extend(new_particles)
+        x_list.extend(new_particles)
         neighborhoods.update({i: [] for i in range(n + m)})
         rev_neighborhoods.update({i: [] for i in range(n + m)})
         k_dist.update({i: float("inf") for i in range(n + m)})
@@ -393,7 +393,7 @@ def expand_objects(
         lof.update({i + n: [] for i in range(m)})
         return (
             (n, m),
-            X,
+            x_list,
             neighborhoods,
             rev_neighborhoods,
             k_dist,

From b6fbdb5a7052dd5164d769707b5829f605a6fc3b Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Thu, 7 Sep 2023 14:56:01 +0700
Subject: [PATCH 19/43] Refactor code with black

---
 river/anomaly/ilof.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index dbea7413fc..f946868963 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -170,7 +170,12 @@ def learn(self, x_batch: list):
                 self.k_dist,
                 self.dist_dict,
             ) = self.initial_calculations(
-                self.x_list, nm, self.neighborhoods, self.rev_neighborhoods, self.k_dist, self.dist_dict
+                self.x_list,
+                nm,
+                self.neighborhoods,
+                self.rev_neighborhoods,
+                self.k_dist,
+                self.dist_dict,
             )
 
             # Define sets of particles
@@ -333,7 +338,10 @@ def initial_calculations(
 
         # Calculate distances all particles considering new and old ones
         new_distances = [
-            [i, j, self.distance(x_list[i], x_list[j])] for i in range(n + m) for j in range(i) if i >= n
+            [i, j, self.distance(x_list[i], x_list[j])]
+            for i in range(n + m)
+            for j in range(i)
+            if i >= n
         ]
         # Add new distances to distance dictionary
         for i in range(len(new_distances)):
@@ -364,7 +372,7 @@ def initial_calculations(
     @staticmethod
     def check_equal(x_list: list, y_list: list):
         """Check if new list of observations (x_list) has any data sample that is equal to
-           any previous data recorded (y_list)."""
+        any previous data recorded (y_list)."""
         result = [x for x in x_list if not any(x == y for y in y_list)]
         return result, len(x_list) - len(result)
 

From e9f009605139da0fb1e22ab00f2a193d45892aa9 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Thu, 7 Sep 2023 15:53:15 +0700
Subject: [PATCH 20/43] Remove description for unnecessary variables.

---
 river/anomaly/ilof.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index f946868963..bf418c7cca 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -34,8 +34,6 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
     ----------
     n_neighbors
         The number of nearest neighbors to use for density estimation.
-    window_size
-        The size of the batch of data to be taken in at once for the model to learn
     distance_func
         Distance function to be used. By default, the Euclidean distance is used.
     verbose

From 1f1a99ffd2c76dd349e5a3587fb21b3b5b85e5e8 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Thu, 7 Sep 2023 15:53:40 +0700
Subject: [PATCH 21/43] Re-wording for variable description.

---
 river/anomaly/ilof.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index bf418c7cca..204ca59726 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -37,7 +37,7 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
     distance_func
         Distance function to be used. By default, the Euclidean distance is used.
     verbose
-        Whether or not to print messages
+        Whether to print warning/messages
 
     Attributes
     ----------

From a5afc239a58ee830bada9abf31d5b82590a09df3 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Thu, 7 Sep 2023 17:30:43 +0700
Subject: [PATCH 22/43] Refactor.

---
 river/anomaly/ilof.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 204ca59726..9201e7c67e 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -88,7 +88,9 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
 
     References
     ----------
-    Pokrajac, David & Lazarevic, Aleksandar & Latecki, Longin Jan. (2007). Incremental Local Outlier Detection for Data Streams. Proceedings of the 2007 IEEE Symposium on Computational Intelligence and Data Mining, CIDM 2007. 504-515. 10.1109/CIDM.2007.368917.
+    Pokrajac, David & Lazarevic, Aleksandar & Latecki, Longin Jan. (2007). Incremental Local Outlier Detection for Data Streams.
+    In: Proceedings of the 2007 IEEE Symposium on Computational Intelligence and Data Mining (CIDM 2007). 504-515.
+    DOI: 10.1109/CIDM.2007.368917.
     """
 
     def __init__(

From 456cb6ec80937494dcb00754d893b8fa2392f7f5 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Thu, 7 Sep 2023 17:40:52 +0700
Subject: [PATCH 23/43] Add learn_many to learn multiple instances at a time
 and update Docstring test to take into account the newly implemented
 function.

---
 river/anomaly/ilof.py | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 9201e7c67e..d9c450c18e 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -2,6 +2,8 @@
 
 import functools
 
+import pandas as pd
+
 from river import anomaly, utils
 from river.neighbors.base import DistanceFunc
 from river.utils import VectorDict
@@ -79,12 +81,14 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
     >>> for x, _ in datasets.CreditCard().take(200):
     ...    incremental_lof.learn_one(x)
 
+    >>> incremental_lof.learn_many(cc_df[201:401])
+
     >>> ilof_scores = []
-    >>> for x in cc_df[0][201:206]:
+    >>> for x in cc_df[0][401:406]:
     ...    ilof_scores.append(incremental_lof.score_one(x))
 
     >>> [round(ilof_score, 3) for ilof_score in ilof_scores]
-    [1.149, 1.098, 1.158, 1.101, 1.092]
+    [1.802, 1.937, 1.567, 1.181, 1.28]
 
     References
     ----------
@@ -117,6 +121,19 @@ def __init__(
             else functools.partial(utils.math.minkowski_distance, p=2)
         )
 
+    def learn_many(self, x: pd.DataFrame):
+        """
+        Update the model with multiple incoming observations simultaneously.
+        This function assumes that the observations are stored in the first column of the dataset.
+
+        Parameters
+        ----------
+        x
+            A Pandas DataFrame including multiple instances to be learned at the same time
+        """
+        x = x[0].tolist()
+        self.learn(x)
+
     def learn_one(self, x: dict):
         """
         Update the model with one incoming observation

From b4605e3c2b9479b202ff9b5ea56c470251127f87 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 00:00:41 +0700
Subject: [PATCH 24/43] Remove description of unnecessary variables.

---
 river/anomaly/ilof.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index d9c450c18e..6d7a4a58c0 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -63,8 +63,6 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
         A dictionary to hold Local Outlier Factors for each observation.
     local_reach
         A dictionary to hold local reachability distances for each observation.
-    skip_first
-        A boolean value indicating whether to skip the first window of data.
 
     Example
     ----------

From 0e47a2b08af81982a3c5e8ac9e81e3699b679738 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 00:12:35 +0700
Subject: [PATCH 25/43] Spelling correction.

---
 river/anomaly/ilof.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 6d7a4a58c0..cad128a9d4 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -178,7 +178,7 @@ def learn(self, x_batch: list):
                 self.lof,
             )
 
-            # Calculate neighborhoods, reverse neighborhoods, k-distances and distances between neighboors
+            # Calculate neighborhoods, reverse neighborhoods, k-distances and distances between neighbors
             (
                 self.neighborhoods,
                 self.rev_neighborhoods,

From f3a2cb1770f2170cd5d831adb9c05a9288a64a54 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 00:15:23 +0700
Subject: [PATCH 26/43]  Modify variable names by removing capital letters to
 align with PEP8.

---
 river/anomaly/ilof.py | 66 +++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index cad128a9d4..c25c94885c 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -195,16 +195,16 @@ def learn(self, x_batch: list):
 
             # Define sets of particles
             (
-                Set_new_points,
-                Set_neighbors,
-                Set_rev_neighbors,
-                Set_upd_lrd,
-                Set_upd_lof,
+                set_new_points,
+                set_neighbors,
+                set_rev_neighbors,
+                set_upd_lrd,
+                set_upd_lof,
             ) = self.define_sets(nm, self.neighborhoods, self.rev_neighborhoods)
 
             # Calculate new reachability distance of all affected points
             self.reach_dist = self.calc_reach_dist_newpoints(
-                Set_new_points,
+                set_new_points,
                 self.neighborhoods,
                 self.rev_neighborhoods,
                 self.reach_dist,
@@ -212,7 +212,7 @@ def learn(self, x_batch: list):
                 self.k_dist,
             )
             self.reach_dist = self.calc_reach_dist_otherpoints(
-                Set_rev_neighbors,
+                set_rev_neighbors,
                 self.neighborhoods,
                 self.rev_neighborhoods,
                 self.reach_dist,
@@ -222,11 +222,11 @@ def learn(self, x_batch: list):
 
             # Calculate new local reachability distance of all affected points
             self.local_reach = self.calc_local_reach_dist(
-                Set_upd_lrd, self.neighborhoods, self.reach_dist, self.local_reach
+                set_upd_lrd, self.neighborhoods, self.reach_dist, self.local_reach
             )
 
             # Calculate new Local Outlier Factor of all affected points
-            self.lof = self.calc_lof(Set_upd_lof, self.neighborhoods, self.local_reach, self.lof)
+            self.lof = self.calc_lof(set_upd_lof, self.neighborhoods, self.local_reach, self.lof)
 
     def score_one(self, x: dict):
         """
@@ -282,17 +282,17 @@ def score_one(self, x: dict):
                 x_list_copy, nm, neighborhoods, rev_neighborhoods, k_dist, dist_dict
             )
             (
-                Set_new_points,
-                Set_neighbors,
-                Set_rev_neighbors,
-                Set_upd_lrd,
-                Set_upd_lof,
+                set_new_points,
+                set_neighbors,
+                set_rev_neighbors,
+                set_upd_lrd,
+                set_upd_lof,
             ) = self.define_sets(nm, neighborhoods, rev_neighborhoods)
             reach_dist = self.calc_reach_dist_newpoints(
-                Set_new_points, neighborhoods, rev_neighborhoods, reach_dist, dist_dict, k_dist
+                set_new_points, neighborhoods, rev_neighborhoods, reach_dist, dist_dict, k_dist
             )
             reach_dist = self.calc_reach_dist_otherpoints(
-                Set_rev_neighbors,
+                set_rev_neighbors,
                 neighborhoods,
                 rev_neighborhoods,
                 reach_dist,
@@ -300,9 +300,9 @@ def score_one(self, x: dict):
                 k_dist,
             )
             local_reach = self.calc_local_reach_dist(
-                Set_upd_lrd, neighborhoods, reach_dist, local_reach
+                set_upd_lrd, neighborhoods, reach_dist, local_reach
             )
-            lof = self.calc_lof(Set_upd_lof, neighborhoods, local_reach, lof)
+            lof = self.calc_lof(set_upd_lof, neighborhoods, local_reach, lof)
             self.x_scores = []
 
             return lof[nm[0]]
@@ -429,28 +429,28 @@ def expand_objects(
     def define_sets(self, nm, neighborhoods: dict, rev_neighborhoods: dict):
         """Define sets of points for the incremental LOF algorithm"""
         # Define set of new points from batch
-        Set_new_points = set(range(nm[0], nm[0] + nm[1]))
-        Set_neighbors: set = set()
-        Set_rev_neighbors: set = set()
+        set_new_points = set(range(nm[0], nm[0] + nm[1]))
+        set_neighbors: set = set()
+        set_rev_neighbors: set = set()
 
         # Define neighbors and reverse neighbors of new data points
-        for i in Set_new_points:
-            Set_neighbors = set(Set_neighbors) | set(neighborhoods[i])
-            Set_rev_neighbors = set(Set_rev_neighbors) | set(rev_neighborhoods[i])
+        for i in set_new_points:
+            set_neighbors = set(set_neighbors) | set(neighborhoods[i])
+            set_rev_neighbors = set(set_rev_neighbors) | set(rev_neighborhoods[i])
 
         # Define points that need to update their local reachability distance because of new data points
-        Set_upd_lrd = Set_rev_neighbors
-        for j in Set_rev_neighbors:
-            Set_upd_lrd = Set_upd_lrd | set(rev_neighborhoods[j])
-        Set_upd_lrd = Set_upd_lrd | Set_new_points
+        set_upd_lrd = set_rev_neighbors
+        for j in set_rev_neighbors:
+            set_upd_lrd = set_upd_lrd | set(rev_neighborhoods[j])
+        set_upd_lrd = set_upd_lrd | set_new_points
 
         # Define points that need to update their lof because of new data points
-        Set_upd_lof = Set_upd_lrd
-        for m in Set_upd_lrd:
-            Set_upd_lof = Set_upd_lof | set(rev_neighborhoods[m])
-        Set_upd_lof = Set_upd_lof
+        set_upd_lof = set_upd_lrd
+        for m in set_upd_lrd:
+            set_upd_lof = set_upd_lof | set(rev_neighborhoods[m])
+        set_upd_lof = set_upd_lof
 
-        return Set_new_points, Set_neighbors, Set_rev_neighbors, Set_upd_lrd, Set_upd_lof
+        return set_new_points, set_neighbors, set_rev_neighbors, set_upd_lrd, set_upd_lof
 
     def calc_reach_dist_newpoints(
         self,

From 508373ff4ce3d17fab701522ec76ae65ad417043 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 00:30:32 +0700
Subject: [PATCH 27/43] Refactor calc_local_reach_dist and cal_lof and change
 these functions to static methods.

---
 river/anomaly/ilof.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index c25c94885c..8afb602ffa 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -485,19 +485,21 @@ def calc_reach_dist_otherpoints(
                 reach_dist[i][j] = max(dist_dict[i][j], k_dist[j])
         return reach_dist
 
+    @staticmethod
     def calc_local_reach_dist(
-        self, Set: set, neighborhoods: dict, reach_dist: dict, local_reach_dist: dict
+        set_index: set, neighborhoods: dict, reach_dist: dict, local_reach_dist: dict
     ):
-        """Calculate local reachability distance of affected points"""
-        for i in Set:
+        """Calculate local reachability distance of affected points."""
+        for i in set_index:
             local_reach_dist[i] = len(neighborhoods[i]) / sum(
                 [reach_dist[i][j] for j in neighborhoods[i]]
             )
         return local_reach_dist
 
-    def calc_lof(self, Set: set, neighborhoods: dict, local_reach: dict, lof: dict):
-        """Calculate local outlier factor of affected points"""
-        for i in Set:
+    @staticmethod
+    def calc_lof(set_index: set, neighborhoods: dict, local_reach: dict, lof: dict):
+        """Calculate local outlier factor (LOF) of affected points."""
+        for i in set_index:
             lof[i] = sum([local_reach[j] for j in neighborhoods[i]]) / (
                 len(neighborhoods[i]) * local_reach[i]
             )

From 5af882d7fb19458ec676d1c0933c2b9c470d441d Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 00:34:58 +0700
Subject: [PATCH 28/43] Change expand_objects to static method

---
 river/anomaly/ilof.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 8afb602ffa..0a495ef841 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -391,8 +391,8 @@ def check_equal(x_list: list, y_list: list):
         result = [x for x in x_list if not any(x == y for y in y_list)]
         return result, len(x_list) - len(result)
 
+    @staticmethod
     def expand_objects(
-        self,
         new_particles: list,
         x_list: list,
         neighborhoods: dict,

From c7ed8cc3ff90d6df8bee5c00edc1c88fa7bf8a29 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 00:50:59 +0700
Subject: [PATCH 29/43] Refactor.

---
 river/anomaly/ilof.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 0a495ef841..16ed09d934 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -386,8 +386,9 @@ def initial_calculations(
 
     @staticmethod
     def check_equal(x_list: list, y_list: list):
-        """Check if new list of observations (x_list) has any data sample that is equal to
-        any previous data recorded (y_list)."""
+        """
+        Check if new list of observations (x_list) has any data sample that is equal to any previous data recorded (y_list).
+        """
         result = [x for x in x_list if not any(x == y for y in y_list)]
         return result, len(x_list) - len(result)
 

From fedf6f733da2af90a1eaca98036d8c8f8d15b3ab Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 00:51:19 +0700
Subject: [PATCH 30/43] Change define_sets to static method.

---
 river/anomaly/ilof.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 16ed09d934..b3ae7429e3 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -427,8 +427,11 @@ def expand_objects(
             lof,
         )
 
-    def define_sets(self, nm, neighborhoods: dict, rev_neighborhoods: dict):
-        """Define sets of points for the incremental LOF algorithm"""
+    @staticmethod
+    def define_sets(nm, neighborhoods: dict, rev_neighborhoods: dict):
+        """
+        Define sets of points for the incremental LOF algorithm.
+        """
         # Define set of new points from batch
         set_new_points = set(range(nm[0], nm[0] + nm[1]))
         set_neighbors: set = set()

From 8b7bb8cb374f59e3c23ae0a0f54964a07df0715f Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 00:51:36 +0700
Subject: [PATCH 31/43] Change calc_reach_dist_newpoints to static method.

---
 river/anomaly/ilof.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index b3ae7429e3..a9f61463e9 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -456,17 +456,19 @@ def define_sets(nm, neighborhoods: dict, rev_neighborhoods: dict):
 
         return set_new_points, set_neighbors, set_rev_neighbors, set_upd_lrd, set_upd_lof
 
+    @staticmethod
     def calc_reach_dist_newpoints(
-        self,
-        Set: set,
+        set_index: set,
         neighborhoods: dict,
         rev_neighborhoods: dict,
         reach_dist: dict,
         dist_dict: dict,
         k_dist: dict,
     ):
-        """Calculate reachability distance from new points to neighbors and from neighbors to new points"""
-        for c in Set:
+        """
+        Calculate reachability distance from new points to neighbors and from neighbors to new points.
+        """
+        for c in set_index:
             for j in set(neighborhoods[c]):
                 reach_dist[c][j] = max(dist_dict[c][j], k_dist[j])
             for j in set(rev_neighborhoods[c]):

From cc1864a3f1959af6427f33430b858a739bae370a Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 01:00:06 +0700
Subject: [PATCH 32/43] Change calc_reach_dist_otherpoints to static method and
 refactor.

---
 river/anomaly/ilof.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index a9f61463e9..df20313d72 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -475,18 +475,20 @@ def calc_reach_dist_newpoints(
                 reach_dist[j][c] = max(dist_dict[j][c], k_dist[c])
         return reach_dist
 
+    @staticmethod
     def calc_reach_dist_otherpoints(
-        self,
-        Set: set,
+        set_index: set,
         neighborhoods: dict,
         rev_neighborhoods: dict,
         reach_dist: dict,
         dist_dict: dict,
         k_dist: dict,
     ):
-        """Calculate reachability distance from reverse neighbors of reverse neighbors ( RkNN(RkNN(NewPoints)) ) to reverse neighbors ( RkNN(NewPoints) )
-        These values change because of the insertion of new points"""
-        for j in Set:
+        """
+        Calculate reachability distance from reverse neighbors of reverse neighbors ( RkNN(RkNN(NewPoints)) )
+        to reverse neighbors ( RkNN(NewPoints) ). These values change due to the insertion of new points.
+        """
+        for j in set_index:
             for i in set(rev_neighborhoods[j]):
                 reach_dist[i][j] = max(dist_dict[i][j], k_dist[j])
         return reach_dist

From 74d814afcee76ec0288d3cc19c767176f2f1da1e Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 01:14:05 +0700
Subject: [PATCH 33/43] Refactor.

---
 river/anomaly/ilof.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index df20313d72..b7745b3688 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -90,8 +90,8 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
 
     References
     ----------
-    Pokrajac, David & Lazarevic, Aleksandar & Latecki, Longin Jan. (2007). Incremental Local Outlier Detection for Data Streams.
-    In: Proceedings of the 2007 IEEE Symposium on Computational Intelligence and Data Mining (CIDM 2007). 504-515.
+    David Pokrajac, Aleksandar Lazarevic, and Longin Jan Latecki (2007). Incremental Local Outlier Detection for Data
+    Streams. In: Proceedings of the 2007 IEEE Symposium on Computational Intelligence and Data Mining (CIDM 2007). 504-515.
     DOI: 10.1109/CIDM.2007.368917.
     """
 
@@ -231,7 +231,7 @@ def learn(self, x_batch: list):
     def score_one(self, x: dict):
         """
         Score a new incoming observation based on model constructed previously.
-        Perform same calculations as 'learn_one' function but doesn't add the new calculations to the atributes
+        Perform same calculations as 'learn_one' function but doesn't add the new calculations to the attributes
         Data samples that are equal to samples stored by the model are not considered.
 
         Parameters

From fca09a080dfc070a72bfb9d5d80a6c4962d7ef77 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 01:14:29 +0700
Subject: [PATCH 34/43] Refactor calc_reach_dist_new_points

---
 river/anomaly/ilof.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index b7745b3688..a59f6b7eaf 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -203,7 +203,7 @@ def learn(self, x_batch: list):
             ) = self.define_sets(nm, self.neighborhoods, self.rev_neighborhoods)
 
             # Calculate new reachability distance of all affected points
-            self.reach_dist = self.calc_reach_dist_newpoints(
+            self.reach_dist = self.calc_reach_dist_new_points(
                 set_new_points,
                 self.neighborhoods,
                 self.rev_neighborhoods,
@@ -288,7 +288,7 @@ def score_one(self, x: dict):
                 set_upd_lrd,
                 set_upd_lof,
             ) = self.define_sets(nm, neighborhoods, rev_neighborhoods)
-            reach_dist = self.calc_reach_dist_newpoints(
+            reach_dist = self.calc_reach_dist_new_points(
                 set_new_points, neighborhoods, rev_neighborhoods, reach_dist, dist_dict, k_dist
             )
             reach_dist = self.calc_reach_dist_otherpoints(
@@ -457,7 +457,7 @@ def define_sets(nm, neighborhoods: dict, rev_neighborhoods: dict):
         return set_new_points, set_neighbors, set_rev_neighbors, set_upd_lrd, set_upd_lof
 
     @staticmethod
-    def calc_reach_dist_newpoints(
+    def calc_reach_dist_new_points(
         set_index: set,
         neighborhoods: dict,
         rev_neighborhoods: dict,

From 385fc89986cf64b513a1bed2422275801492e59e Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 01:15:17 +0700
Subject: [PATCH 35/43] Refactor calc_reach_dist_other_points.

---
 river/anomaly/ilof.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index a59f6b7eaf..653190bf8e 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -211,7 +211,7 @@ def learn(self, x_batch: list):
                 self.dist_dict,
                 self.k_dist,
             )
-            self.reach_dist = self.calc_reach_dist_otherpoints(
+            self.reach_dist = self.calc_reach_dist_other_points(
                 set_rev_neighbors,
                 self.neighborhoods,
                 self.rev_neighborhoods,
@@ -291,7 +291,7 @@ def score_one(self, x: dict):
             reach_dist = self.calc_reach_dist_new_points(
                 set_new_points, neighborhoods, rev_neighborhoods, reach_dist, dist_dict, k_dist
             )
-            reach_dist = self.calc_reach_dist_otherpoints(
+            reach_dist = self.calc_reach_dist_other_points(
                 set_rev_neighbors,
                 neighborhoods,
                 rev_neighborhoods,
@@ -476,7 +476,7 @@ def calc_reach_dist_new_points(
         return reach_dist
 
     @staticmethod
-    def calc_reach_dist_otherpoints(
+    def calc_reach_dist_other_points(
         set_index: set,
         neighborhoods: dict,
         rev_neighborhoods: dict,

From 2d18fe6a9b4bae24adf4934ac74f0872758829e5 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 01:17:19 +0700
Subject: [PATCH 36/43] Remove import

---
 river/anomaly/ilof.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 653190bf8e..701e6967cb 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -6,7 +6,6 @@
 
 from river import anomaly, utils
 from river.neighbors.base import DistanceFunc
-from river.utils import VectorDict
 
 
 class LocalOutlierFactor(anomaly.base.AnomalyDetector):

From 7ef647e3ac9bd6f925fc394dcc6fff8d6baa0a73 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 01:18:08 +0700
Subject: [PATCH 37/43] Refactor and add description in docstring regarding
 expected performance of ILOF.

---
 river/anomaly/ilof.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 701e6967cb..05e3ecf822 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -17,7 +17,7 @@ class LocalOutlierFactor(anomaly.base.AnomalyDetector):
 
     We consider:
         - NewPoints: new points;
-        - kNN(p): the neighboors of p (the k closest points to p)
+        - kNN(p): the neighboors of p (the k-closest points to p)
         - RkNN(p): the rev-neighboors of p (points that have p as one of their neighboors)
         - Set_upd_lrd: Set of points that need to update the local reachability distance
         - Set_upd_lof: Set of points that need to update the local outlier factor

From f22393cc88148add26230ac8a80ea541451cc0ed Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 07:47:37 +0700
Subject: [PATCH 38/43] Refactor.

---
 river/anomaly/ilof.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 05e3ecf822..966247295e 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -403,7 +403,9 @@ def expand_objects(
         local_reach: dict,
         lof: dict,
     ):
-        """Expand size of dictionaries and lists to fit new data"""
+        """
+        Expand size of dictionaries and lists to take into account new data points.
+        """
         n = len(x_list)
         m = len(new_particles)
         x_list.extend(new_particles)
@@ -496,7 +498,9 @@ def calc_reach_dist_other_points(
     def calc_local_reach_dist(
         set_index: set, neighborhoods: dict, reach_dist: dict, local_reach_dist: dict
     ):
-        """Calculate local reachability distance of affected points."""
+        """
+        Calculate local reachability distance of affected points.
+        """
         for i in set_index:
             local_reach_dist[i] = len(neighborhoods[i]) / sum(
                 [reach_dist[i][j] for j in neighborhoods[i]]
@@ -505,7 +509,9 @@ def calc_local_reach_dist(
 
     @staticmethod
     def calc_lof(set_index: set, neighborhoods: dict, local_reach: dict, lof: dict):
-        """Calculate local outlier factor (LOF) of affected points."""
+        """
+        Calculate local outlier factor (LOF) of affected points.
+        """
         for i in set_index:
             lof[i] = sum([local_reach[j] for j in neighborhoods[i]]) / (
                 len(neighborhoods[i]) * local_reach[i]

From 1eb210dd3b6286c7aa6abc2a3a4bfcb890b5ccb7 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 08:23:42 +0700
Subject: [PATCH 39/43] Remove one unnecessary variable of
 calc_reach_dist_other_points.

---
 river/anomaly/ilof.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 966247295e..92ac687a9d 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -212,7 +212,6 @@ def learn(self, x_batch: list):
             )
             self.reach_dist = self.calc_reach_dist_other_points(
                 set_rev_neighbors,
-                self.neighborhoods,
                 self.rev_neighborhoods,
                 self.reach_dist,
                 self.dist_dict,
@@ -292,7 +291,6 @@ def score_one(self, x: dict):
             )
             reach_dist = self.calc_reach_dist_other_points(
                 set_rev_neighbors,
-                neighborhoods,
                 rev_neighborhoods,
                 reach_dist,
                 dist_dict,
@@ -479,7 +477,6 @@ def calc_reach_dist_new_points(
     @staticmethod
     def calc_reach_dist_other_points(
         set_index: set,
-        neighborhoods: dict,
         rev_neighborhoods: dict,
         reach_dist: dict,
         dist_dict: dict,

From 7ae1ab8592478ac51b551d3c8a18253d5ec0d219 Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Fri, 8 Sep 2023 08:24:00 +0700
Subject: [PATCH 40/43] Modify docstring description of the algorithm

---
 river/anomaly/ilof.py | 44 ++++++++++++++++++++++++-------------------
 1 file changed, 25 insertions(+), 19 deletions(-)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 92ac687a9d..56b2cde678 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -11,25 +11,31 @@
 class LocalOutlierFactor(anomaly.base.AnomalyDetector):
     """Incremental Local Outlier Factor (Incremental LOF).
 
-    Incremental LOF Algorithm as described in the reference paper
-
-    The Incremental Local Outlier Factor (ILOF) is an online version of the Local Outlier Factor (LOF) used to identify outliers based on density of local neighbors.
-
-    We consider:
-        - NewPoints: new points;
-        - kNN(p): the neighboors of p (the k-closest points to p)
-        - RkNN(p): the rev-neighboors of p (points that have p as one of their neighboors)
-        - Set_upd_lrd: Set of points that need to update the local reachability distance
-        - Set_upd_lof: Set of points that need to update the local outlier factor
-
-    The algorithm here implemented based on the original one in the paper is:
-        1) Insert NewPoints and calculate its distance to existing points
-        2) Update the neighboors and reverse-neighboors of all the points
-        3) Define sets of affected points that required update
-        4) Calculate the reachability-distance from new point to neighboors (NewPoints -> kNN(NewPoints)) and from rev-neighboors to new point (RkNN(NewPoints) -> NewPoints)
-        5) Update the reachability-distance for affected points: RkNN(RkNN(NewPoints)) -> RkNN(NewPoints)
-        6) Update local reachability distance of affected points: lrd(Set_upd_lrd)
-        7) Update local outlier factor: lof(Set_upd_lof)
+    The Incremental Local Outlier Factor (ILOF) is an online version of the Local Outlier Factor (LOF), proposed by
+    Pokrajac et al. (2017),  and is used to identify outliers based on density of local neighbors.
+
+    The algorithm take into account the following elements:
+        - `NewPoints`: new points;
+        - `kNN(p)`: the k-nearest neighboors of `p` (the k-closest points to `p`);
+        - `RkNN(p)`: the reverse-k-nearest neighboors of `p` (points that have `p` as one of their neighboors);
+        - `set_upd_lrd`: Set of points that need to have the local reachability distance updated;
+        - `set_upd_lof`: Set of points that need to have the local outlier factor updated.
+
+    This current implementation within `River`, based on the original one in the paper, follows the following steps:
+        1) Insert new data points (`NewPoints`) and calculate its distance to existing points;
+        2) Update the nreaest neighboors and reverse nearest neighboors of all the points;
+        3) Define sets of affected points that required updates;
+        4) Calculate the reachability-distance from new point to neighboors (`NewPoints` -> `kNN(NewPoints)`)
+           and from rev-neighboors to new point (`RkNN(NewPoints)` -> `NewPoints`);
+        5) Update the reachability-distance for affected points: `RkNN(RkNN(NewPoints))` -> `RkNN(NewPoints)`
+        6) Update local reachability distance of affected points: `lrd(set_upd_lrd)`;
+        7) Update local outlier factor: `lof(set_upd_lof)`.
+
+    The incremental LOF algorithm is expected to provide equivalent detection performance as the iterated static
+    LOF algroithm (applied after insertion of each data record), while requiring significantly less computational time.
+    Moreover, the insertion of a new data point as well as deletion of an old data point influence only a limited number
+    of their closest neighbors, which means that the number of updates per such insertion/deletion does not depend
+    on the total number of instances learned/in the data set.
 
     Parameters
     ----------

From 3b5f851ea030cf77d5794018701c6f6676245adc Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Sat, 9 Sep 2023 23:53:04 +0700
Subject: [PATCH 41/43] Add comments to justify the returning results of
 score_one function.

---
 river/anomaly/ilof.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/river/anomaly/ilof.py b/river/anomaly/ilof.py
index 56b2cde678..e66104c4e5 100644
--- a/river/anomaly/ilof.py
+++ b/river/anomaly/ilof.py
@@ -308,6 +308,7 @@ def score_one(self, x: dict):
             lof = self.calc_lof(set_upd_lof, neighborhoods, local_reach, lof)
             self.x_scores = []
 
+            # Use nm[0] as index since upon this configuration nm[1] is expected to be 1.
             return lof[nm[0]]
 
     def initial_calculations(

From 8dae3dcb0291e9c2ebe2422387c315943979905d Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Sat, 9 Sep 2023 23:53:26 +0700
Subject: [PATCH 42/43] Add tests for the newly implemented iLOF algorithm.

---
 river/anomaly/test_ilof.py | 73 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 river/anomaly/test_ilof.py

diff --git a/river/anomaly/test_ilof.py b/river/anomaly/test_ilof.py
new file mode 100644
index 0000000000..23fb7375e1
--- /dev/null
+++ b/river/anomaly/test_ilof.py
@@ -0,0 +1,73 @@
+import numpy as np
+import pandas as pd
+
+from river import anomaly, datasets
+from river.utils import dict2numpy
+from sklearn import neighbors
+
+np.random.seed(42)
+
+
+def test_incremental_lof_scores():
+    """
+    Test that the incremental LOF algorithm returns similar LOF scores for each observation
+    compared with the original static LOF algorithm implemented in scikit-learn.
+    """
+    norm_dist = 0.5 * np.random.rand(100, 2)
+    x_inliers = np.concatenate((norm_dist - 2, norm_dist, norm_dist + 2), axis=0)
+    x_outliers = np.concatenate(
+        (
+            np.random.uniform(low=-4, high=4, size=(20, 2)),
+            np.random.uniform(low=-10, high=-5, size=(10, 2)),
+            np.random.uniform(low=5, high=10, size=(10, 2)),
+        ),
+        axis=0,
+    )
+    x_train = np.concatenate((x_inliers, x_outliers), axis=0)
+    x_train_dict = [{f"feature_{i + 1}": elem[i] for i in range(2)} for elem in x_train]
+    ground_truth = np.ones(len(x_train), dtype=int)
+    ground_truth[-len(x_outliers) :] = -1
+    df_train = pd.DataFrame({"observations": x_train_dict, "ground_truth": ground_truth})
+    x_pred = np.random.uniform(low=-5, high=5, size=(30, 2))
+    x_pred_dict = [{f"feature_{i + 1}": elem[i] for i in range(2)} for elem in x_pred]
+    incremental_lof = anomaly.LocalOutlierFactor(n_neighbors=20, verbose=False)
+
+    for x in df_train["observations"]:
+        incremental_lof.learn_one(x)
+
+    ilof_scores_train = np.array([ilof_score for ilof_score in incremental_lof.lof.values()])
+
+    ilof_scores_pred = []
+    for x in x_pred_dict:
+        ilof_scores_pred.append(incremental_lof.score_one(x))
+
+    lof_sklearn = neighbors.LocalOutlierFactor(n_neighbors=20)
+    lof_sklearn.fit_predict(x_train)
+    lof_sklearn_scores_train = -lof_sklearn.negative_outlier_factor_
+
+    assert np.allclose(ilof_scores_train, lof_sklearn_scores_train, rtol=1e-08, atol=1e-08)
+
+
+def test_batch_lof_scores():
+    """
+    Test that the incremental LOF algorithm returns similar LOF scores for each batch
+    with `learn_many` compared with the original static LOF algorithm implemented in scikit-learn,
+    under different batch sizes.
+    """
+    cc_df = pd.DataFrame(datasets.CreditCard())
+    cc_df_np = [dict2numpy(i) for i in cc_df[0].to_dict().values()]
+
+    batch_sizes = [20, 50, 100]
+
+    for batch_size in batch_sizes:
+        ilof_river_batch = anomaly.LocalOutlierFactor(n_neighbors=20, verbose=False)
+        ilof_river_batch.learn_many(cc_df[0:batch_size])
+        ilof_scores_river_batch = np.array([v for v in ilof_river_batch.lof.values()])
+
+        lof_sklearn_batch = neighbors.LocalOutlierFactor(n_neighbors=20)
+        lof_sklearn_batch.fit_predict(cc_df_np[0:batch_size])
+        lof_scores_sklearn_batch = -lof_sklearn_batch.negative_outlier_factor_
+
+        assert np.allclose(
+            ilof_scores_river_batch, lof_scores_sklearn_batch, rtol=1e-02, atol=1e-02
+        )

From 7ce72be9b320dbfac68e48ebfe05f6911c6d569a Mon Sep 17 00:00:00 2001
From: Hoang-Anh Ngo <50743576+hoanganhngo610@users.noreply.github.com>
Date: Sat, 9 Sep 2023 23:57:00 +0700
Subject: [PATCH 43/43] Remove iLOF notebook (since the content has been
 covered by the test file within the same module).

---
 docs/examples/ilof_notebook.ipynb | 779 ------------------------------
 1 file changed, 779 deletions(-)
 delete mode 100644 docs/examples/ilof_notebook.ipynb

diff --git a/docs/examples/ilof_notebook.ipynb b/docs/examples/ilof_notebook.ipynb
deleted file mode 100644
index 7509df27ee..0000000000
--- a/docs/examples/ilof_notebook.ipynb
+++ /dev/null
@@ -1,779 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {
-    "Screenshot from 2023-06-08 10-01-42.png": {
-     "image/png": "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"
-    }
-   },
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Incremental Local Outlier factor\n",
-    "\n",
-    "##### Created by: Pietro TANURE ONNIS\n",
-    "##### Final project for the Online Machine Learning course at Telecom Paris 2023\n",
-    "\n",
-    "The Incremental Local Outlier Factor (ILOF) is an online version of the Local Outlier Factor (LOF) used to identify outliers based on density of local neighbors.\n",
-    "\n",
-    "We consider: \n",
-    "\n",
-    "    - NewPoints: new points; \n",
-    "    - kNN(p): the neighboors of p (the k closest points to p)\n",
-    "    - RkNN(p): the rev-neighboors of p (points that have p as one of their neighboors)\n",
-    "    - Set_upd_lrd: Set of points that need to update the local reachability distance\n",
-    "    - Set_upd_lof: Set of points that need to update the local outlier factor\n",
-    "\n",
-    "The algorithm here implemented based on the original one in the paper is:\n",
-    "\n",
-    "    1) Insert NewPoints and calculate its distance to existing points\n",
-    "    2) Update the neighboors and reverse-neighboors of all the points\n",
-    "    3) Define sets of affected points that required update\n",
-    "    4) Calculate the reachability-distance from new point to neighboors (NewPoints -> kNN(NewPoints)) and from rev-neighboors to new point (RkNN(NewPoints) -> NewPoints)\n",
-    "    5) Update the reachability-distance for affected points: RkNN(RkNN(NewPoints)) -> RkNN(NewPoints)\n",
-    "    6) Update local reachability distance of affected points: lrd(Set_upd_lrd)\n",
-    "    7) Update local outlier factor: lof(Set_upd_lof)\n",
-    "\n",
-    "Reference: Pokrajac, David & Lazarevic, Aleksandar & Latecki, Longin Jan. (2007). Incremental Local Outlier Detection for Data Streams. Proceedings of the 2007 IEEE Symposium on Computational Intelligence and Data Mining, CIDM 2007. 504-515. 10.1109/CIDM.2007.368917. \n",
-    "\n",
-    "![Screenshot from 2023-06-08 10-01-42.png](<attachment:Screenshot from 2023-06-08 10-01-42.png>)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Generate data with some outliers\n",
-    "\n",
-    "We create an artifical data centered around two cluster and add some data made from another distribuition (outliers)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "np.random.seed(42)\n",
-    "\n",
-    "# Generate train data\n",
-    "X_inliers = 0.3 * np.random.randn(100, 2)\n",
-    "X_inliers = np.r_[X_inliers + 2, X_inliers - 2]\n",
-    "\n",
-    "# Generate some outliers\n",
-    "X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))\n",
-    "X = np.r_[X_inliers, X_outliers]\n",
-    "\n",
-    "n_outliers = len(X_outliers)\n",
-    "ground_truth = np.ones(len(X), dtype=int)\n",
-    "ground_truth[-n_outliers:] = -1\n",
-    "\n",
-    "#Visualize data\n",
-    "plt.title(\"Data with Outliers\")\n",
-    "plt.scatter(X[:, 0], X[:, 1], color=\"k\", s=3.0, label=\"Data points\")\n",
-    "plt.axis(\"tight\")\n",
-    "plt.xlim((-5, 5))\n",
-    "plt.ylim((-5, 5))\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Online Machine Learning with River\n",
-    "\n",
-    "Using the built class ILOF we calculte the Local Outlier Factor in an online approach, at each step we send an instance of data to the model, that will learn it using the 'learn_one' function, updating the model incrementally. \n",
-    "\n",
-    "The class ILOF takes in the following argumetns: \n",
-    "\n",
-    "ILOF(*k_neighbors = int; batch_size = int; verbose = boolean; distance_func = function*)\n",
-    "\n",
-    "\n",
-    "Function to learn batch of data: \n",
-    "\n",
-    "learn_one(*x: dictionary*)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import ilof_ as ilof\n",
-    "from river import utils\n",
-    "\n",
-    "#Convert to dictionary\n",
-    "Xdicts = tuple({f'feature_{i+1}': x[i] for i in range(2)} for x in X)\n",
-    "\n",
-    "#Define model\n",
-    "k = 20 #k-neighboors\n",
-    "ilof_river = ilof.ILOF(k, verbose=False)\n",
-    "\n",
-    "#Fit model on stream data\n",
-    "for x in Xdicts:\n",
-    "    ilof_river.learn_one(x)\n",
-    "\n",
-    "lof_scores_river = np.array([v for v in ilof_river.lof.values()])"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can also evaluate data without adding learning it, this way the programme outputs a LOF for the data but doesn't update the parameters of the model (neighborhoods, reverse neighborhoods, k-distances, reachability-distances, local outlier factor).\n",
-    "\n",
-    "The learn_one function can take in the following arguments:\n",
-    "*learn_one(k_neighbors, batch_size, verbose, distance_func)*"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[4.1225951442931335], [4.856989240600968], [6.700737740891463], [4.67398123498832], [10.318743687776967], [1.695085624011412], [3.1578141066216476], [1.6190480666043154], [4.135136784137301], [5.1959975977883746]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "#Evaluate data without updating the model\n",
-    "X_score = np.random.uniform(low=-4, high=4, size=(10, 2))\n",
-    "\n",
-    "X_score_dict = tuple({f'feature_{i+1}': x[i] for i in range(2)} for x in X_score)\n",
-    "\n",
-    "lof_score = []\n",
-    "for x in X_score_dict:\n",
-    "    lof_score.append(ilof_river.score_one(x))\n",
-    "\n",
-    "print(lof_score)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Batch Machine Learning with Scikit-learn\n",
-    "\n",
-    "To compare our results we fit a model with the same data using scikit-learn\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.neighbors import LocalOutlierFactor\n",
-    "\n",
-    "#Define the model\n",
-    "lof_scikit = LocalOutlierFactor(n_neighbors=k)\n",
-    "\n",
-    "#Fit model on data\n",
-    "lof_scikit.fit_predict(X)\n",
-    "\n",
-    "#Get Local Outlier Factor\n",
-    "lof_scores_scikit = - lof_scikit.negative_outlier_factor_"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Plot results\n",
-    "\n",
-    "We observe that both the online river approach (river) and the batch approach (sklearn) give the same results, but the online has the advantage of being adapted to treat data streams"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "We observe that the difference is at machine error level:\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "array([-4.09616785e-12, -6.33715302e-11,  1.09381393e-11, -1.17567955e-10,\n",
-       "        1.33887346e-11,  1.18958177e-11, -6.57527366e-11, -7.40709716e-11,\n",
-       "       -7.44937445e-12, -6.17876861e-11, -9.02540265e-11, -2.53728150e-11,\n",
-       "        1.22162280e-11, -1.55155888e-11,  1.49403823e-11, -1.26576083e-10,\n",
-       "       -1.56268332e-11, -4.20663504e-11, -7.77566900e-11, -2.44553267e-11,\n",
-       "       -2.61148880e-11,  1.45454759e-11, -5.68558534e-11, -2.96740410e-11,\n",
-       "       -5.03610487e-11,  6.52056187e-12,  8.45368220e-12, -6.24331697e-11,\n",
-       "        3.10773629e-12, -1.87143634e-11,  1.69848580e-11, -6.51001475e-11,\n",
-       "       -5.37054845e-11, -7.33879624e-12, -4.45921078e-12, -6.28377350e-11,\n",
-       "       -6.90747459e-11, -3.41847439e-10,  1.80840898e-11, -8.69331274e-11,\n",
-       "        2.49876786e-11, -1.05403020e-10, -6.49036380e-12, -5.79656323e-11,\n",
-       "        7.16537940e-12, -7.47046869e-12,  6.71662725e-12, -4.13140633e-11,\n",
-       "       -7.85482790e-13,  1.55593316e-11, -4.18334256e-11,  5.83022519e-12,\n",
-       "        2.18497442e-11, -1.66783476e-10,  1.46855861e-11, -1.15608412e-10,\n",
-       "       -1.78021597e-10,  2.40570897e-11, -2.40685250e-11, -7.99027511e-11,\n",
-       "       -3.46016549e-11, -1.07650999e-10, -1.20261578e-10, -3.42865736e-11,\n",
-       "        9.95292737e-12, -3.97579747e-11, -1.71840320e-11, -1.03541176e-10,\n",
-       "        8.75211015e-12, -4.21567226e-11, -5.32438538e-11, -5.20865573e-11,\n",
-       "       -3.00426350e-13, -9.62636637e-11, -1.02473585e-11,  2.13062901e-12,\n",
-       "        8.63087379e-12, -3.78064247e-12, -1.60033098e-10, -3.17976756e-11,\n",
-       "       -2.91409119e-11, -9.17790288e-11, -5.40958389e-11, -8.77666828e-11,\n",
-       "        8.20443713e-12, -4.10795842e-11,  2.28256303e-11, -6.83730850e-12,\n",
-       "       -6.59496902e-11, -2.46087373e-10, -2.80828694e-11, -1.77728943e-11,\n",
-       "        1.73787651e-11, -2.39386289e-12, -5.03110886e-11,  5.85975712e-13,\n",
-       "       -2.67477152e-11,  1.17149623e-11, -5.93547433e-12, -2.51376697e-11,\n",
-       "       -3.91231492e-12, -6.39361897e-11,  1.17769128e-11, -1.36209932e-10,\n",
-       "        1.12351239e-11,  1.16284760e-11, -6.91506852e-11, -8.15103540e-11,\n",
-       "       -9.22262267e-12, -6.39255315e-11, -9.08870756e-11, -2.77369239e-11,\n",
-       "        1.16167076e-11, -1.39550593e-11,  1.46895829e-11, -1.41733292e-10,\n",
-       "       -1.54865010e-11, -4.47302195e-11, -7.35935757e-11, -2.80169221e-11,\n",
-       "       -2.83830737e-11,  1.49515955e-11, -6.71342981e-11, -3.07622816e-11,\n",
-       "       -5.31310551e-11,  6.80433487e-12,  5.86319882e-12, -6.18920470e-11,\n",
-       "        3.35398376e-13, -2.10242934e-11,  1.76045845e-11, -6.86697366e-11,\n",
-       "       -6.14872597e-11, -6.16851015e-12, -3.94029254e-12, -6.70448141e-11,\n",
-       "       -7.16353643e-11, -3.63674646e-10,  1.83564275e-11, -7.49840190e-11,\n",
-       "        2.55555577e-11, -1.05627285e-10, -1.05502274e-11, -5.96580563e-11,\n",
-       "        4.42612613e-12, -6.44362341e-12,  6.25999252e-12, -4.48610038e-11,\n",
-       "       -5.12034859e-13,  1.57456270e-11, -4.36486403e-11,  4.71545025e-12,\n",
-       "        2.25058860e-11, -1.84880333e-10,  1.47774015e-11, -1.19127597e-10,\n",
-       "       -1.85351290e-10,  2.46216381e-11, -2.55948596e-11, -7.39723838e-11,\n",
-       "       -3.54656304e-11, -1.09745102e-10, -1.43158596e-10, -3.35480532e-11,\n",
-       "        1.04337650e-11, -4.41688908e-11, -1.50348622e-11, -1.16774812e-10,\n",
-       "        7.96585020e-12, -4.48201476e-11, -5.69460035e-11, -5.68629588e-11,\n",
-       "        5.56110713e-13, -1.03254738e-10, -1.00581765e-11,  2.49988918e-12,\n",
-       "        6.66378064e-12, -3.26383365e-12, -1.77152959e-10, -3.82229803e-11,\n",
-       "       -3.23736593e-11, -9.27151689e-11, -5.59789992e-11, -9.92872451e-11,\n",
-       "        8.13549228e-12, -4.12598844e-11,  2.33668640e-11, -8.91531293e-12,\n",
-       "       -6.88478163e-11, -2.58987498e-10, -2.74111844e-11, -1.59048330e-11,\n",
-       "        1.83143500e-11, -2.21744845e-12, -6.28099794e-11, -1.59727787e-12,\n",
-       "       -2.83923995e-11,  1.20728982e-11, -7.79643017e-12, -2.67832423e-11,\n",
-       "       -4.55934845e-10, -1.07836184e-10, -3.60191432e-10, -1.28838495e-10,\n",
-       "       -7.21577020e-10, -1.42578749e-09, -2.53113752e-10, -9.60296287e-11,\n",
-       "       -2.22227037e-09, -9.43074063e-10, -1.70505743e-09, -1.32515510e-09,\n",
-       "       -1.30334055e-09, -1.82649540e-09, -1.89989269e-09, -1.57570668e-09,\n",
-       "       -1.35358125e-09, -1.53304036e-09, -1.98927808e-09, -1.32804345e-09])"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from river.utils import dict2numpy\n",
-    "X_scores1 = lof_scores_scikit\n",
-    "X_scores2 = lof_scores_river\n",
-    "\n",
-    "fig, axs = plt.subplots(ncols=2, figsize=(10, 5))\n",
-    "\n",
-    "# First plot\n",
-    "radius1 = (X_scores1.max() - X_scores1) / (X_scores1.max() - X_scores1.min()) * (X_scores1 > 1.5)\n",
-    "axs[0].set_title(\"Local Outlier Factor - Sklearn \")\n",
-    "axs[0].scatter(X[:, 0], X[:, 1], color=\"k\", s=3.0, label=\"Data points\")\n",
-    "axs[0].axis(\"tight\")\n",
-    "axs[0].set_xlim((-5, 5))\n",
-    "axs[0].set_ylim((-5, 5))\n",
-    "axs[0].scatter(X[:, 0], X[:, 1], s=1000 * radius1, edgecolors=\"r\", facecolors=\"none\", label=\"Outlier scores\")\n",
-    "axs[0].legend(loc=\"upper left\")\n",
-    "\n",
-    "# Second plot\n",
-    "radius2 = (max(X_scores2) - X_scores2) / (max(X_scores2) - min(X_scores2)) * (X_scores2 > 1.5)\n",
-    "axs[1].set_title(\"Incremental Local Outlier Factor - River\")\n",
-    "axs[1].scatter(X[:, 0], X[:, 1], color=\"k\", s=3.0, label=\"Data points\")\n",
-    "axs[1].axis(\"tight\")\n",
-    "axs[1].set_xlim((-5, 5))\n",
-    "axs[1].set_ylim((-5, 5))\n",
-    "axs[1].scatter(X[:, 0], X[:, 1], s=1000 * radius2, edgecolors=\"r\", facecolors=\"none\", label=\"Outlier scores\")\n",
-    "axs[1].legend(loc=\"upper left\")\n",
-    "\n",
-    "plt.show()\n",
-    "\n",
-    "print('We observe that the difference is at machine error level:')\n",
-    "X_scores1 - X_scores2"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Time comparison\n",
-    "\n",
-    "Although not adapted to a batch approach River ILOF also allows to calculate a mini-batch approach using the function 'learn_many', here we compare the time of execution of ScikitLOF and RiverILOF considering both receiving a *batch_size*  number of data points:\n",
-    "\n",
-    "ScikitLOF has applies methods like tree search that optimize the search for neighboors so its execution time remains more of less constant"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from river import datasets\n",
-    "import pandas as pd\n",
-    "from river.utils import dict2numpy\n",
-    "import time \n",
-    "dataset = pd.DataFrame(datasets.CreditCard())\n",
-    "dataset_np = [dict2numpy(i) for i in dataset[0].to_dict().values()]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "We observe again that the error is of machine precision level:     (the few errors at the scale of e-05 are because of the river minkowski-distance function error,     I submitted a correction request, for details see bottom of this document  \n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "array([ 1.15640830e-12,  1.39670502e-05,  1.18705046e-12,  1.55497837e-12,\n",
-       "        4.09583478e-12,  1.33378808e-05,  1.28123493e-05,  1.81729894e-05,\n",
-       "        2.78910228e-12,  1.16189877e-05,  1.14542134e-05,  9.35752947e-03,\n",
-       "        1.18571819e-12,  1.33008174e-05,  2.86748403e-12,  1.16448999e-05,\n",
-       "        1.14404267e-05,  1.10114258e-05,  3.12239123e-12,  1.07421263e-05,\n",
-       "        5.79758463e-13,  1.48459023e-12,  1.02679237e-05,  1.10608636e-05,\n",
-       "        9.62921621e-06,  4.63407090e-13,  1.60071956e-12, -1.26565425e-13,\n",
-       "        1.02962083e-12, -1.02362563e-13, -1.12798659e-13, -8.31557045e-14,\n",
-       "       -1.26343380e-13, -1.26343380e-13, -9.31477118e-14, -9.31477118e-14,\n",
-       "        5.65991698e-13, -1.12909682e-13,  5.81756865e-14, -6.90558721e-14,\n",
-       "        5.17141885e-13, -1.15241150e-13, -3.32289751e-13, -1.55431223e-13,\n",
-       "       -3.33177930e-13, -7.32747196e-14, -1.53210777e-13, -2.20934382e-13,\n",
-       "        5.41122702e-13, -7.88258347e-14, -1.08357767e-13,  3.73034936e-13,\n",
-       "       -1.61870517e-13, -2.10720330e-13, -1.11577414e-13,  1.06137321e-13,\n",
-       "        7.18092252e-13, -2.16826557e-13, -1.96176408e-13, -1.94289029e-14,\n",
-       "        5.29576383e-13,  5.44231327e-13,  7.85815857e-13,  7.86259946e-13,\n",
-       "        5.29798427e-13,  1.77857729e-13,  1.84563476e-12,  2.95319325e-13,\n",
-       "        1.70974346e-12,  1.01563202e-12,  9.39026634e-13,  3.55271368e-15,\n",
-       "        1.93178806e-13,  1.67421632e-13,  4.48752147e-13,  1.11022302e-13,\n",
-       "        1.40487622e-12,  5.26911847e-13,  6.88338275e-14,  1.00586206e-13,\n",
-       "        2.87547763e-13,  1.34336986e-13,  7.30526750e-13,  3.91464638e-13,\n",
-       "        1.56761799e-04,  2.69784195e-13,  2.46469511e-13,  1.66405849e-04,\n",
-       "        1.58040050e-04,  2.77333712e-13,  3.08864045e-13,  1.92956762e-13,\n",
-       "        1.82164776e-04,  1.60346254e-04, -3.75195624e-04,  6.79012402e-13,\n",
-       "        1.57798215e-04, -2.95809327e-04, -3.33431024e-04,  6.43923737e-03,\n",
-       "        1.54669151e-04, -3.04159366e-04,  1.56511402e-04,  1.89848137e-13,\n",
-       "        1.55735689e-04, -2.70298576e-04, -5.93150343e-06, -5.30967388e-06,\n",
-       "        4.09087888e-04,  4.07393126e-04,  1.70752301e-13, -5.79448265e-06,\n",
-       "        4.07393126e-04,  4.07393126e-04,  4.07393126e-04,  4.07393126e-04,\n",
-       "        1.30118138e-13,  9.82103288e-13,  1.80522264e-13, -5.32003883e-06,\n",
-       "        9.96536187e-13, -5.26649721e-06,  2.24709140e-13,  2.70457805e-04,\n",
-       "        3.94795308e-13,  2.55833616e-02,  2.01616501e-13, -7.19974911e-06,\n",
-       "       -4.16309377e-04,  2.26485497e-13,  1.36335387e-13, -1.56394049e-04,\n",
-       "       -1.60504680e-04,  1.44551038e-13,  3.40172335e-13,  3.41948692e-13,\n",
-       "       -6.06908744e-06, -1.60557147e-04,  9.34519349e-03,  3.09530179e-13,\n",
-       "        1.63424829e-13, -2.24538171e-04,  5.22248911e-13, -6.35571313e-04,\n",
-       "        4.31520099e-03, -1.72894609e-04, -1.73668432e-04,  4.70068429e-13,\n",
-       "        2.10026490e-02,  7.59392549e-13,  1.70530257e-13,  5.21804822e-13,\n",
-       "        3.11006829e-04,  3.11648281e-04,  3.11801549e-04,  3.29088527e-04,\n",
-       "        3.30327983e-04,  9.14823772e-14,  2.27151631e-13,  2.56017429e-13,\n",
-       "        1.31450406e-13,  1.53210777e-13,  1.17873899e-05,  3.31071287e-04,\n",
-       "        2.02060590e-12,  6.01740879e-13, -5.12563388e-04,  1.92068583e-13,\n",
-       "       -5.09268541e-04,  1.82076576e-13,  2.81108470e-13,  4.03899136e-13,\n",
-       "        2.44915199e-13,  2.04725126e-13,  1.65201186e-13,  1.01008091e-12,\n",
-       "        7.07878201e-13,  4.12336831e-13, -3.49806685e-04,  2.26929586e-13,\n",
-       "        9.29034627e-13,  4.90496532e-13, -3.37636089e-04,  3.67039732e-13,\n",
-       "        8.68860539e-13,  1.28319577e-12,  1.28341782e-13, -3.15081632e-04,\n",
-       "       -3.19684248e-04,  2.52020627e-13,  1.59494640e-12,  1.46549439e-13,\n",
-       "        4.73399098e-13,  1.38620889e-02, -3.05438289e-04, -3.01573389e-04,\n",
-       "       -2.90886979e-04, -3.03033530e-04, -2.91426910e-04,  6.49596881e-05,\n",
-       "       -2.87462398e-04,  1.91446858e-12,  1.39372554e-04, -2.83187516e-04,\n",
-       "        6.25721697e-13,  1.22379275e-04,  2.41584530e-13,  1.40776280e-13,\n",
-       "        1.62048153e-12, -2.77279167e-04,  1.76725301e-12,  1.20264974e-04,\n",
-       "        4.20552482e-13,  1.44328993e-13,  1.19077456e-04,  1.18444812e-04,\n",
-       "        1.17944021e-04,  2.42117437e-12, -1.16573418e-14, -3.04312131e-13,\n",
-       "        1.18190262e-04,  1.18190262e-04,  1.18186866e-04,  1.18186866e-04,\n",
-       "        1.26787469e-13,  1.36677821e-04, -2.38211696e-04,  1.59650071e-13,\n",
-       "        1.14530607e-12,  8.85291840e-13,  2.47801779e-13, -2.49588575e-04,\n",
-       "       -2.50087996e-04, -2.55130443e-04,  1.33448808e-13,  1.86295424e-13,\n",
-       "       -2.62012944e-04, -2.68561161e-04, -2.62749009e-04, -3.02303230e-04,\n",
-       "        1.00364161e-13, -3.37650827e-04,  1.50029701e-02,  1.08113518e-12,\n",
-       "        1.47952174e-02, -2.90580271e-04,  1.00053299e-12, -2.91386478e-04,\n",
-       "        1.34847689e-12,  5.00932629e-13, -2.95171897e-04,  6.53255228e-13,\n",
-       "       -3.02667832e-04, -2.98851904e-04,  7.90034704e-13,  4.60520511e-13,\n",
-       "        8.42437231e-13,  5.03597164e-13, -3.15720643e-04,  3.31956684e-13,\n",
-       "        5.34683409e-13, -3.06075277e-04, -3.06075277e-04,  1.41664458e-13,\n",
-       "        3.04645198e-13,  7.26085858e-14,  5.73319170e-13,  3.71258579e-13,\n",
-       "        1.19015908e-13,  3.38173933e-13,  1.11022302e-13,  5.12923037e-14,\n",
-       "        1.06670228e-12,  1.15463195e-14,  9.37694367e-13, -2.98649994e-14,\n",
-       "       -2.78665979e-14,  4.21440660e-13, -2.26485497e-14,  5.71764858e-13,\n",
-       "       -2.43138842e-14,  2.72448730e-13,  6.44595488e-13,  3.44169138e-13,\n",
-       "        8.35997938e-13, -4.45199433e-14, -6.62803146e-14,  3.33288952e-13,\n",
-       "        4.50528503e-13, -6.94999613e-14, -5.57331958e-14, -4.11892742e-14,\n",
-       "        9.54125667e-13,  5.40456568e-13, -8.16013923e-14, -9.27036226e-14,\n",
-       "        9.61453139e-14,  7.74047493e-13, -1.30562228e-13, -9.54791801e-14,\n",
-       "        4.21884749e-15,  1.77635684e-14, -2.06501483e-14, -2.59792188e-14,\n",
-       "       -3.81916720e-14, -3.16413562e-14,  6.26165786e-13,  9.61453139e-14,\n",
-       "        2.50910404e-14,  5.21804822e-15,  1.06559206e-12, -4.18554080e-14,\n",
-       "        4.15223411e-13,  4.17887946e-13,  2.96873637e-13,  5.50892665e-13,\n",
-       "        1.03472786e-12,  9.06164033e-13,  4.37649916e-13,  1.73638881e-13,\n",
-       "        1.11466392e-12,  3.01758618e-13,  2.29816166e-13, -2.22044605e-15,\n",
-       "       -2.88657986e-15,  7.31414929e-13, -2.57571742e-14, -3.37507799e-14,\n",
-       "       -1.86517468e-14,  9.34807787e-14,  2.33146835e-14,  1.27675648e-14,\n",
-       "        7.54951657e-14,  4.63185046e-13,  9.41469125e-14,  8.59312621e-14,\n",
-       "        5.26245714e-14,  8.12683254e-14, -5.19584376e-14, -1.96509475e-14,\n",
-       "       -7.96029909e-14,  1.24589228e-12,  3.65263375e-13,  4.01012556e-13,\n",
-       "        4.09894341e-13, -5.41788836e-14,  9.21485110e-14, -2.18047802e-13,\n",
-       "       -4.78506124e-14,  3.14193116e-13, -1.68753900e-13,  2.09943174e-12,\n",
-       "       -1.72306613e-13,  9.87210313e-13,  3.15747428e-13, -2.51243470e-13,\n",
-       "       -1.96620498e-13,  2.12030393e-12,  7.80930876e-13, -3.35287353e-14,\n",
-       "       -3.73034936e-14, -7.16093851e-14,  1.05560005e-12, -2.33146835e-15,\n",
-       "        5.35127498e-13,  4.10338430e-13, -2.55351296e-14, -1.18016708e-13,\n",
-       "       -1.08912879e-13, -1.32893696e-13,  2.20135021e-12, -2.63122857e-14,\n",
-       "       -3.04201109e-14,  6.73905376e-13,  1.53210777e-12, -3.90798505e-14,\n",
-       "        1.89404048e-13, -2.84217094e-14,  4.90940621e-13, -1.55431223e-15,\n",
-       "        5.88196158e-13, -6.69464484e-14,  4.00568467e-13, -3.74145159e-14,\n",
-       "        1.57096558e-12, -9.04831765e-14, -3.54161145e-14,  3.23518989e-13,\n",
-       "       -9.40358902e-14, -5.65103520e-14,  1.43218770e-14, -5.08482145e-14,\n",
-       "        4.03010958e-13,  1.71951342e-12, -4.99600361e-14,  7.59392549e-13,\n",
-       "        3.19522186e-13,  7.03215264e-13,  3.57491814e-14,  2.75557355e-13,\n",
-       "        1.69819714e-12,  2.54463117e-13,  4.22106794e-13,  2.44693155e-13,\n",
-       "        1.29674049e-13,  8.52207194e-13,  1.23456800e-13,  3.59934305e-13,\n",
-       "        1.76103576e-12, -7.46069873e-14,  7.31859018e-13, -4.46309656e-14,\n",
-       "       -4.98490138e-14, -4.76285678e-14,  1.48969725e-12,  5.50670620e-14,\n",
-       "        1.70974346e-13, -5.25135491e-14, -8.95949981e-14,  1.71196390e-13,\n",
-       "       -8.58202398e-14,  2.91322522e-13,  7.87148124e-13,  1.45439216e-14,\n",
-       "        3.69038133e-13, -4.09672296e-14, -1.33226763e-14, -3.20854454e-14,\n",
-       "        2.87769808e-13,  7.26529947e-13,  1.87627691e-14, -2.17603713e-14,\n",
-       "        6.86339874e-13,  6.21724894e-14,  1.28275168e-12,  5.12923037e-14,\n",
-       "        2.65121258e-13, -8.32667268e-15,  3.20410365e-13,  3.34177130e-13,\n",
-       "        1.66533454e-14,  7.10542736e-15,  6.88338275e-15, -1.27675648e-14,\n",
-       "        1.15396581e-12,  7.19424520e-14,  1.11999299e-12,  9.21485110e-14,\n",
-       "        2.31370478e-13,  1.75015558e-12,  4.43423076e-13,  1.05648823e-12,\n",
-       "        1.61270997e-12,  1.94066985e-13,  1.09690035e-13,  3.71036535e-13,\n",
-       "        9.06830167e-13,  2.65343303e-13,  2.26263452e-13,  1.51434421e-13,\n",
-       "        2.95097280e-13,  4.04787315e-13,  1.21658239e-12,  1.68753900e-13,\n",
-       "        4.18776125e-13,  1.00786046e-12,  1.02917674e-12,  4.97379915e-13,\n",
-       "        1.37667655e-13, -8.93729535e-14, -2.68673972e-14,  6.99440506e-14,\n",
-       "        9.57900426e-13, -9.35918010e-14, -1.14352972e-14, -1.74305015e-14,\n",
-       "       -1.28341782e-13, -5.66213743e-14,  3.70814490e-14, -1.52211577e-13,\n",
-       "       -9.52571355e-14,  8.90176821e-13, -1.35558231e-13,  3.69926312e-13,\n",
-       "        5.91082738e-13,  8.71080985e-13, -1.44328993e-14, -9.37028233e-14,\n",
-       "        1.00142117e-13,  1.82587279e-12, -3.41948692e-14, -6.78346268e-14,\n",
-       "        7.98472399e-13,  1.94422256e-12,  8.75743922e-13, -7.72715225e-14,\n",
-       "       -4.92939023e-14,  1.18238752e-12, -1.66977543e-13, -1.72750703e-13,\n",
-       "       -1.84297022e-13, -1.36113343e-13,  1.28652644e-12, -1.73083770e-13,\n",
-       "       -9.25926003e-14,  4.66293670e-14, -5.28466160e-14,  9.00612918e-13,\n",
-       "        5.26245714e-14,  4.75175455e-14,  5.24025268e-14,  1.82187598e-12,\n",
-       "        8.82405260e-13,  8.59312621e-14,  8.12683254e-14,  4.57411886e-14,\n",
-       "        1.14197540e-12,  2.68673972e-13,  1.59205982e-13,  5.24025268e-14,\n",
-       "        3.93018951e-14,  2.10942375e-14,  4.72955008e-14,  8.59312621e-14,\n",
-       "        3.08642001e-14,  6.41708908e-14,  7.94697641e-13,  6.04183370e-13,\n",
-       "        8.63753513e-13,  1.02851061e-12,  1.69420034e-13,  1.49658064e-13,\n",
-       "        2.25597319e-13,  9.03721542e-14,  1.03472786e-13,  1.28563826e-13,\n",
-       "        7.14095449e-13,  1.77191595e-13,  1.33670852e-13,  8.52429238e-13,\n",
-       "        1.37445610e-13,  3.09086090e-13,  5.19140286e-13,  1.45838897e-12,\n",
-       "        5.83977311e-14,  3.57491814e-14,  7.65609798e-13,  8.10018719e-13,\n",
-       "        6.41264819e-13,  4.50750548e-14,  8.82183215e-13,  4.66293670e-15,\n",
-       "        6.99440506e-13,  6.29274410e-13,  5.93969318e-13,  6.64801547e-13,\n",
-       "       -4.90718577e-14,  3.17967874e-13, -1.48436818e-13,  7.86481991e-13,\n",
-       "       -6.86117829e-14, -1.45994328e-13, -1.23900890e-13, -1.62647673e-13,\n",
-       "        6.07736084e-13,  5.29354338e-13, -1.01696429e-13, -6.72795153e-14,\n",
-       "        1.68753900e-14, -5.54001289e-14, -7.28306304e-14, -5.70654635e-14,\n",
-       "        5.81756865e-14,  7.53619389e-13, -8.97060204e-14, -6.83897383e-14,\n",
-       "       -8.89288643e-14,  6.91890989e-13,  8.86180018e-13,  2.50466314e-13,\n",
-       "        9.17044218e-13, -5.76205750e-14,  3.83915122e-13,  9.21485110e-14,\n",
-       "       -1.42885703e-13, -1.24344979e-14, -5.57331958e-14, -6.57252031e-14,\n",
-       "        2.10942375e-15,  7.87370169e-13,  4.75175455e-14,  4.58744154e-13,\n",
-       "        9.64561764e-13,  1.25899291e-13,  1.66977543e-13,  3.88356014e-13,\n",
-       "        1.23012711e-13,  9.45910017e-14,  2.44249065e-13,  1.00230935e-12,\n",
-       "        4.90940621e-13,  3.52606833e-13,  1.15907284e-13,  9.35918010e-13,\n",
-       "        5.37347944e-14,  8.06021916e-14,  8.74855743e-14,  6.37268016e-14,\n",
-       "        8.99058605e-13,  6.68354261e-14,  2.54907206e-13,  2.37587727e-14,\n",
-       "        1.73194792e-14,  6.63691324e-13,  1.69708692e-12, -1.33226763e-14,\n",
-       "       -6.40598685e-14,  7.32747196e-15, -4.81836793e-14,  2.70006240e-13,\n",
-       "        7.53175300e-13,  4.79616347e-14, -2.12052598e-14,  6.06181771e-14,\n",
-       "        1.61870517e-13, -2.91988655e-14, -2.04281037e-14, -7.54951657e-14,\n",
-       "        7.10542736e-15,  1.86295424e-13, -7.27196081e-14, -1.99840144e-14,\n",
-       "        6.23945340e-14,  1.38999923e-13, -6.61692923e-14,  9.08162434e-14,\n",
-       "       -4.79616347e-14,  1.23234756e-12,  8.19566637e-13, -1.23345778e-13,\n",
-       "        5.12256904e-13, -2.04281037e-14,  3.96349620e-13, -4.66293670e-14,\n",
-       "        2.58904009e-13,  1.16529009e-12, -1.00697228e-13,  7.03437308e-13,\n",
-       "       -7.00550729e-14, -2.50910404e-14, -1.72084569e-14,  3.75255382e-14,\n",
-       "        1.65423231e-13,  2.44027021e-13,  8.50430837e-14,  7.50066675e-13,\n",
-       "       -5.49560397e-14,  3.40172335e-13, -3.81916720e-14, -2.00950367e-14,\n",
-       "       -7.38298311e-14,  2.48023824e-13,  3.59046126e-13, -3.70814490e-14,\n",
-       "        2.84217094e-13,  7.37410133e-13,  6.21724894e-14,  3.55493412e-13,\n",
-       "        5.50670620e-14,  1.39666056e-13,  9.16156040e-13,  2.96429548e-14,\n",
-       "        3.26405569e-14,  1.44328993e-13,  4.82280882e-13,  3.41948692e-14,\n",
-       "        3.35953487e-13,  3.03090886e-13,  2.90878432e-14,  4.26325641e-14,\n",
-       "        7.34967642e-14,  2.53130850e-13,  3.28181926e-13,  4.13225010e-13,\n",
-       "        4.92939023e-14,  2.52908805e-13,  7.19424520e-14,  9.05941988e-14,\n",
-       "        1.37667655e-13,  4.52082816e-13,  3.84359211e-13, -2.89768209e-14,\n",
-       "        3.67927910e-13,  3.20188320e-13,  4.28101998e-13,  4.29212221e-13,\n",
-       "        5.54889468e-13,  1.07247544e-13,  2.40030218e-13,  7.03881398e-14,\n",
-       "        1.15685239e-13,  1.04583009e-13,  1.22790667e-13,  1.62092562e-13,\n",
-       "        8.41771097e-13,  1.69420034e-13,  5.42677014e-13,  4.29434266e-13,\n",
-       "        1.62980740e-13,  6.54143406e-13,  2.06501483e-13,  1.94511074e-13,\n",
-       "        8.22231172e-13,  5.83311177e-13,  9.64339719e-13,  8.65529870e-13,\n",
-       "        1.13686838e-13,  1.48547841e-13,  8.86180018e-13,  2.07389661e-13,\n",
-       "        7.99360578e-15,  6.17284002e-14, -2.02060590e-14,  1.62536651e-13,\n",
-       "        9.51239087e-13,  1.35313982e-12,  1.22590826e-12,  8.39328607e-14,\n",
-       "        1.18216548e-12, -2.07611706e-14, -1.81521465e-13, -1.28785871e-13,\n",
-       "        4.79838391e-13,  9.35029831e-13, -2.08055795e-13, -1.71751502e-13,\n",
-       "        1.42108547e-13, -1.88848936e-13,  2.00683914e-12, -1.43440815e-13,\n",
-       "        4.88942220e-13, -2.53019827e-13, -1.59205982e-13, -2.01838546e-13,\n",
-       "       -7.30526750e-14,  3.79696274e-13, -2.36921593e-13,  4.46975790e-13,\n",
-       "        2.53552734e-12, -1.84297022e-13, -5.07371922e-14,  7.41851025e-13,\n",
-       "       -8.01581024e-14, -7.90478794e-14,  3.17457172e-12, -2.64233080e-14,\n",
-       "       -7.54951657e-15,  3.68594044e-14,  1.44551038e-13,  4.92939023e-14,\n",
-       "        1.26343380e-13, -2.76445533e-14,  6.29274410e-13,  1.84074977e-13,\n",
-       "        7.41406936e-13,  4.39648318e-13,  1.61648472e-13,  1.31827882e-12,\n",
-       "        9.06830167e-13,  3.14637205e-13,  2.80220291e-13,  2.40918396e-13,\n",
-       "        6.31938946e-13,  3.30846461e-13,  1.13908882e-13,  2.08277839e-13,\n",
-       "        1.51079149e-12,  2.36033415e-13,  4.70956607e-13,  1.88515870e-13,\n",
-       "        2.24043006e-13,  2.07345252e-12,  1.56763491e-13,  1.80744308e-13,\n",
-       "        1.13020704e-13,  7.68274333e-14,  5.41788836e-14,  1.73527859e-12,\n",
-       "        3.26405569e-14,  6.63913369e-14,  2.86437540e-14,  5.05595565e-13,\n",
-       "        7.92699240e-14,  9.11715148e-13,  6.88338275e-14,  3.12194715e-13,\n",
-       "        6.17284002e-14,  4.95159469e-13,  2.02060590e-14,  1.04782849e-12,\n",
-       "       -1.78745907e-14,  1.04360964e-14,  1.04494191e-12,  1.05138120e-12,\n",
-       "        1.11999299e-12,  3.80584453e-13, -1.20459198e-13,  4.38316050e-13,\n",
-       "        8.99280650e-14,  1.38777878e-13, -6.32827124e-14, -9.10382880e-15,\n",
-       "        1.48991930e-13,  1.48547841e-13,  4.44311254e-13,  1.44328993e-14,\n",
-       "        2.06279438e-13,  1.79856130e-14,  6.28386232e-14,  1.05693232e-13,\n",
-       "        4.33653113e-13,  9.89874849e-13,  6.03517236e-13,  4.05897538e-13,\n",
-       "        6.14397422e-13,  3.30624417e-13,  9.05275854e-13,  3.03090886e-13,\n",
-       "        7.83817455e-13,  4.95603558e-13,  6.00186567e-13,  3.87911925e-13,\n",
-       "        8.27782287e-13,  9.02389274e-13,  8.79740725e-13,  3.63487018e-13,\n",
-       "        8.07354184e-13,  5.88418203e-13,  2.70672373e-13,  6.51922960e-13,\n",
-       "        7.19424520e-13,  4.84057239e-13,  3.40394379e-13,  1.08801856e-13,\n",
-       "        6.52811138e-14, -5.98410210e-14,  4.94715380e-13,  3.73923115e-13,\n",
-       "       -1.33337785e-13,  9.99200722e-13,  3.03090886e-14,  4.09006162e-13,\n",
-       "        1.14308563e-12, -2.00617301e-13, -1.39555034e-13, -5.17363929e-14,\n",
-       "       -1.10356169e-13, -2.79998247e-13, -1.82964754e-13, -1.57762692e-13,\n",
-       "       -1.05027098e-13, -2.20601315e-13,  1.17461596e-13, -1.93511873e-13,\n",
-       "        7.45847828e-13,  4.78728168e-13, -1.76192394e-13, -1.79856130e-13,\n",
-       "        4.99822406e-13, -1.25677246e-13, -1.25677246e-13,  8.32667268e-15,\n",
-       "        5.61772850e-13,  1.22346577e-13,  4.88720175e-13,  2.11164419e-13,\n",
-       "        7.60724816e-13,  4.28768132e-13,  1.58983937e-13,  1.90514271e-13,\n",
-       "        3.43947093e-13,  1.44151358e-12,  1.04583009e-13,  6.80344669e-13,\n",
-       "        2.16493490e-13,  3.59712260e-14,  1.49347201e-12,  2.22488694e-13,\n",
-       "        1.38178358e-12,  1.08801856e-14,  1.11022302e-15,  3.45501405e-13,\n",
-       "        2.18269847e-13,  4.09894341e-13,  1.48547841e-13,  3.16857651e-13,\n",
-       "        1.25144339e-12,  8.00470801e-13,  9.14823772e-14,  7.90478794e-14,\n",
-       "        4.57411886e-14,  6.92779167e-14,  1.46771484e-13,  2.04725126e-13,\n",
-       "        5.47339951e-13,  1.23234756e-13,  5.10702591e-13,  6.63913369e-14,\n",
-       "        2.73114864e-13,  7.13651360e-13,  2.00950367e-14,  1.41420209e-12,\n",
-       "        1.36135547e-12,  1.72972747e-13,  1.56896718e-12,  1.88737914e-14,\n",
-       "        1.96287431e-13,  2.83773005e-13,  2.08943973e-13,  1.38933309e-12,\n",
-       "        8.34887715e-14,  9.01501096e-14,  2.85105273e-13,  1.82520665e-13,\n",
-       "        4.42756942e-13,  6.43929354e-14,  5.73097125e-13,  7.37854222e-13,\n",
-       "        6.11510842e-13,  3.34621220e-13,  4.66293670e-15,  9.99200722e-15,\n",
-       "        1.15241150e-13,  4.81170659e-13,  2.04281037e-14,  5.53779245e-13,\n",
-       "       -1.13242749e-14,  1.11022302e-13,  3.55271368e-14,  1.39888101e-13,\n",
-       "        1.73372428e-12,  7.27862215e-13, -4.58522109e-14,  2.66475730e-12,\n",
-       "       -1.11466392e-13, -1.00697228e-13, -1.11133325e-13, -8.84847751e-14,\n",
-       "        4.67403893e-13, -1.42441614e-13,  2.68740585e-12, -1.99840144e-14,\n",
-       "        1.22790667e-13, -7.39408534e-14,  1.23900890e-13,  1.26876287e-12,\n",
-       "        8.65973959e-13,  7.48512363e-13,  7.79376563e-14, -1.61537450e-13,\n",
-       "        3.44169138e-14, -1.08135723e-13, -3.49831275e-13, -1.39999123e-13,\n",
-       "        4.22550883e-13, -2.65343303e-13, -2.37920794e-13, -1.22013510e-13,\n",
-       "       -1.39555034e-13,  2.35012010e-12, -1.91957561e-13,  1.01252340e-13,\n",
-       "        7.72271136e-13, -5.12923037e-14,  1.06137321e-12,  7.55395746e-13,\n",
-       "        2.77555756e-15,  8.32001135e-13,  1.55520041e-12,  1.22124533e-13,\n",
-       "        1.03939080e-12,  3.17523785e-14,  2.82662782e-13,  1.03916875e-13,\n",
-       "        1.14552812e-12,  1.16573418e-12,  6.48148202e-13,  2.19824159e-13,\n",
-       "        4.03632683e-12,  4.03677092e-13,  4.66826577e-12,  7.95807864e-13,\n",
-       "        3.24407168e-13,  3.04645198e-13,  3.57047725e-13,  7.15871806e-13,\n",
-       "        8.36664071e-13,  1.99174011e-12,  5.36015676e-12,  7.07878201e-13])"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "k = 20\n",
-    "batch_sizes = [20,50,100,200,400,1000]\n",
-    "\n",
-    "time_river = []\n",
-    "time_scikit = []\n",
-    "for batch_size in batch_sizes:\n",
-    "    #River\n",
-    "    start_time_r = time.time()\n",
-    "    ilof_river2 = ilof.ILOF(k, verbose=False)\n",
-    "    ilof_river2.learn_many(dataset[0:batch_size])\n",
-    "    time_river.append(time.time() - start_time_r)\n",
-    "    ilof_scores_river2 = np.array([v for v in ilof_river2.lof.values()])\n",
-    "\n",
-    "    #Scikit\n",
-    "    start_time_s = time.time()\n",
-    "    lof_scikit2 = LocalOutlierFactor(n_neighbors=k)\n",
-    "    lof_scikit2.fit_predict(dataset_np[0:batch_size])\n",
-    "    time_scikit.append(time.time() - start_time_s)\n",
-    "    lof_scores_scikit2 = - lof_scikit2.negative_outlier_factor_\n",
-    "\n",
-    "#Compare\n",
-    "print('We observe again that the error is of machine precision level: \\\n",
-    "    (the few errors at the scale of e-05 are because of the river minkowski-distance function error, \\\n",
-    "    I submitted a correction request, for details see bottom of this document  ')\n",
-    "ilof_scores_river2 - lof_scores_scikit2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "# Plotting the bar graph\n",
-    "plt.bar(np.array(range(len(time_river)))*1.5+0.25, time_river, width=0.4, label='River ILOF')\n",
-    "plt.bar(np.array(range(len(time_river)))*1.5-0.25, time_scikit, width=0.4, label='Scikit LOF')\n",
-    "plt.xticks(np.array(range(len(time_river)))*1.5, batch_sizes)\n",
-    "plt.xlabel('Batch size')\n",
-    "plt.ylabel('Execution Time (seconds)')\n",
-    "plt.title('Mini-batch mode Time Comparison')\n",
-    "plt.yscale('log')\n",
-    "plt.legend()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "RiverILOF time: [5.1155877113342285] ;  ScikitLOF time: [0.22044944763183594] \n",
-      " We observe that RiverILOF gets slower as the number of points learned increases,    since it calculates the distance of the new point to all other ones each iteration\n"
-     ]
-    }
-   ],
-   "source": [
-    "#Time to add new points on existing model with 1000 points\n",
-    "#River\n",
-    "time_r = []\n",
-    "start_t_r = time.time()\n",
-    "for x in dataset[0][1200:1300]:\n",
-    "    ilof_river2.learn_one(x)\n",
-    "time_r.append(time.time() - start_t_r)\n",
-    "\n",
-    "#Scikit\n",
-    "time_s = []\n",
-    "start_t_s = time.time()\n",
-    "lof_scikit2.novelty = True\n",
-    "lof_scores_scikit2 = lof_scikit2.score_samples(dataset_np[1200:1300])\n",
-    "time_s.append(time.time() - start_t_s)\n",
-    "\n",
-    "print('RiverILOF time:', time_r,';  ScikitLOF time:', time_s, '\\n We observe that RiverILOF gets slower as the number of points learned increases,\\\n",
-    "since it calculates the distance of the new point to all other ones each iteration.')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "13.974262055650739 195.28000000000003\n"
-     ]
-    }
-   ],
-   "source": [
-    "#River Minkowski_distance error\n",
-    "\n",
-    "import functools\n",
-    "from river import utils\n",
-    "#from river.neighbors.base import DistanceFunc\n",
-    "from river.utils import VectorDict\n",
-    "\n",
-    "distancefunc = functools.partial(utils.math.minkowski_distance, p=2)\n",
-    "a={1: 1.5, 2: 3.5}\n",
-    "b={1: -0.7, 2: -10.3}\n",
-    "print(((1.5+0.7)**2+(3.5+10.3)**2)**(1/2), distancefunc(a,b))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.16"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}