### Install scikit-garden from source

Source: https://onelearn.readthedocs.io/en/latest/_sources/experiments.rst.txt

Clones the scikit-garden repository and installs it via setup.py to get the latest version, required for comparison with Mondrian forests.

```bash
git clone https://github.com/scikit-garden/scikit-garden.git && \
    cd scikit-garden && \
    python setup.py build install
```

--------------------------------

### Install onelearn from GitHub

Source: https://onelearn.readthedocs.io/en/latest/_sources/index.rst.txt

Install the latest development version of onelearn directly from GitHub.

```bash
pip install git+https://github.com/onelearn/onelearn.git
```

--------------------------------

### Run tree playground with run_playground_tree

Source: https://onelearn.readthedocs.io/en/latest/_sources/playground.rst.txt

Starts the tree playground. Requires streamlit, bokeh, and matplotlib. Use after pip installing onelearn.

```python
from onelearn import run_playground_tree

run_playground_tree()
```

--------------------------------

### Install onelearn via pip

Source: https://onelearn.readthedocs.io/en/latest/_sources/index.rst.txt

Install onelearn from PyPI using pip.

```bash
pip install onelearn
```

--------------------------------

### Run decision function playground with run_playground_decision

Source: https://onelearn.readthedocs.io/en/latest/_sources/playground.rst.txt

Starts the decision function playground. Requires streamlit, bokeh, and matplotlib. Use after pip installing onelearn.

```python
from onelearn import run_playground_decision

run_playground_decision()
```

--------------------------------

### Run scripts to reproduce paper figures

Source: https://onelearn.readthedocs.io/en/latest/_sources/experiments.rst.txt

Commands to run the example scripts that reproduce all figures from the paper. Note that run_* scripts can take a while, especially run_regrets_experiments.py.

```bash
python examples/plot_iterations.py
```

```bash
python examples/plot_decisions.py
```

```bash
python examples/plot_forest_effect.py
```

```bash
python examples/run_regrets_experiments.py
```

```bash
python examples/run_online_vs_batch.py
```

```bash
python examples/run_n_trees_sensitivity.py
```

--------------------------------

### RandomForestClassifier

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_decisions.html

RandomForestClassifier from scikit-learn is used in the example. It is instantiated with n_estimators and random_state. It supports fit and predict_proba methods.

```APIDOC
## RandomForestClassifier

### Description
RandomForestClassifier is a random forest classifier from scikit-learn. It is used in the example to compare decision functions with other classifiers.

### Constructor Parameters
- **n_estimators** (int) - Required - Number of estimators in the forest.
- **random_state** (int) - Required - Random state for reproducibility.

### Methods
#### fit(X, y)
Fits the classifier on the given data.

#### predict_proba(X)
Returns probability estimates for the input samples.

### Example Usage
```python
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X, y)
Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
```
```

--------------------------------

### ExtraTreesClassifier

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_decisions.html

ExtraTreesClassifier from scikit-learn is used in the example. It is instantiated with n_estimators and random_state. It supports fit and predict_proba methods.

```APIDOC
## ExtraTreesClassifier

### Description
ExtraTreesClassifier is an extra trees classifier from scikit-learn. It is used in the example to compare decision functions with other classifiers.

### Constructor Parameters
- **n_estimators** (int) - Required - Number of estimators in the forest.
- **random_state** (int) - Required - Random state for reproducibility.

### Methods
#### fit(X, y)
Fits the classifier on the given data.

#### predict_proba(X)
Returns probability estimates for the input samples.

### Example Usage
```python
from sklearn.ensemble import ExtraTreesClassifier
clf = ExtraTreesClassifier(n_estimators=100, random_state=42)
clf.fit(X, y)
Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
```
```

--------------------------------

### MondrianForestClassifier

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_decisions.html

MondrianForestClassifier from scikit-garden is used in the example. It is instantiated with n_estimators and random_state. It supports fit and predict_proba methods.

```APIDOC
## MondrianForestClassifier

### Description
MondrianForestClassifier is a random forest type classifier from scikit-garden. It is used in the example to compare decision functions with other classifiers.

### Constructor Parameters
- **n_estimators** (int) - Required - Number of estimators in the forest.
- **random_state** (int) - Required - Random state for reproducibility.

### Methods
#### fit(X, y)
Fits the classifier on the given data.

#### predict_proba(X)
Returns probability estimates for the input samples.

### Example Usage
```python
from skgarden import MondrianForestClassifier
clf = MondrianForestClassifier(n_estimators=100, random_state=42)
clf.fit(X, y)
Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
```
```

--------------------------------

### AMFClassifier

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_decisions.html

The AMFClassifier from onelearn is used in the example. It is instantiated with parameters such as n_classes, n_estimators, random_state, use_aggregation, and split_pure. The classifier supports partial_fit and predict_proba methods.

