Repository: scikit-activeml/scikit-activeml (language: python)

Issue:
DOC: Text Classification Tutorial
### Describe the issue linked to the documentation

Add an example text classification and annotation tutorial

### Suggest a potential alternative/fix

_No response_


Discussion / hints:

Fix patch:
diff --git a/tutorials/06_pool_al_text_annotation_tool.ipynb b/tutorials/06_pool_al_text_annotation_tool.ipynb
new file mode 100644
index 00000000..f8046c7e
--- /dev/null
+++ b/tutorials/06_pool_al_text_annotation_tool.ipynb
@@ -0,0 +1,2017 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Paper Annotation Tool using Text Embeddings"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "> **_Google Colab Note:_** If the notebook fails to run after installing the needed packages, try to restart the runtime (Ctrl + M) under Runtime -> Restart session.\n",
+        "\n",
+        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](<colab_link>)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "**Notebook Dependencies**\n",
+        "\n",
+        "Uncomment the following cell to install all dependencies for this tutorial."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "x0BxO18zdzwn",
+        "outputId": "4f496be3-ebed-450a-898d-0dac9fcd6542"
+      },
+      "outputs": [],
+      "source": [
+        "# !pip install scikit-activeml datasets jupyter_ui_poll"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "<hr style=\"border-style: solid; border-top: 1px solid; border-right: 0; border-bottom: 0; border-left: 0;\">"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "This notebook showcases an example annotation tool to classify arXiv papers. The overall task is to classify arXiv paper into machine learning papers (cs.AI, cs.LG, cs.CV) and non-machine learning papers (cs.LO, cs.NI, cs.CR, cs.PL) which are class 1 and 0, respectively. We use `ipywidgets` to create the interface, such that users can annotate samples directly within the notebook. The dataset is a subset of the `subset_arxiv_papers_with_embeddings` dataset on [huggingface](https://huggingface.co/datasets/MongoDB/subset_arxiv_papers_with_embeddings) from MongoDB which already provides precomputed embeddings.\n",
+        "\n",
+        "> **_NOTE:_** For testing execute this notebook on your local machine or click the Open in Google Colab button above."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "Ql6c7wbfbKlQ"
+      },
+      "outputs": [],
+      "source": [
+        "import datasets\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import ipywidgets as widgets\n",
+        "import time\n",
+        "import textwrap\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from IPython.display import display\n",
+        "from jupyter_ui_poll import ui_events"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Dataset\n",
+        "\n",
+        "First, we have to create our dataset, which we want to annotate. The papers are filtered according to their assigned category. To simplify the task, we exclude all papers that would belong to both classes. Based on the filtered papers, we subsample a balanced dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 287,
+          "referenced_widgets": [
+            "3d2e823b26764a4bb6ee1263f7540a6e",
+            "31f2cb542c234a73a458598f858ab0ea",
+            "6c70d082e69f4fd7b2ab2664d7a5c4fa",
+            "449cfe6c623148cc90e910d16f7e2e16",
+            "12b59f932c5e4e0f91d734d2734d3ad9",
+            "bdc26182b0604220ba7fcdd12aa4b60d",
+            "ab997738bb014abe9700b6762ec5fc17",
+            "54c0a9cd436e463b954e203db622af89",
+            "d9f7f53be39541f7b2af655c23681b6d",
+            "8c29c360c6bb46b5ad55743720912291",
+            "573e0c84a3da42fba62f95ed2ccb91c1",
+            "dac9ea749aea48888bdb11ce4d0b7e44",
+            "019b66f303204a24b9d57ab5faef6b0d",
+            "f3ee69a2b91d4fa384f557763650f133",
+            "fb015057e08c4e5fae36392280603e5b",
+            "e65cec7450b34bd1a756e46fe37afc84",
+            "0b034663c2bf493d9284be73aede4c9c",
+            "94cc5882db984867b4af2dd13bf28dcf",
+            "4f483afd17aa4368943f7fbd0ddeba4c",
+            "6c41b494477240e5947089e103cfc53d",
+            "9b9c5c95ebf746d5a1e5f06d96cd3e79",
+            "a8a848800f1b4f709d594ac0a688d013",
+            "0a9344cc59704f5ebf2c77e76d56dbdc",
+            "b08d232560564081b9ab172504a3d6e7",
+            "02e1c7b2c33d44c79217d724dbc2fa10",
+            "018c2704c5af48cbbf83c2c28469c742",
+            "c8aff5b9febf427793a3b682caa01af6",
+            "aed6ac245cc54f649dfadd00cda606c3",
+            "9f64d642d04e46bc9db94fc2992c1093",
+            "39145780dab04311b1989e8b9e4053e0",
+            "7ab12a559474405cb1e29bab8ec4a02e",
+            "bb0948b78eaa479fbefe3cf988f6ea1d",
+            "519d9823101a43fcb3373c9340691da2"
+          ]
+        },
+        "id": "xzX5L32Vdt_R",
+        "outputId": "5c065963-10c9-43ff-849b-dde7472d390e"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Repo card metadata block was not found. Setting CardData to empty.\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "c0: 267\n",
+            "c1: 267\n"
+          ]
+        }
+      ],
+      "source": [
+        "random_state = np.random.RandomState(0)\n",
+        "\n",
+        "\n",
+        "# functions to check if the provided category is indicative of class 0 or 1\n",
+        "def is_c0_category(category):\n",
+        "    return category in [\"cs.LO\", \"cs.NI\", \"cs.CR\", \"cs.PL\"]\n",
+        "\n",
+        "\n",
+        "def is_c1_category(category):\n",
+        "    return category in [\"cs.AI\", \"cs.LG\", \"cs.CV\"]\n",
+        "\n",
+        "\n",
+        "# check if one of the assigned category of a paper is assigned to a class\n",
+        "def is_valid_paper(category_field, category_fn):\n",
+        "    categories = category_field.split()\n",
+        "    valid_category = [category_fn(c) for c in categories]\n",
+        "    return any(valid_category)\n",
+        "\n",
+        "\n",
+        "# download dataset from huggingface\n",
+        "cache_dir = \"huggingface_cache/datasets/\"\n",
+        "arxiv = datasets.load_dataset(\n",
+        "    \"MongoDB/subset_arxiv_papers_with_embeddings\", cache_dir=cache_dir\n",
+        ")\n",
+        "\n",
+        "# filter papers according to their categories\n",
+        "is_c1 = np.array(\n",
+        "    [is_valid_paper(c, is_c1_category) for c in arxiv[\"train\"][\"categories\"]]\n",
+        ")\n",
+        "is_c0 = np.array(\n",
+        "    [is_valid_paper(c, is_c0_category) for c in arxiv[\"train\"][\"categories\"]]\n",
+        ")\n",
+        "\n",
+        "# exclude paper that belong to both classes\n",
+        "is_exclusive_c1 = np.logical_and(is_c1, ~is_c0)\n",
+        "is_exclusive_c0 = np.logical_and(is_c0, ~is_c1)\n",
+        "\n",
+        "# calculate maximum subset size per class\n",
+        "subset_size = min(np.sum(is_exclusive_c0), np.sum(is_exclusive_c1))\n",
+        "\n",
+        "# draw subset per class\n",
+        "is_exclusive_c1_subset = random_state.choice(\n",
+        "    np.where(is_exclusive_c1)[0], subset_size, replace=False\n",
+        ")\n",
+        "is_exclusive_c0_subset = random_state.choice(\n",
+        "    np.where(is_exclusive_c0)[0], subset_size, replace=False\n",
+        ")\n",
+        "\n",
+        "# get embeddings for subsets\n",
+        "c1_embeddings = np.array(arxiv[\"train\"][\"embedding\"])[is_exclusive_c1_subset]\n",
+        "c0_embeddings = np.array(arxiv[\"train\"][\"embedding\"])[is_exclusive_c0_subset]\n",
+        "print(f\"c0: {len(c0_embeddings)}\")\n",
+        "print(f\"c1: {len(c1_embeddings)}\")\n",
+        "\n",
+        "# create dataset as needed for scikit-activeml and the annotation tool\n",
+        "X_indices = np.concatenate(\n",
+        "    [is_exclusive_c0_subset, is_exclusive_c1_subset], dtype=int\n",
+        ")\n",
+        "X_embeddings = np.concatenate([c0_embeddings, c1_embeddings])\n",
+        "y = np.array([0] * len(c0_embeddings) + [1] * len(c1_embeddings), dtype=float)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## User Interface\n",
+        "\n",
+        "We need to define the user interface, such that the notebook can interact with the user. We use `ipywidgets` to create the shown widgets and `jupyter_ui_poll` to handle the polling for the events. The user interface iteratively presents a single sample for which the user can press a button to indicate to which class this sample belongs to. We also offer an additional button that always classifies the shown sample correctly. An output widget is updated after every annotation and shows the current performance of the trained classifier (with user annotations and ideal annotations). We also show the learning curve which shows the performance over time.\n",
+        "\n",
+        "The `process_batch_annotation_UI` function offers two boolean flags to customize the user interface. If `show_correct_class` is set to `True`, the user interface also shows what the real class of the sample is. If `skip_interaction` is set to `True`, samples are annotated with the real class automatically. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "EAmWZGs2n5F3"
+      },
+      "outputs": [],
+      "source": [
+        "# this function removes whitespace and wraps the text again so it fits into the annotation tool\n",
+        "def normalize_text(text):\n",
+        "    text_lines = text.replace(\"\\t\", \" \").replace(\"\\n\", \" \").strip().split()\n",
+        "    text_single_line = \" \".join(text_lines)\n",
+        "    wrapped_text = textwrap.fill(text_single_line, width=70)\n",
+        "    return wrapped_text\n",
+        "\n",
+        "# this function blocks the execution to wait for button presses\n",
+        "def wait_for_interaction():\n",
+        "    global button_pressed\n",
+        "    with ui_events() as poll:\n",
+        "        poll(1000)\n",
+        "        while not button_pressed:\n",
+        "            poll(10)\n",
+        "            time.sleep(0.01)\n",
+        "\n",
+        "# a button callback used to save the annotation\n",
+        "def button_clicked(i, arg):\n",
+        "    global button_pressed\n",
+        "    global results\n",
+        "    if not button_pressed:\n",
+        "        results.append(i)\n",
+        "        button_pressed = True\n",
+        "\n",
+        "# create buttons and connect the callbacks\n",
+        "button_c0 = widgets.Button(\n",
+        "    description=f\"Other\",\n",
+        "    tooltip=\"Paper belongs to cs.LO, cs.NI, cs.CR, cs.PL.\",\n",
+        ")\n",
+        "button_c0.on_click(lambda arg: button_clicked(0, arg))\n",
+        "button_c1 = widgets.Button(\n",
+        "    description=f\"Machine Learning\",\n",
+        "    tooltip=\"Paper belongs to cs.AI, cs.LG, or cs.CV.\",\n",
+        ")\n",
+        "button_c1.on_click(lambda arg: button_clicked(1, arg))\n",
+        "button_creal = widgets.Button(\n",
+        "    description=f\"Correct Class\",\n",
+        "    tooltip=\"Use this button to always annotate with the real class.\",\n",
+        ")\n",
+        "button_creal.on_click(lambda arg: button_clicked(-1, arg))\n",
+        "\n",
+        "# output to display the sample that should be annotated\n",
+        "output_sample = widgets.Output()\n",
+        "# output to show a summary of the performance and annotation\n",
+        "output_stats = widgets.Output()\n",
+        "# output to show learning curves\n",
+        "output_plot = widgets.Output()\n",
+        "\n",
+        "# create the layout for the annotation tool\n",
+        "buttons = widgets.VBox([button_c1, button_c0, button_creal])\n",
+        "buttons.layout.width = \"200px\"\n",
+        "\n",
+        "output_sample.layout.width = \"590px\"\n",
+        "\n",
+        "output_stats.layout.height = \"450px\"\n",
+        "output_stats.layout.width = \"250px\"\n",
+        "\n",
+        "output_plot.layout.height = \"450px\"\n",
+        "output_plot.layout.width = \"540px\"\n",
+        "\n",
+        "stats_box = widgets.HBox([output_stats, output_plot])\n",
+        "sample_box = widgets.HBox([buttons, output_sample])\n",
+        "output_box = widgets.VBox([stats_box, sample_box])\n",
+        "\n",
+        "\n",
+        "# this function processes handles the updates for the annotation tool\n",
+        "def process_batch_annotation_UI(\n",
+        "    cycle,\n",
+        "    learning_curve,\n",
+        "    learning_curve_ideal,\n",
+        "    query_indices,\n",
+        "    X_indices_train,\n",
+        "    y_train_true,\n",
+        "    num_annot_errors,\n",
+        "    num_total_annot,\n",
+        "    batch_size,\n",
+        "    # set this flag to True to additionally show the real class\n",
+        "    show_correct_class=False,\n",
+        "    # set this flag if the presented papers should be annotated automatically\n",
+        "    skip_interaction=False,\n",
+        "):\n",
+        "    # initialize global variables that are used by the callbacks\n",
+        "    global button_pressed\n",
+        "    global results\n",
+        "    button_pressed = False\n",
+        "    results = []\n",
+        "    # draw plot\n",
+        "    with output_plot:\n",
+        "        fig, ax = plt.subplots(figsize=(6, 4))\n",
+        "        ax.set_xlabel(\"Cycle\")\n",
+        "        ax.set_ylabel(\"Accuracy\")\n",
+        "        ax.plot(learning_curve, label=\"with annotated labels\")\n",
+        "        ax.plot(learning_curve_ideal, label=\"with ideally annotated labels\")\n",
+        "        ax.set_xlim(0, len(X_indices_train) // batch_size)\n",
+        "        ax.legend(loc=\"upper center\", bbox_to_anchor=(0.5, -0.175), ncol=2)\n",
+        "        output_plot.clear_output(wait=True)\n",
+        "        display(fig)\n",
+        "        plt.close(fig)\n",
+        "\n",
+        "    # update the stats text\n",
+        "        with output_stats:\n",
+        "            output_stats.clear_output(wait=True)\n",
+        "            print(f\"Cycle: {cycle}\")\n",
+        "            print(f\"Accuracy:          {learning_curve[-1]:.3f}\")\n",
+        "            print(f\"Accuracy (ideal):  {learning_curve_ideal[-1]:.3f}\")\n",
+        "            print(f\"AULC:              {np.mean(learning_curve):.3f}\")\n",
+        "            print(f\"AULC (ideal):      {np.mean(learning_curve_ideal):.3f}\")\n",
+        "            print(f\"Annotation errors: {num_annot_errors}/{num_total_annot}\")\n",
+        "\n",
+        "    # iterate over all queried instances and process buttons and update outputs\n",
+        "    # after each annotations\n",
+        "    for batch_index, query_index in enumerate(query_indices):\n",
+        "        # reset button_pressed variable, such that waiting for button presses\n",
+        "        # works\n",
+        "        button_pressed = False\n",
+        "        # only do loop once if skip_interaction is True\n",
+        "        if skip_interaction and batch_index > 0:\n",
+        "            break\n",
+        "        # update the sample text which should be annotated\n",
+        "        with output_sample:\n",
+        "            output_sample.clear_output(wait=True)\n",
+        "            title = normalize_text(\n",
+        "                arxiv[\"train\"][int(X_indices_train[int(query_index)])][\"title\"]\n",
+        "            )\n",
+        "            abstract = normalize_text(\n",
+        "                arxiv[\"train\"][int(X_indices_train[int(query_index)])][\n",
+        "                    \"abstract\"\n",
+        "                ]\n",
+        "            )\n",
+        "            print(f\"Batch index: {batch_index}/{batch_size}\")\n",
+        "            if show_correct_class:\n",
+        "                correct_class_str = (\n",
+        "                    \"Machine Learning\"\n",
+        "                    if y_train_true[query_index] > 0\n",
+        "                    else \"Other\"\n",
+        "                )\n",
+        "                print(f\"Correct class: {correct_class_str}\")\n",
+        "            print(\"Title:\")\n",
+        "            print(title)\n",
+        "            print()\n",
+        "            print(\"Abstract:\")\n",
+        "            print(abstract)\n",
+        "        # replace all labels with the real labels if skip_interaction=True,\n",
+        "        # otherwise wait for the respective button input\n",
+        "        if skip_interaction:\n",
+        "            results.extend(y_train_true[query_indices])\n",
+        "        else:\n",
+        "            wait_for_interaction()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Annotation & Active Learning Cycle\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The following cell shows the active learning cycle. The classifier (`clf`), the query strategy (`qs`) and the batch size (`batch_size`) are marked with a todo comment and can be changed freely. Note, that you might have to adjust the `call_func` call to pass additional parameters to the query strategy's `query` function.\n",
+        "\n",
+        "The UI updates itself after pressing one of the buttons used for annotation to show the next sample to annotate. The learning curves are only updated once per batch. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "805c09e6ebe54af68126d7869aa9d245",
+            "37b1258047d14583a6abf1d6bb44b984",
+            "c2ac76677a5a44f5ae8317fc52b29692",
+            "cbba931d922b426780f5186dfac592c4",
+            "899a9ff55b6641bab7f50c566c2f7876",
+            "a51b56005d354fc9abeadcad4d7c4c14",
+            "7eb6c7b6a7b64864804b2375b37a56c0",
+            "c399b72cbdb247d9ab73886f457c141f",
+            "6d61a3724d9f4fec9b37d1276b259242",
+            "13bf8ee801c94f81a68e5d1e1dfce7ee"
+          ]
+        },
+        "id": "uZLWpUkufB07",
+        "outputId": "7c0e7acb-1900-4798-bb98-3478d7176014"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.linear_model import LogisticRegression\n",
+        "\n",
+        "from skactiveml.classifier import SklearnClassifier\n",
+        "from skactiveml.pool import RandomSampling\n",
+        "from skactiveml.utils import call_func\n",
+        "\n",
+        "import warnings\n",
+        "warnings.filterwarnings(\"ignore\")\n",
+        "\n",
+        "# split data into a train and test set\n",
+        "X_indices_train, X_indices_test, X_train, X_test, y_train_true, y_test = (\n",
+        "    train_test_split(X_indices, X_embeddings, y, shuffle=True, random_state=0)\n",
+        ")\n",
+        "# initialize the labels for the training set\n",
+        "# y_train will consist of the annotations the user does\n",
+        "y_train = np.full_like(y_train_true, np.nan)\n",
+        "# y_train_ideal is labeled under a perfect annotator\n",
+        "y_train_ideal = np.full_like(y_train_true, np.nan)\n",
+        "\n",
+        "# number of queries per batch\n",
+        "# TODO: change the batch size to see how it affects various query strategies\n",
+        "batch_size = 5\n",
+        "\n",
+        "# initialize the classifier\n",
+        "# TODO: replace with a classifier of choice\n",
+        "clf = SklearnClassifier(\n",
+        "    LogisticRegression(random_state=0), classes=[0, 1], random_state=0\n",
+        ")\n",
+        "# initialize the query strategy\n",
+        "# TODO: replace with a query strategy of choice\n",
+        "qs = RandomSampling(random_state=0)\n",
+        "\n",
+        "# the accuracies per cycle\n",
+        "learning_curve = []\n",
+        "learning_curve_ideal = []\n",
+        "# number of annotation errors\n",
+        "num_annotation_errors = 0\n",
+        "# number of total annotations\n",
+        "num_total_annotations = 0\n",
+        "\n",
+        "# clear all outputs\n",
+        "output_sample.clear_output()\n",
+        "output_stats.clear_output()\n",
+        "output_plot.clear_output()\n",
+        "\n",
+        "# display the UI\n",
+        "display(output_box)\n",
+        "\n",
+        "# iterate over all cycles\n",
+        "for cycle in range(0, len(X_train) // batch_size):\n",
+        "    # calculate accuracy for this cycle with ideal annotations\n",
+        "    clf.fit(X_train, y_train_ideal)\n",
+        "    score_ideal = clf.score(X_test, y_test)\n",
+        "    learning_curve_ideal.append(score_ideal)\n",
+        "    # calculate accuracy for this cycle with user annotations\n",
+        "    clf.fit(X_train, y_train)\n",
+        "    score = clf.score(X_test, y_test)\n",
+        "    learning_curve.append(score)\n",
+        "\n",
+        "    # get indices to query labels for from the query strategy\n",
+        "    query_indices = call_func(\n",
+        "        qs.query,\n",
+        "        X=X_train,\n",
+        "        y=y_train,\n",
+        "        batch_size=batch_size,\n",
+        "        clf=clf,\n",
+        "        fit_clf=False,\n",
+        "    )\n",
+        "\n",
+        "    # update UI\n",
+        "    process_batch_annotation_UI(\n",
+        "        cycle,\n",
+        "        learning_curve,\n",
+        "        learning_curve_ideal,\n",
+        "        query_indices,\n",
+        "        X_indices_train,\n",
+        "        y_train_true,\n",
+        "        num_annotation_errors,\n",
+        "        num_total_annotations,\n",
+        "        batch_size,\n",
+        "        show_correct_class=False,\n",
+        "        skip_interaction=False,\n",
+        "    )\n",
+        "\n",
+        "    # Update labels with new annotations\n",
+        "    # replace all -1 labels (Correct Class button) with the correct label\n",
+        "    results = [\n",
+        "        y_train_true[i] if r == -1 else r\n",
+        "        for i, r in zip(query_indices, results)\n",
+        "    ]\n",
+        "    # set label in y_train and y_train_ideal\n",
+        "    y_train[query_indices] = results\n",
+        "    y_train_ideal[query_indices] = y_train_true[query_indices]\n",
+        "    # increase number of errors and total annotations\n",
+        "    num_annotation_errors += np.sum(y_train_true[query_indices] != results)\n",
+        "    num_total_annotations += len(results)"
+      ]
+    },
+    {
+      "attachments": {
+        "image.png": {
+          "image/png": "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"
+        }
+      },
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "b6sIVYMibnGx"
+      },
+      "source": [
+        "![image.png](attachment:image.png)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.11.9"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "018c2704c5af48cbbf83c2c28469c742": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bb0948b78eaa479fbefe3cf988f6ea1d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_519d9823101a43fcb3373c9340691da2",
+            "value": " 50000/50000 [00:07&lt;00:00, 6598.30 examples/s]"
+          }
+        },
+        "019b66f303204a24b9d57ab5faef6b0d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0b034663c2bf493d9284be73aede4c9c",
+            "placeholder": "​",
+            "style": "IPY_MODEL_94cc5882db984867b4af2dd13bf28dcf",
+            "value": "Downloading data: 100%"
+          }
+        },
+        "02e1c7b2c33d44c79217d724dbc2fa10": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_39145780dab04311b1989e8b9e4053e0",
+            "max": 50000,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_7ab12a559474405cb1e29bab8ec4a02e",
+            "value": 50000
+          }
+        },
+        "0a9344cc59704f5ebf2c77e76d56dbdc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_b08d232560564081b9ab172504a3d6e7",
+              "IPY_MODEL_02e1c7b2c33d44c79217d724dbc2fa10",
+              "IPY_MODEL_018c2704c5af48cbbf83c2c28469c742"
+            ],
+            "layout": "IPY_MODEL_c8aff5b9febf427793a3b682caa01af6"
+          }
+        },
+        "0b034663c2bf493d9284be73aede4c9c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "12b59f932c5e4e0f91d734d2734d3ad9": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "13bf8ee801c94f81a68e5d1e1dfce7ee": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "31f2cb542c234a73a458598f858ab0ea": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bdc26182b0604220ba7fcdd12aa4b60d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_ab997738bb014abe9700b6762ec5fc17",
+            "value": "Downloading readme: 100%"
+          }
+        },
+        "37b1258047d14583a6abf1d6bb44b984": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ButtonModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ButtonView",
+            "button_style": "",
+            "description": "Machine Learning",
+            "disabled": false,
+            "icon": "",
+            "layout": "IPY_MODEL_899a9ff55b6641bab7f50c566c2f7876",
+            "style": "IPY_MODEL_a51b56005d354fc9abeadcad4d7c4c14",
+            "tooltip": "Paper belongs to cs.LO, cs.NI, cs.CR, cs.PL]"
+          }
+        },
+        "39145780dab04311b1989e8b9e4053e0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3d2e823b26764a4bb6ee1263f7540a6e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_31f2cb542c234a73a458598f858ab0ea",
+              "IPY_MODEL_6c70d082e69f4fd7b2ab2664d7a5c4fa",
+              "IPY_MODEL_449cfe6c623148cc90e910d16f7e2e16"
+            ],
+            "layout": "IPY_MODEL_12b59f932c5e4e0f91d734d2734d3ad9"
+          }
+        },
+        "449cfe6c623148cc90e910d16f7e2e16": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8c29c360c6bb46b5ad55743720912291",
+            "placeholder": "​",
+            "style": "IPY_MODEL_573e0c84a3da42fba62f95ed2ccb91c1",
+            "value": " 701/701 [00:00&lt;00:00, 5.46kB/s]"
+          }
+        },
+        "4f483afd17aa4368943f7fbd0ddeba4c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "519d9823101a43fcb3373c9340691da2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "54c0a9cd436e463b954e203db622af89": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "573e0c84a3da42fba62f95ed2ccb91c1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "6c41b494477240e5947089e103cfc53d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "6c70d082e69f4fd7b2ab2664d7a5c4fa": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_54c0a9cd436e463b954e203db622af89",
+            "max": 701,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_d9f7f53be39541f7b2af655c23681b6d",
+            "value": 701
+          }
+        },
+        "6d61a3724d9f4fec9b37d1276b259242": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_13bf8ee801c94f81a68e5d1e1dfce7ee",
+            "msg_id": "",
+            "outputs": [
+              {
+                "name": "stdout",
+                "output_type": "stream",
+                "text": [
+                  "Cycle: 15\n",
+                  "Accuracy: 0.7972972972972973\n",
+                  "Batch index: 1/3\n",
+                  "Real class: 1.0\n",
+                  "\n",
+                  "Title:\n",
+                  "Intelligent location of simultaneously active acoustic emission sources:\n",
+                  "  Part I\n",
+                  "\n",
+                  "Abstract:\n",
+                  "  The intelligent acoustic emission locator is described in Part I, while Part\n",
+                  "II discusses blind source separation, time delay estimation and location of two\n",
+                  "simultaneously active continuous acoustic emission sources.\n",
+                  "  The location of acoustic emission on complicated aircraft frame structures is\n",
+                  "a difficult problem of non-destructive testing. This article describes an\n",
+                  "intelligent acoustic emission source locator. The intelligent locator comprises\n",
+                  "a sensor antenna and a general regression neural network, which solves the\n",
+                  "location problem based on learning from examples. Locator performance was\n",
+                  "tested on different test specimens. Tests have shown that the accuracy of\n",
+                  "location depends on sound velocity and attenuation in the specimen, the\n",
+                  "dimensions of the tested area, and the properties of stored data. The location\n",
+                  "accuracy achieved by the intelligent locator is comparable to that obtained by\n",
+                  "the conventional triangulation method, while the applicability of the\n",
+                  "intelligent locator is more general since analysis of sonic ray paths is\n",
+                  "avoided. This is a promising method for non-destructive testing of aircraft\n",
+                  "frame structures by the acoustic emission method.\n",
+                  "\n"
+                ]
+              }
+            ]
+          }
+        },
+        "7ab12a559474405cb1e29bab8ec4a02e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "7eb6c7b6a7b64864804b2375b37a56c0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "805c09e6ebe54af68126d7869aa9d245": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "VBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "VBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "VBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_37b1258047d14583a6abf1d6bb44b984",
+              "IPY_MODEL_c2ac76677a5a44f5ae8317fc52b29692"
+            ],
+            "layout": "IPY_MODEL_cbba931d922b426780f5186dfac592c4"
+          }
+        },
+        "899a9ff55b6641bab7f50c566c2f7876": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8c29c360c6bb46b5ad55743720912291": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "94cc5882db984867b4af2dd13bf28dcf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "9b9c5c95ebf746d5a1e5f06d96cd3e79": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9f64d642d04e46bc9db94fc2992c1093": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "a51b56005d354fc9abeadcad4d7c4c14": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ButtonStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "button_color": null,
+            "font_weight": ""
+          }
+        },
+        "a8a848800f1b4f709d594ac0a688d013": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ab997738bb014abe9700b6762ec5fc17": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "aed6ac245cc54f649dfadd00cda606c3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b08d232560564081b9ab172504a3d6e7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_aed6ac245cc54f649dfadd00cda606c3",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9f64d642d04e46bc9db94fc2992c1093",
+            "value": "Generating train split: 100%"
+          }
+        },
+        "bb0948b78eaa479fbefe3cf988f6ea1d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "bdc26182b0604220ba7fcdd12aa4b60d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c2ac76677a5a44f5ae8317fc52b29692": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ButtonModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ButtonView",
+            "button_style": "",
+            "description": "Other Paper",
+            "disabled": false,
+            "icon": "",
+            "layout": "IPY_MODEL_7eb6c7b6a7b64864804b2375b37a56c0",
+            "style": "IPY_MODEL_c399b72cbdb247d9ab73886f457c141f",
+            "tooltip": "Paper belongs to cs.AI, cs.LG, or cs.CV]"
+          }
+        },
+        "c399b72cbdb247d9ab73886f457c141f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ButtonStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "button_color": null,
+            "font_weight": ""
+          }
+        },
+        "c8aff5b9febf427793a3b682caa01af6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "cbba931d922b426780f5186dfac592c4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d9f7f53be39541f7b2af655c23681b6d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "dac9ea749aea48888bdb11ce4d0b7e44": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_019b66f303204a24b9d57ab5faef6b0d",
+              "IPY_MODEL_f3ee69a2b91d4fa384f557763650f133",
+              "IPY_MODEL_fb015057e08c4e5fae36392280603e5b"
+            ],
+            "layout": "IPY_MODEL_e65cec7450b34bd1a756e46fe37afc84"
+          }
+        },
+        "e65cec7450b34bd1a756e46fe37afc84": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f3ee69a2b91d4fa384f557763650f133": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4f483afd17aa4368943f7fbd0ddeba4c",
+            "max": 102202622,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_6c41b494477240e5947089e103cfc53d",
+            "value": 102202622
+          }
+        },
+        "fb015057e08c4e5fae36392280603e5b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_9b9c5c95ebf746d5a1e5f06d96cd3e79",
+            "placeholder": "​",
+            "style": "IPY_MODEL_a8a848800f1b4f709d594ac0a688d013",
+            "value": " 102M/102M [00:02&lt;00:00, 56.9MB/s]"
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}


Test patch:
diff --git a/skactiveml/pool/tests/test_bald.py b/skactiveml/pool/tests/test_bald.py
index e0dab043..fb5e6399 100644
--- a/skactiveml/pool/tests/test_bald.py
+++ b/skactiveml/pool/tests/test_bald.py
@@ -317,7 +317,7 @@ def test_batch_bald(self):
         probas = np.random.rand(10, 100, 5)
         np.testing.assert_equal(_bald(probas), _bald(probas))
         np.testing.assert_allclose(
-            _bald(probas), batch_bald(probas, batch_size=1)[0]
+            _bald(probas), batch_bald(probas, batch_size=1)[0], rtol=1e-6
         )
         np.testing.assert_equal(
             batch_bald(probas, batch_size=1), batch_bald(probas, batch_size=1)