{"cells": [{"cell_type": "markdown", "id": "ecb4c9ef9b411e30", "metadata": {}, "source": ["# Advanced Active Learning with Multiple Annotators"]}, {"cell_type": "markdown", "id": "40e5bcb5ce6baa06", "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)](https://colab.research.google.com/github/scikit-activeml/scikit-activeml.github.io/blob/gh-pages/1.0/generated/tutorials_colab//11_multiple_annotators_advanced.ipynb)"]}, {"cell_type": "markdown", "id": "f71148c855a74294", "metadata": {}, "source": ["**Notebook Dependencies**\n", "\n", "Uncomment the following cell to install all dependencies for this tutorial."]}, {"cell_type": "code", "execution_count": 1, "id": "66693b55107b4127", "metadata": {}, "outputs": [], "source": ["# !pip install scikit-activeml[opt] torch torchvision tqdm"]}, {"cell_type": "markdown", "id": "32f32816679bb797", "metadata": {}, "source": ["<hr style=\"border-style: solid; border-top: 1px solid; border-right: 0; border-bottom: 0; border-left: 0;\">"]}, {"cell_type": "markdown", "id": "5526b4044f2fb5b6", "metadata": {}, "source": ["This notebook demonstrates how to use `scikit-activeml` to perform pool-based active learning when labels are provided by multiple, potentially unreliable annotators. We work on the handwritten digits dataset and simulate a small crowd of annotators with different noise patterns. We then compare a simple majority-vote baseline with a dedicated multi-annotator model that learns annotator performance (i.e., annotation accuracy) while querying new labels."]}, {"cell_type": "code", "execution_count": 2, "id": "13c5edccd0d21e5d", "metadata": {"ExecuteTime": {"end_time": "2025-12-02T18:55:55.936404Z", "start_time": "2025-12-02T18:55:54.000590Z"}}, "outputs": [], "source": ["import warnings\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torch\n", "import torch.nn.functional as F\n", "\n", "from sklearn.datasets import load_digits\n", "from sklearn.model_selection import train_test_split\n", "\n", "from skactiveml.classifier import SkorchClassifier\n", "from skactiveml.classifier.multiannotator import (\n", "    AnnotMixClassifier,\n", "    CrowdLayerClassifier,\n", ")\n", "from skactiveml.pool import RandomSampling\n", "from skactiveml.pool.multiannotator import SingleAnnotatorWrapper\n", "from skactiveml.utils import MISSING_LABEL, is_labeled, majority_vote\n", "\n", "from skorch.callbacks import LRScheduler\n", "from torch import nn\n", "from torch.optim import RAdam\n", "from torch.optim.lr_scheduler import CosineAnnealingLR\n", "from tqdm.auto import tqdm\n", "\n", "\n", "# Global configuration\n", "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "torch.manual_seed(0)\n", "warnings.filterwarnings(\"ignore\")"]}, {"cell_type": "markdown", "id": "74b896636ca24294", "metadata": {}, "source": ["## Data Preparation and Simulation of Multiple Annotators\n", "\n", "We start by loading the digits dataset and splitting it into training and test sets. Each image is scaled to the range \\([0, 1]\\) and reshaped to match the input format expected by a small convolutional neural network. On top of the ground-truth training labels `y_train` we simulate five annotators with different reliability profiles:\n", "\n", "- some are almost perfect,\n", "- some are noisy, one struggles with a specific digit,\n", "- and another one is biased towards the majority class.\n", "\n", "The resulting matrix `z_train` has one column per annotator and serves as crowd labels for the multi-annotator models.\n"]}, {"cell_type": "code", "execution_count": 3, "id": "f3745dbd8c761421", "metadata": {"ExecuteTime": {"end_time": "2025-12-02T18:55:55.998294Z", "start_time": "2025-12-02T18:55:55.981331Z"}}, "outputs": [], "source": ["# Load and preprocess the data\n", "digits = load_digits()\n", "X = digits.images[:, np.newaxis, :, :] / 16.0  # (n_samples, 1, 8, 8)\n", "y = digits.target\n", "classes = np.unique(y)\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(\n", "    X,\n", "    y,\n", "    test_size=0.5,\n", "    stratify=y,\n", "    random_state=42,\n", ")\n", "\n", "rng = np.random.default_rng(0)\n", "n_samples = len(y_train)\n", "classes = np.asarray(classes)\n", "y_train = np.asarray(y_train)\n", "\n", "\n", "def sample_noisy_labels(y_true, accuracy, rng):\n", "    \"\"\"Generate annotator labels with a given accuracy.\n", "\n", "    With probability `accuracy` the annotator returns\n", "    the true label. Otherwise, it samples a wrong label\n", "    uniformly from the remaining classes.\n", "    \"\"\"\n", "    y_true = np.asarray(y_true)\n", "    n = y_true.shape[0]\n", "    y_annot = y_true.copy()\n", "\n", "    correct = rng.random(n) < accuracy\n", "    wrong_idx = np.flatnonzero(~correct)\n", "\n", "    if wrong_idx.size:\n", "        wrong_labels = []\n", "        for yt in y_true[wrong_idx]:\n", "            candidates = classes[classes != yt]\n", "            wrong_labels.append(rng.choice(candidates))\n", "        y_annot[wrong_idx] = wrong_labels\n", "\n", "    return y_annot\n", "\n", "\n", "# Annotator 1: almost perfect\n", "ann1 = sample_noisy_labels(y_train, accuracy=0.95, rng=rng)\n", "\n", "# Annotator 2: strong, but clearly imperfect\n", "ann2 = sample_noisy_labels(y_train, accuracy=0.85, rng=rng)\n", "\n", "# Annotator 3: noticeably noisy\n", "ann3 = sample_noisy_labels(y_train, accuracy=0.70, rng=rng)\n", "\n", "# Annotator 4: class-dependent difficulties\n", "# (struggles with one hard digit)\n", "hard_class = 9  # treat digit '9' as hard, for example\n", "acc_easy = 0.85\n", "acc_hard = 0.40\n", "\n", "per_sample_acc = np.where(y_train == hard_class, acc_hard, acc_easy)\n", "rand = rng.random(n_samples)\n", "correct = rand < per_sample_acc\n", "\n", "ann4 = y_train.copy()\n", "wrong_idx = np.flatnonzero(~correct)\n", "if wrong_idx.size:\n", "    wrong_labels = []\n", "    for yt in y_train[wrong_idx]:\n", "        candidates = classes[classes != yt]\n", "        wrong_labels.append(rng.choice(candidates))\n", "    ann4[wrong_idx] = wrong_labels\n", "\n", "# Annotator 5: biased towards the majority class\n", "values, counts = np.unique(y_train, return_counts=True)\n", "majority_class = values[counts.argmax()]\n", "\n", "ann5 = y_train.copy()\n", "bias_strength = 0.50  # probability of forcing the majority label\n", "bias_mask = rng.random(n_samples) < bias_strength\n", "ann5[bias_mask] = majority_class\n", "\n", "# Final annotation matrix: shape (n_samples, n_annotators)\n", "z_train = np.column_stack([ann1, ann2, ann3, ann4, ann5])\n", "n_annotators = z_train.shape[1]"]}, {"cell_type": "markdown", "id": "8237de992529d4de", "metadata": {}, "source": ["## Neural Network Backbone and Classifiers\n", "\n", "The next step is to define a small convolutional network (CNN) that serves as a backbone for all classifiers. The network processes the 8 x 8 images, applies a single convolutional layer with max pooling, and maps the resulting 128-dimensional feature vector to class logits. The forward method returns both the logits and the intermediate embedding, which could be used by an active learning query strategy, such as `BADGE`.\n", "\n", "On top of this backbone we define two classifiers.\n", "\n", "- The `MajorityVoteClassifier` first aggregates the crowd labels in `z_train` by taking a majority vote per sample and then fits a standard single-annotator model.\n", "- In contrast, `AnnotMixClassifier` directly consumes the full matrix of annotator labels and internally models annotator performance.\n", "\n", "Both models share the same neural architecture and optimization hyperparameters so that differences in performance can be attributed to how they handle multiple annotators.\n"]}, {"cell_type": "code", "execution_count": 4, "id": "c4347732b970bb0f", "metadata": {"ExecuteTime": {"end_time": "2025-12-02T18:55:56.027719Z", "start_time": "2025-12-02T18:55:56.023746Z"}}, "outputs": [], "source": ["# Small CNN backbone for 8\u00d78 digit images\n", "class CNNModule(nn.Module):\n", "    \"\"\"\n", "    Compact CNN that returns both logits\n", "    and a 128-dimensional embedding.\n", "    \"\"\"\n", "\n", "    feature_dim = 128\n", "\n", "    def __init__(self, n_classes=10):\n", "        super().__init__()\n", "\n", "        # Input: (B, 1, 8, 8)\n", "        self.conv = nn.Conv2d(\n", "            in_channels=1,\n", "            out_channels=8,\n", "            kernel_size=3,\n", "            padding=1,\n", "        )  # -> (B, 8, 8, 8)\n", "\n", "          # after 2\u00d72 pooling: (B, 8, 4, 4)\n", "        self.fc = nn.Linear(self.feature_dim, n_classes)\n", "\n", "    def forward(self, x: torch.Tensor):\n", "        # x: (B, 1, 8, 8)\n", "        x = self.conv(x)\n", "        x = F.relu(x)\n", "        x = F.max_pool2d(x, kernel_size=2)  # (B, 8, 4, 4)\n", "        x_embed = x.view(x.size(0), -1)  # (B, 128)\n", "        logits = self.fc(x_embed)  # (B, n_classes)\n", "        return logits, x_embed\n", "\n", "class MajorityVoteClassifier(SkorchClassifier):\n", "    \"\"\"\n", "    Classifier that trains on labels\n", "    aggregated by majority vote.\n", "    \"\"\"\n", "\n", "    def fit(self, X, y, **fit_params):\n", "        y_mv = majority_vote(\n", "            y,\n", "            classes=self.classes,\n", "            missing_label=self.missing_label,\n", "            random_state=self.random_state,\n", "        )\n", "        return super().fit(X, y_mv, **fit_params)\n", "\n", "\n", "\n", "# Parameters passed to the NeuralNet in skorch`\n", "neural_net_param_dict = {\n", "    # Module-related parameters.\n", "    \"module__n_classes\": len(classes),\n", "    # Optimizer-related parameters.\n", "    \"max_epochs\": 100,\n", "    \"optimizer\": RAdam,\n", "    \"optimizer__weight_decay\": 0.0,\n", "    \"optimizer__lr\": 0.01,\n", "    # Data loading parameters.\n", "    \"iterator_train__shuffle\": True,\n", "    \"iterator_train__num_workers\": 0,\n", "    \"iterator_train__batch_size\": 16,\n", "    \"iterator_valid__batch_size\": 64,\n", "    \"iterator_train__drop_last\": True,\n", "    \"train_split\": None,\n", "    # Scheduler.\n", "    \"callbacks\": [\n", "        (\n", "            \"lr_scheduler\",\n", "            LRScheduler(policy=CosineAnnealingLR, T_max=100),\n", "        ),\n", "    ],\n", "    # Misc.\n", "    \"verbose\": 0,\n", "    \"device\": DEVICE,\n", "}\n", "\n", "# Common keyword arguments shared by all classifiers\n", "common_clf_kwargs = dict(\n", "    classes=classes,\n", "    missing_label=MISSING_LABEL,\n", "    sample_dtype=np.float32,\n", "    neural_net_param_dict=neural_net_param_dict,\n", ")\n", "\n", "\n", "def make_majority_vote_classifier(random_state):\n", "    return MajorityVoteClassifier(\n", "        module=CNNModule,\n", "        criterion=nn.CrossEntropyLoss,\n", "        random_state=random_state,\n", "        **common_clf_kwargs,\n", "    )\n", "\n", "\n", "def make_annot_mix_classifier(random_state):\n", "    return AnnotMixClassifier(\n", "        clf_module=CNNModule,\n", "        sample_embed_dim=2,\n", "        n_annotators=n_annotators,\n", "        random_state=random_state,\n", "        **common_clf_kwargs,\n", "    )\n", "\n", "classifier_dict = {\n", "    \"Majority-Vote\": make_majority_vote_classifier,\n", "    \"Annot-Mix\": make_annot_mix_classifier,\n", "}"]}, {"cell_type": "markdown", "id": "5bc9b5db6d898f18", "metadata": {}, "source": ["## Active Learning loop with Multiple Annotators\n", "\n", "We now set up the active-learning loop. For each classifier we run several independent repetitions, and in each repetition we start with an annotation matrix `y` that contains only missing labels. We then alternate between fitting the classifier on the currently observed noisy annotations and querying new labels from the simulated annotators.\n", "\n", "The query strategy is based on random sampling and wrapped in a `SingleAnnotatorWrapper` so that individual annotator\u2013sample pairs can be requested. For the `Annot-Mix` model we optionally use estimated annotator performances `A_perf` after the first warm-start iteration and pass them to the query strategy. After each cycle we record the test classification accuracy on the held-out test set and the accuracy of the collected labels compared to `y_train`.\n"]}, {"cell_type": "code", "execution_count": 5, "id": "6205f3055b5f6b02", "metadata": {"ExecuteTime": {"end_time": "2025-12-02T19:02:03.975360Z", "start_time": "2025-12-02T18:55:56.066640Z"}}, "outputs": [{"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "f804d7c6d16d4f2b9acd9f8c9f3f02f5", "version_major": 2, "version_minor": 0}, "text/plain": ["Majority-Vote | repetition 1/3:   0%|          | 0/11 [00:00<?, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "426abe8154c94185ab13ca38114891dd", "version_major": 2, "version_minor": 0}, "text/plain": ["Majority-Vote | repetition 2/3:   0%|          | 0/11 [00:00<?, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "768f6f32dabd49beac6a045eca1da13d", "version_major": 2, "version_minor": 0}, "text/plain": ["Majority-Vote | repetition 3/3:   0%|          | 0/11 [00:00<?, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "9d7ff04e0ea64977a33a8ca7f988b06e", "version_major": 2, "version_minor": 0}, "text/plain": ["Annot-Mix | repetition 1/3:   0%|          | 0/11 [00:00<?, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "a196fec7699a47d8afa8262b03f11212", "version_major": 2, "version_minor": 0}, "text/plain": ["Annot-Mix | repetition 2/3:   0%|          | 0/11 [00:00<?, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "f012ba1f7a86411a8bfcc77d6007d46d", "version_major": 2, "version_minor": 0}, "text/plain": ["Annot-Mix | repetition 3/3:   0%|          | 0/11 [00:00<?, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}], "source": ["n_reps = 3\n", "n_cycles = 10\n", "query_batch_size = 64\n", "\n", "results = {}\n", "\n", "for clf_name, clf_factory in classifier_dict.items():\n", "    # rows: repetitions, cols: AL cycles (excluding warm start)\n", "    clf_acc = np.full((n_reps, n_cycles), np.nan)\n", "    label_acc = np.full((n_reps, n_cycles), np.nan)\n", "\n", "    for i_rep in range(n_reps):\n", "        # Start with all annotations missing\n", "        y = np.full_like(z_train, fill_value=MISSING_LABEL, dtype=np.float32)\n", "\n", "        clf = clf_factory(random_state=i_rep)\n", "\n", "        base_qs = RandomSampling(\n", "            missing_label=MISSING_LABEL,\n", "            random_state=i_rep,\n", "        )\n", "        ma_qs = SingleAnnotatorWrapper(\n", "            base_qs,\n", "            missing_label=MISSING_LABEL,\n", "            random_state=i_rep,\n", "        )\n", "\n", "        for c in tqdm(\n", "            range(n_cycles + 1),\n", "            total=n_cycles + 1,\n", "            desc=f\"{clf_name} | repetition {i_rep + 1}/{n_reps}\",\n", "        ):\n", "            # Train classifier on current annotations\n", "            clf.fit(X_train, y)\n", "\n", "            if c > 0:\n", "                # For Annot-Mix, use estimated annotator performance from the model\n", "                if clf_name == \"Annot-Mix\":\n", "                    _, A_perf = clf.predict_proba(\n", "                        X_train,\n", "                        extra_outputs=[\"annotator_perf\"],\n", "                    )\n", "                else:\n", "                    A_perf = None\n", "\n", "                # Evaluate label and test accuracy\n", "                is_lbld_y = is_labeled(y, missing_label=MISSING_LABEL)\n", "                n_labels = is_lbld_y.sum()\n", "\n", "                if n_labels > 0:\n", "                    is_true_y = y == y_train[:, None]\n", "                    n_correct_labels = (is_true_y & is_lbld_y).sum()\n", "                    label_acc[i_rep, c - 1] = n_correct_labels / n_labels\n", "                    clf_acc[i_rep, c - 1] = clf.score(X_test, y_test)\n", "            else:\n", "                # Warm start: no model-based A_perf\n", "                A_perf = None\n", "\n", "            # Query new (sample, annotator) pairs and reveal their labels\n", "            query_idx = ma_qs.query(\n", "                X=X_train,\n", "                y=y,\n", "                batch_size=query_batch_size,\n", "                A_perf=A_perf,\n", "                n_annotators_per_sample=1,\n", "            )\n", "            sample_idx, annotator_idx = query_idx[:, 0], query_idx[:, 1]\n", "            y[sample_idx, annotator_idx] = z_train[sample_idx, annotator_idx]\n", "\n", "    results[f\"{clf_name}_clf-acc\"] = clf_acc\n", "    results[f\"{clf_name}_label-acc\"] = label_acc"]}, {"cell_type": "markdown", "id": "8bb09e8413c8c47b", "metadata": {}, "source": ["## Visualising Classifier and Annotation Accuracy\n", "\n", "To conclude the tutorial we visualise how both classifiers behave as more annotations are acquired. For each method we plot the average test accuracy and the average correct annotation rate across repetitions as a function of the number of acquired annotations. The curves include error bars showing one standard deviation, and the legend reports a simple area-like summary score (ALCU), which is the mean value of each curve over all active-learning cycles. There is one central observations:\n"]}, {"cell_type": "code", "execution_count": 6, "id": "d908397d36ff9d5d", "metadata": {"ExecuteTime": {"end_time": "2025-12-02T19:02:04.214503Z", "start_time": "2025-12-02T19:02:04.038912Z"}}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 1400x500 with 2 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, axes = plt.subplots(1, 2, figsize=(14, 5), constrained_layout=True)\n", "\n", "metrics = [\n", "    (\"clf-acc\", \"Test Classification Accuracy\"),\n", "    (\"label-acc\", \"Correct Annotation Rate\"),\n", "]\n", "\n", "x_values = np.arange(1, n_cycles + 1) * query_batch_size\n", "\n", "for (metric_key, ylabel), ax in zip(metrics, axes):\n", "    for clf_name in classifier_dict.keys():\n", "        result = results[\n", "            f\"{clf_name}_{metric_key}\"\n", "        ]\n", "\n", "        mean_curve = np.mean(result, axis=0)\n", "        std_curve = np.std(result, axis=0)\n", "\n", "        alcu = np.mean(mean_curve)\n", "\n", "        ax.errorbar(\n", "            x_values,\n", "            mean_curve,\n", "            yerr=std_curve,\n", "            label=f\"{clf_name}: ALCU={alcu:.3f}\",\n", "            alpha=1.0,\n", "            markersize=0.1,\n", "        )\n", "\n", "    ax.set_xlabel(\"# Acquired Annotations\", fontsize=14)\n", "    ax.set_ylabel(ylabel, fontsize=14)\n", "    ax.grid(True)\n", "    ax.legend(\n", "        fontsize=14,\n", "        loc=\"lower right\",\n", "        frameon=True,\n", "    )\n", "    ax.tick_params(axis=\"both\", which=\"major\", labelsize=12)\n", "\n", "plt.show()"]}], "metadata": {"kernelspec": {"display_name": "scikit-activeml", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.11"}, "nbsphinx": {"orphan": true}}, "nbformat": 4, "nbformat_minor": 5}