```APIDOC
## AMFClassifier

### Description
AMFClassifier is a random forest type classifier from onelearn. It is used in the example to compare decision functions with other classifiers.

### Constructor Parameters
- **n_classes** (int) - Required - Number of classes.
- **n_estimators** (int) - Required - Number of estimators in the forest.
- **random_state** (int) - Required - Random state for reproducibility.
- **use_aggregation** (bool) - Required - Whether to use aggregation.
- **split_pure** (bool) - Required - Whether to split pure nodes.

### Methods
#### partial_fit(X, y)
Incrementally fits the classifier on the given data.

#### predict_proba(X)
Returns probability estimates for the input samples.

### Example Usage
```python
from onelearn import AMFClassifier
clf = AMFClassifier(
    n_classes=2,
    n_estimators=100,
    random_state=42,
    use_aggregation=True,
    split_pure=True,
)
clf.partial_fit(X, y)
Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
```
```

--------------------------------

### Run tree playground with streamlit

Source: https://onelearn.readthedocs.io/en/latest/_sources/playground.rst.txt

Alternative way to run the tree playground when onelearn is git cloned. Executes the streamlit app from examples/playground_tree.py.

```bash
streamlit run examples/playground_tree.py
```

--------------------------------

### AMFClassifier.__init__

Source: https://onelearn.readthedocs.io/en/latest/_sources/generated/onelearn.AMFClassifier.rst.txt

Initializes the AMFClassifier instance.

```APIDOC
## AMFClassifier.__init__

### Description
Initializes the AMFClassifier instance.

### Method
Constructor

### Signature
`__init__(self, ...)`

### Parameters
No parameters are explicitly documented in the source.

### Returns
None

```

--------------------------------

### Generate onelearn logo with AMFClassifier

Source: https://onelearn.readthedocs.io/en/latest/_sources/auto_examples/plot_logo.rst.txt

Runs the full logo-generation script: imports libraries, sets up logging, creates a two-class dataset with make_moons, splits into train/test, computes a meshgrid, trains an AMFClassifier with partial_fit over several iterations, plots decision contours and scatter points, and saves the figure as logo.png. The script prints progress bar output from tqdm.

```python
import sys
import logging
import matplotlib.pyplot as plt
from tqdm import trange
from sklearn.datasets import make_moons
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split

sys.path.extend([".", ".."])
from onelearn import AMFClassifier
from experiments.plot import (
    get_mesh,
    plot_contour_binary_classif,
    plot_scatter_binary_classif,
)

logging.basicConfig(
    format="%(asctime)s %(message)s", datefmt="%Y/%m/%d %H:%M:%S", level=logging.INFO
)

n_samples = 100
n_features = 2
n_classes = 2
random_state = 123
save_iterations = [5, 10, 30, 70]

logging.info("Simulation of the data")
X, y = make_moons(n_samples=n_samples, noise=0.25, random_state=random_state)

logging.info("Train/Test splitting")
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.5, random_state=random_state
)

logging.info("Computation of the meshgrid")
xx, yy, X_mesh = get_mesh(X)


clf = AMFClassifier(
    n_classes=n_classes,
    n_estimators=100,
    random_state=random_state,
    split_pure=True,
    use_aggregation=True,
)

n_plots = len(save_iterations)
n_fig = 0
save_iterations = [0, *save_iterations]

plt.figure(figsize=(3, 3))

logging.info("Launching iterations")
bar = trange(n_plots, desc="Plotting iterations", leave=True)

norm = plt.Normalize(vmin=0.0, vmax=1.0)

for start, end in zip(save_iterations[:-1], save_iterations[1:]):
    X_iter = X_train[start:end]
    y_iter = y_train[start:end]
    clf.partial_fit(X_iter, y_iter)
    n_fig += 1
    Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
    ax = plt.subplot(2, 2, n_fig)
    score = roc_auc_score(y_test, clf.predict_proba(X_test)[:, 1])
    plot_contour_binary_classif(ax, xx, yy, Z, levels=5, norm=norm)

    plot_scatter_binary_classif(
        ax, xx, yy, X_train[:end], y_train[:end], s=15, norm=norm
    )
    bar.update(1)

bar.close()
plt.subplots_adjust(wspace=0, hspace=0)
plt.savefig("logo.png", transparent=True)
logging.info("Saved logo in file logo.png")
```

```none
Plotting iterations:   0%|          | 0/4 [00:00<?, ?it/s]
Plotting iterations:  25%|##5       | 1/4 [00:02<00:06,  2.04s/it]
Plotting iterations:  50%|#####     | 2/4 [00:04<00:04,  2.11s/it]
Plotting iterations:  75%|#######5  | 3/4 [00:07<00:02,  2.31s/it]
Plotting iterations: 100%|##########| 4/4 [00:09<00:00,  2.42s/it]
Plotting iterations: 100%|##########| 4/4 [00:09<00:00,  2.44s/it]
```

--------------------------------

### Run decision playground with streamlit

Source: https://onelearn.readthedocs.io/en/latest/_sources/playground.rst.txt

Alternative way to run the decision function playground when onelearn is git cloned. Executes the streamlit app from examples/playground_decision.py.

```bash
streamlit run examples/playground_decision.py
```

--------------------------------

### OnlineDummyClassifier.__init__

Source: https://onelearn.readthedocs.io/en/latest/_sources/generated/onelearn.OnlineDummyClassifier.rst.txt

Initializes the OnlineDummyClassifier instance.

```APIDOC
## OnlineDummyClassifier.__init__

### Description
Initializes the OnlineDummyClassifier instance.

### Method
__init__

### Parameters
No parameters documented.

### Returns
No return value documented.
```

--------------------------------

### Clone onelearn repository

Source: https://onelearn.readthedocs.io/en/latest/_sources/experiments.rst.txt

Clones the onelearn repository to access the scripts for reproducing paper figures.

```bash
git clone https://github.com/onelearn/onelearn.git
```

--------------------------------

### Initialize AMFClassifier

Source: https://onelearn.readthedocs.io/en/latest/_sources/classification.rst.txt

Create an instance of the AMFClassifier with the required n_classes parameter.

```python
from onelearn import AMFClassifier

amf = AMFClassifier(n_classes=2)
```

--------------------------------

### Create AMFClassifier with default parameters

Source: https://onelearn.readthedocs.io/en/latest/classification.html

Instantiate an AMFClassifier for online multi-class classification. The n_classes parameter must be provided when constructing the object.

```python
from onelearn import AMFClassifier

amf = AMFClassifier(n_classes=2)

```

--------------------------------

### partial_fit(X, y, classes=None)

Source: https://onelearn.readthedocs.io/en/latest/generated/onelearn.AMFClassifier.html

Updates the classifier with a batch of samples. This is the main method for online learning.

```APIDOC
## partial_fit(X, y, classes=None)

### Description
Updates the classifier with the given batch of samples.

### Parameters
- **X** (`np.ndarray`, shape=(n_samples, n_features)) - Required - Input features matrix.
- **y** (`np.ndarray`) - Required - Input labels vector.
- **classes** (`None`) - Optional - Must not be used, only here for backwards compatibility.

### Returns
- **output** (`AMFClassifier`) - Updated instance of `AMFClassifier`.
```

--------------------------------

### Visualize forest effect with AMFClassifier

Source: https://onelearn.readthedocs.io/en/latest/_sources/auto_examples/plot_forest_effect.rst.txt

This script initializes an AMFClassifier, trains it on a moons dataset, and plots the decision boundaries for individual trees alongside the aggregated forest decision boundary.

```python
import sys
import warnings

warnings.filterwarnings("ignore")

import logging
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons


sys.path.extend([".", ".."])
from onelearn import AMFClassifier
from experiments.plot import (
    plot_contour_binary_classif,
    plot_scatter_binary_classif,
    get_mesh,
)


logging.basicConfig(
    level=logging.INFO, format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
)


norm = plt.Normalize(vmin=0.0, vmax=1.0)
levels = 30


def plot_forest_effect(forest, dataset):
    n_estimators = forest.n_estimators
    _ = plt.figure(figsize=(2 * (n_estimators / 2 + 1), 4))

    X, y = dataset
    xx, yy, X_mesh = get_mesh(X)

    # Plot the training points
    ax = plt.subplot(2, n_estimators / 2 + 1, 1)
    plot_scatter_binary_classif(ax, xx, yy, X, y, title="Input data")

    forest.partial_fit(X, y)

    for idx_tree in range(n_estimators):
        ax = plt.subplot(2, n_estimators / 2 + 1, idx_tree + 2)
        Z = forest.predict_proba_tree(X_mesh, idx_tree)[:, 1].reshape(xx.shape)
        plot_contour_binary_classif(
            ax, xx, yy, Z, title="Tree #%d" % (idx_tree + 1), norm=norm, levels=levels
        )

    ax = plt.subplot(2, n_estimators / 2 + 1, n_estimators + 2)
    Z = forest.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
    plot_contour_binary_classif(ax, xx, yy, Z, title="Forest", norm=norm, levels=levels)
    plt.tight_layout()


n_samples = 100
n_features = 2
n_classes = 2
random_state = 42
dataset = make_moons(n_samples=n_samples, noise=0.15, random_state=random_state)

n_estimators = 10
amf = AMFClassifier(
    n_classes=n_classes,
    n_estimators=n_estimators,
    random_state=random_state,
    use_aggregation=True,
    split_pure=True,
)

logging.info("Building the graph...")
plot_forest_effect(amf, dataset)

plt.savefig("forest_effect.pdf")
logging.info("Saved the forest effect plot in forest_effect.pdf")
```

--------------------------------

### Visualize AMFRegressor weighted depths

Source: https://onelearn.readthedocs.io/en/latest/_sources/auto_examples/plot_signals_weighted_depth.rst.txt

This script trains an AMFRegressor on various 1D signals and plots the resulting predictions and weighted depths.

```python
import sys
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.cm import get_cmap
import logging

sys.path.extend([".", ".."])

from onelearn import AMFRegressor
from onelearn.datasets import get_signal, make_regression

logging.basicConfig(
    level=logging.INFO, format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
)

colormap = get_cmap("tab20")

n_samples_train = 5000
n_samples_test = 1000
random_state = 42


noise = 0.03
use_aggregation = True
split_pure = True
n_estimators = 100
step = 10.0


signals = ["heavisine", "bumps", "blocks", "doppler"]


def plot_weighted_depth(signal):
    X_train, y_train = make_regression(
        n_samples=n_samples_train, signal=signal, noise=noise, random_state=random_state
    )
    X_test = np.linspace(0, 1, num=n_samples_test)

    amf = AMFRegressor(
        random_state=random_state,
        use_aggregation=use_aggregation,
        n_estimators=n_estimators,
        split_pure=split_pure,
        step=step,
    )

    amf.partial_fit(X_train.reshape(n_samples_train, 1), y_train)
    y_pred = amf.predict(X_test.reshape(n_samples_test, 1))
    weighted_depths = amf.weighted_depth(X_test.reshape(n_samples_test, 1))

    fig, (ax1, ax2, ax3) = plt.subplots(nrows=3, ncols=1, sharex=True, figsize=(6, 5))

    plot_samples = ax1.plot(
        X_train, y_train, color=colormap.colors[1], lw=2, label="Samples"
    )[0]
    plot_signal = ax1.plot(
        X_test,
        get_signal(X_test, signal),
        lw=2,
        color=colormap.colors[0],
        label="Signal",
    )[0]
    plot_prediction = ax2.plot(
        X_test.ravel(), y_pred, lw=2, color=colormap.colors[2], label="Prediction"
    )[0]
    ax3.plot(
        X_test,
        weighted_depths[:, 1:],
        lw=1,
        color=colormap.colors[5],
        alpha=0.2,
        label="Weighted depths",
    )
    plot_weighted_depths = ax3.plot(
        X_test, weighted_depths[:, 0], lw=1, color=colormap.colors[5], alpha=0.2
    )[0]

    plot_mean_weighted_depths = ax3.plot(
        X_test,
        weighted_depths.mean(axis=1),
        lw=2,
        color=colormap.colors[4],
        label="Mean weighted depth",
    )[0]
    filename = "weighted_depths_%s.pdf" % signal
    fig.subplots_adjust(hspace=0.1)
    fig.legend(
        (
            plot_signal,
            plot_samples,
            plot_mean_weighted_depths,
            plot_weighted_depths,
            plot_prediction,
        ),
        (
            "Signal",
            "Samples",
            "Average weighted depths",
            "Weighted depths",
            "Prediction",
        ),
        fontsize=12,
        loc="upper center",
        bbox_to_anchor=(0.5, 1.0),
        ncol=3,
    )
    plt.savefig(filename)
    logging.info("Saved the decision functions in '%s'" % filename)


for signal in signals:
    plot_weighted_depth(signal)
```

--------------------------------

### Logo generation script

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_logo.html

The Python script used to simulate data, train the AMFClassifier incrementally, and save the resulting visualization as logo.png.

```python
import sys
import logging
import matplotlib.pyplot as plt
from tqdm import trange
from sklearn.datasets import make_moons
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split

sys.path.extend([".", ".."])
from onelearn import AMFClassifier
from experiments.plot import (
    get_mesh,
    plot_contour_binary_classif,
    plot_scatter_binary_classif,
)

logging.basicConfig(
    format="%(asctime)s %(message)s", datefmt="%Y/%m/%d %H:%M:%S", level=logging.INFO
)

n_samples = 100
n_features = 2
n_classes = 2
random_state = 123
save_iterations = [5, 10, 30, 70]

logging.info("Simulation of the data")
X, y = make_moons(n_samples=n_samples, noise=0.25, random_state=random_state)

logging.info("Train/Test splitting")
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.5, random_state=random_state
)

logging.info("Computation of the meshgrid")
xx, yy, X_mesh = get_mesh(X)


clf = AMFClassifier(
    n_classes=n_classes,
    n_estimators=100,
    random_state=random_state,
    split_pure=True,
    use_aggregation=True,
)

n_plots = len(save_iterations)
n_fig = 0
save_iterations = [0, *save_iterations]

plt.figure(figsize=(3, 3))

logging.info("Launching iterations")
bar = trange(n_plots, desc="Plotting iterations", leave=True)

norm = plt.Normalize(vmin=0.0, vmax=1.0)

for start, end in zip(save_iterations[:-1], save_iterations[1:]):
    X_iter = X_train[start:end]
    y_iter = y_train[start:end]
    clf.partial_fit(X_iter, y_iter)
    n_fig += 1
    Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
    ax = plt.subplot(2, 2, n_fig)
    score = roc_auc_score(y_test, clf.predict_proba(X_test)[:, 1])
    plot_contour_binary_classif(ax, xx, yy, Z, levels=5, norm=norm)

    plot_scatter_binary_classif(
        ax, xx, yy, X_train[:end], y_train[:end], s=15, norm=norm
    )
    bar.update(1)

bar.close()
plt.subplots_adjust(wspace=0, hspace=0)
plt.savefig("logo.png", transparent=True)
logging.info("Saved logo in file logo.png")
```

--------------------------------

### Forest effect output logs

Source: https://onelearn.readthedocs.io/en/latest/_sources/auto_examples/plot_forest_effect.rst.txt

The console output generated during the execution of the forest effect visualization script.

```none
2020-04-30 21:08:19 Building the graph...
2020-04-30 21:08:28 Saved the forest effect plot in forest_effect.pdf
```

--------------------------------

### Compare decision functions of random forest classifiers

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_decisions.html

This script compares the decision functions of AMF, MF, RF, and ET classifiers on three synthetic datasets. It uses helper functions from the experiments module to plot decision contours and scatter plots. The script saves the resulting figure as 'decisions.pdf'.

```python
import sys
import numpy as np
import matplotlib.pyplot as plt
import logging
from sklearn.preprocessing import MinMaxScaler
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier
from sklearn.datasets import make_moons, make_classification, make_circles
from sklearn.model_selection import train_test_split
from skgarden import MondrianForestClassifier


sys.path.extend([".", ".."])
from onelearn import AMFClassifier
from experiments import (
    get_mesh,
    plot_contour_binary_classif,
    plot_scatter_binary_classif,
)

logging.basicConfig(
    level=logging.INFO, format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
)

np.set_printoptions(precision=2)

n_samples = 1000
random_state = 42
h = 0.01
levels = 20

use_aggregation = True
split_pure = True
n_estimators = 100
step = 1.0
dirichlet = 0.5

norm = plt.Normalize(vmin=0.0, vmax=1.0)


def simulate_data(dataset="moons"):
    if dataset == "moons":
        X, y = make_moons(n_samples=n_samples, noise=0.2, random_state=random_state)
    elif dataset == "circles":
        X, y = make_circles(
            n_samples=n_samples, noise=0.1, factor=0.5, random_state=random_state
        )
    elif dataset == "linear":
        X, y = make_classification(
            n_samples=n_samples,
            n_features=2,
            n_redundant=0,
            n_informative=2,
            random_state=random_state,
            n_clusters_per_class=1,
            flip_y=0.001,
            class_sep=2.0,
        )
        rng = np.random.RandomState(random_state)
        X += 2 * rng.uniform(size=X.shape)
    else:
        X, y = make_moons(n_samples=n_samples, noise=0.2, random_state=random_state)
    X = MinMaxScaler().fit_transform(X)
    return X, y


datasets = [simulate_data("moons"), simulate_data("circles"), simulate_data("linear")]

n_classifiers = 5
n_datasets = 3
_ = plt.figure(figsize=(2 * (n_classifiers + 1), 2 * n_datasets))


def get_classifiers():
    return [
        (
            "AMF",
            AMFClassifier(
                n_classes=2,
                n_estimators=n_estimators,
                random_state=random_state,
                use_aggregation=True,
                split_pure=True,
            ),
        ),
        (
            "AMF(no agg)",
            AMFClassifier(
                n_classes=2,
                n_estimators=n_estimators,
                random_state=random_state,
                use_aggregation=False,
                split_pure=True,
            ),
        ),
        (
            "MF",
            MondrianForestClassifier(
                n_estimators=n_estimators, random_state=random_state
            ),
        ),
        (
            "RF",
            RandomForestClassifier(
                n_estimators=n_estimators, random_state=random_state
            ),
        ),
        (
            "ET",
            ExtraTreesClassifier(n_estimators=n_estimators, random_state=random_state),
        ),
    ]


i = 1

for ds_cnt, ds in enumerate(datasets):
    X, y = ds
    xx, yy, X_mesh = get_mesh(X, h=h, padding=0.2)
    ax = plt.subplot(n_datasets, n_classifiers + 1, i)
    if ds_cnt == 0:
        title = "Input data"
    else:
        title = None

    plot_scatter_binary_classif(ax, xx, yy, X, y, s=10, title=title)
    i += 1
    classifiers = get_classifiers()
    for name, clf in classifiers:
        ax = plt.subplot(n_datasets, n_classifiers + 1, i)
        if hasattr(clf, "clear"):
            clf.clear()
        if hasattr(clf, "partial_fit"):
            clf.partial_fit(X, y)
        else:
            clf.fit(X, y)

        Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
        if ds_cnt == 0:
            plot_contour_binary_classif(
                ax, xx, yy, Z, levels=levels, title=name, norm=norm
            )
        else:
            plot_contour_binary_classif(ax, xx, yy, Z, levels=levels, norm=norm)
        i += 1

plt.tight_layout()
plt.savefig("decisions.pdf")
logging.info("Saved the decision functions in 'decision.pdf")

```

--------------------------------

### Logo generation output

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_logo.html

The console output showing the progress of the plotting iterations during the logo generation process.

```text
Plotting iterations:   0%|          | 0/4 [00:00<?, ?it/s]
Plotting iterations:  25%|##5       | 1/4 [00:02<00:06,  2.04s/it]
Plotting iterations:  50%|#####     | 2/4 [00:04<00:04,  2.11s/it]
Plotting iterations:  75%|#######5  | 3/4 [00:07<00:02,  2.31s/it]
Plotting iterations: 100%|##########| 4/4 [00:09<00:00,  2.42s/it]
Plotting iterations: 100%|##########| 4/4 [00:09<00:00,  2.44s/it]
```

--------------------------------

### AMFClassifier iteration progress output

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_iterations.html

The console output showing the progress bar during the training iterations.

```text
Plotting iterations:   0%|          | 0/6 [00:00<?, ?it/s]
Plotting iterations:  17%|#6        | 1/6 [00:01<00:09,  1.83s/it]
Plotting iterations:  33%|###3      | 2/6 [00:03<00:07,  1.90s/it]
Plotting iterations:  50%|#####     | 3/6 [00:06<00:06,  2.02s/it]
Plotting iterations:  67%|######6   | 4/6 [00:08<00:04,  2.22s/it]
Plotting iterations:  83%|########3 | 5/6 [00:11<00:02,  2.46s/it]
Plotting iterations: 100%|##########| 6/6 [00:15<00:00,  2.72s/it]
Plotting iterations: 100%|##########| 6/6 [00:15<00:00,  2.54s/it]
```

--------------------------------

### partial_fit_helper(X, y)

Source: https://onelearn.readthedocs.io/en/latest/generated/onelearn.AMFClassifier.html

Updates the classifier with a batch of samples. This is a helper method for partial_fit.

```APIDOC
## partial_fit_helper(X, y)

### Description
Updates the classifier with the given batch of samples.

### Parameters
- **X** (`np.ndarray`, shape=(n_samples, n_features)) - Required - Input features matrix.
- **y** (`np.ndarray`) - Required - Input labels vector.

### Returns
- **output** (`AMFClassifier`) - Updated instance of `AMFClassifier`.
```

--------------------------------

### Plot forest effect with AMFClassifier

Source: https://onelearn.readthedocs.io/en/latest/auto_examples/plot_forest_effect.html

Builds an AMFClassifier with 10 trees, fits it on a two-moons dataset, and plots the decision function of each tree and the forest. The plot is saved to forest_effect.pdf. The script logs progress and suppresses warnings.

```python
import sys
import warnings

warnings.filterwarnings("ignore")

import logging
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons


sys.path.extend([".", ".."])
from onelearn import AMFClassifier
from experiments.plot import (
    plot_contour_binary_classif,
    plot_scatter_binary_classif,
    get_mesh,
)


logging.basicConfig(
    level=logging.INFO, format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
)


norm = plt.Normalize(vmin=0.0, vmax=1.0)
levels = 30


def plot_forest_effect(forest, dataset):
    n_estimators = forest.n_estimators
    _ = plt.figure(figsize=(2 * (n_estimators / 2 + 1), 4))

    X, y = dataset
    xx, yy, X_mesh = get_mesh(X)

    # Plot the training points
    ax = plt.subplot(2, n_estimators / 2 + 1, 1)
    plot_scatter_binary_classif(ax, xx, yy, X, y, title="Input data")

    forest.partial_fit(X, y)

    for idx_tree in range(n_estimators):
        ax = plt.subplot(2, n_estimators / 2 + 1, idx_tree + 2)
        Z = forest.predict_proba_tree(X_mesh, idx_tree)[:, 1].reshape(xx.shape)
        plot_contour_binary_classif(
            ax, xx, yy, Z, title="Tree #%d" % (idx_tree + 1), norm=norm, levels=levels
        )

    ax = plt.subplot(2, n_estimators / 2 + 1, n_estimators + 2)
    Z = forest.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
    plot_contour_binary_classif(ax, xx, yy, Z, title="Forest", norm=norm, levels=levels)
    plt.tight_layout()


n_samples = 100
n_features = 2
n_classes = 2
random_state = 42
dataset = make_moons(n_samples=n_samples, noise=0.15, random_state=random_state)

n_estimators = 10
amf = AMFClassifier(
    n_classes=n_classes,
    n_estimators=n_estimators,
    random_state=random_state,
    use_aggregation=True,
    split_pure=True,
)

logging.info("Building the graph...")
plot_forest_effect(amf, dataset)

plt.savefig("forest_effect.pdf")
logging.info("Saved the forest effect plot in forest_effect.pdf")

```

--------------------------------

### AMFClassifier.partial_fit_helper

Source: https://onelearn.readthedocs.io/en/latest/_sources/generated/onelearn.AMFClassifier.rst.txt

Helper method for partial_fit.

```APIDOC
## AMFClassifier.partial_fit_helper

### Description
Helper method for partial_fit.

### Method
Method

### Signature
`partial_fit_helper(self, X, y, classes)`

### Parameters
- **X** (array-like) - Required - Training samples.
- **y** (array-like) - Required - Target values.
- **classes** (array-like) - Required - List of all classes.

### Returns
- **self** (AMFClassifier) - The fitted classifier.

```

--------------------------------

### AMFClassifier.weighted_depth_helper

Source: https://onelearn.readthedocs.io/en/latest/_sources/generated/onelearn.AMFClassifier.rst.txt

Helper method for computing weighted depth.

```APIDOC
## AMFClassifier.weighted_depth_helper

### Description
Helper method for computing weighted depth.

### Method
Method

### Signature
`weighted_depth_helper(self, ...)`

### Parameters
No parameters are explicitly documented in the source.

### Returns
- **depth** (float) - Weighted depth value.

```

--------------------------------

### Use AMFClassifier with partial_fit for online learning

Source: https://onelearn.readthedocs.io/en/latest/_sources/index.rst.txt

Shows the basic usage of onelearn's AMFClassifier following the scikit-learn API. Call partial_fit instead of fit each time new data is available, then use predict_proba or predict for predictions. The algorithm updates its decision function with each partial_fit call.

```python
from onelearn import AMFClassifier

amf = AMFClassifier(n_classes=2)
clf.partial_fit(X_train, y_train)
y_pred = clf.predict_proba(X_test)[:, 1]
```

--------------------------------

### BibTeX citation for AMF paper

Source: https://onelearn.readthedocs.io/en/latest/_sources/experiments.rst.txt

BibTeX entry for the paper 'AMF: Aggregated Mondrian Forests for Online Learning' by Mourtada, Gaiffas, and Scornet (2019).

```bibtex
@article{mourtada2019amf,
  title={AMF: Aggregated Mondrian Forests for Online Learning},
  author={Mourtada, Jaouad and Ga{\"i}ffas, St{\'e}phane and Scornet, Erwan},
  journal={arXiv preprint arXiv:1906.10529},
  year={2019}
}
```

--------------------------------

### AMFClassifier.partial_fit

Source: https://onelearn.readthedocs.io/en/latest/_sources/generated/onelearn.AMFClassifier.rst.txt

Incrementally trains the classifier on a batch of samples.

```APIDOC
## AMFClassifier.partial_fit

### Description
Incrementally trains the classifier on a batch of samples.

### Method
Method

### Signature
`partial_fit(self, X, y, classes=None)`

### Parameters
- **X** (array-like) - Required - Training samples.
- **y** (array-like) - Required - Target values.
- **classes** (array-like, optional) - Optional - List of all classes.

### Returns
- **self** (AMFClassifier) - The fitted classifier.

```

--------------------------------

### AMFClassifier.predict_helper

Source: https://onelearn.readthedocs.io/en/latest/_sources/generated/onelearn.AMFClassifier.rst.txt

Helper method for prediction.

```APIDOC
## AMFClassifier.predict_helper

### Description
Helper method for prediction.

### Method
Method

### Signature
`predict_helper(self, X)`

### Parameters
- **X** (array-like) - Required - Samples to predict.

### Returns
- **predictions** (array-like) - Predicted class labels.

```

--------------------------------

### predict_helper(X)

Source: https://onelearn.readthedocs.io/en/latest/generated/onelearn.AMFClassifier.html

Helper method for predictions. Used internally by predict and predict_proba methods.

```APIDOC
## predict_helper(X)

### Description
Helper method for the predictions of the given features vectors. This is used in the `predict` and `predict_proba` methods of `AMFRegressor` and `AMFClassifier`.

### Parameters
- **X** (`np.ndarray`, shape=(n_samples, n_features)) - Required - Input features matrix to predict for.

### Returns
- **output** (`np.ndarray`) - Returns the predictions for the input features.
```

--------------------------------

### Plot and save decision boundaries

Source: https://onelearn.readthedocs.io/en/latest/_sources/auto_examples/plot_decisions.rst.txt

Uses predict_proba to generate contour plots for binary classification and saves the result to a PDF file.

```python
            Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
            if ds_cnt == 0:
                plot_contour_binary_classif(
                    ax, xx, yy, Z, levels=levels, title=name, norm=norm
                )
            else:
                plot_contour_binary_classif(ax, xx, yy, Z, levels=levels, norm=norm)
            i += 1

    plt.tight_layout()
    plt.savefig("decisions.pdf")
    logging.info("Saved the decision functions in 'decision.pdf")
```

--------------------------------

### OnlineDummyClassifier.partial_fit

Source: https://onelearn.readthedocs.io/en/latest/_sources/generated/onelearn.OnlineDummyClassifier.rst.txt

Incrementally fits the model on a batch of samples.

```APIDOC
## OnlineDummyClassifier.partial_fit

### Description
Incrementally fits the model on a batch of samples.

### Method
partial_fit

### Parameters
No parameters documented.

### Returns
No return value documented.
```

--------------------------------

### predict_proba_tree(X, tree)

Source: https://onelearn.readthedocs.io/en/latest/generated/onelearn.AMFClassifier.html

Predicts class probabilities using a single tree. Intended for debugging or visualization.

```APIDOC
## predict_proba_tree(X, tree)

### Description
Predicts the class probabilities for the given features vectors using a single tree at given index `tree`. Should be used only for debugging or visualisation purposes.

### Parameters
- **X** (`np.ndarray`, shape=(n_samples, n_features)) - Required - Input features matrix to predict for.
- **tree** (`int`) - Required - Index of the tree, must be between 0 and `n_estimators` - 1.

### Returns
- **output** (`np.ndarray`, shape=(n_samples, n_classes)) - Returns the predicted class probabilities for the input features.
```

--------------------------------

### Plot iterations of AMFClassifier

Source: https://onelearn.readthedocs.io/en/latest/_sources/auto_examples/plot_iterations.rst.txt

Full script that trains an AMFClassifier incrementally on batches of the moons dataset and plots the decision function and AUC score at specified iteration steps. It uses make_moons, train_test_split, and custom plotting functions from the experiments module. The script logs progress and saves the resulting figure to 'iterations.pdf'.

```python
import sys
import logging
import matplotlib.pyplot as plt
from tqdm import trange
from sklearn.datasets import make_moons
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split

sys.path.extend([".", ".."])
from onelearn import AMFClassifier
from experiments.plot import (
    get_mesh,
    plot_contour_binary_classif,
    plot_scatter_binary_classif,
)

logging.basicConfig(
    format="%(asctime)s %(message)s", datefmt="%Y/%m/%d %H:%M:%S", level=logging.INFO
)

norm = plt.Normalize(vmin=0.0, vmax=1.0)

n_samples = 400
n_features = 2
n_classes = 2
seed = 123
random_state = 42
levels = 30

save_iterations = [5, 10, 20, 50, 100, 200]
output_filename = "iterations.pdf"

logging.info("Simulation of the data")
X, y = make_moons(n_samples=n_samples, noise=0.2, random_state=random_state)

logging.info("Train/Test splitting")
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.5, random_state=random_state
)

logging.info("Computation of the meshgrid")
xx, yy, X_mesh = get_mesh(X)


clf = AMFClassifier(
    n_classes=n_classes,
    n_estimators=100,
    random_state=random_state,
    split_pure=True,
    use_aggregation=True,
)


n_plots = len(save_iterations)
n_fig = 0
save_iterations = [0, *save_iterations]

fig, axes = plt.subplots(nrows=2, ncols=n_plots, figsize=(3 * n_plots, 6))

logging.info("Launching iterations")
bar = trange(n_plots, desc="Plotting iterations", leave=True)


for start, end in zip(save_iterations[:-1], save_iterations[1:]):
    X_iter = X_train[start:end]
    y_iter = y_train[start:end]
    clf.partial_fit(X_iter, y_iter)

    ax = axes[0, n_fig]
    plot_scatter_binary_classif(
        ax,
        xx,
        yy,
        X_train[:end],
        y_train[:end],
        s=50,
        title="t = %d" % end,
        fontsize=20,
        noaxes=False,
    )

    Z = clf.predict_proba(X_mesh)[:, 1].reshape(xx.shape)
    score = roc_auc_score(y_test, clf.predict_proba(X_test)[:, 1])
    ax = axes[1, n_fig]
    plot_contour_binary_classif(ax, xx, yy, Z, score=score, levels=levels, norm=norm)
    n_fig += 1
    bar.update(1)

bar.close()

plt.tight_layout()
plt.savefig(output_filename)
logging.info("Saved result in file %s" % output_filename)
```

--------------------------------

### OnlineDummyClassifier.predict

Source: https://onelearn.readthedocs.io/en/latest/_sources/generated/onelearn.OnlineDummyClassifier.rst.txt

Predicts class labels for input samples.

```APIDOC
## OnlineDummyClassifier.predict

### Description
Predicts class labels for input samples.

### Method
predict

### Parameters
No parameters documented.

### Returns
No return value documented.
```