{"cells": [{"metadata": {}, "cell_type": "markdown", "source": "# Advanced Active Learning with Multiple Annotators", "id": "ecb4c9ef9b411e30"}, {"metadata": {}, "cell_type": "markdown", "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/latest/generated/tutorials_colab//11_multiple_annotators_advanced.ipynb)"], "id": "40e5bcb5ce6baa06"}, {"metadata": {}, "cell_type": "markdown", "source": ["**Notebook Dependencies**\n", "\n", "Uncomment the following cell to install all dependencies for this tutorial."], "id": "f71148c855a74294"}, {"metadata": {}, "cell_type": "code", "outputs": [], "execution_count": null, "source": "# !pip install scikit-activeml[opt] torch torchvision tqdm", "id": "66693b55107b4127"}, {"metadata": {}, "cell_type": "markdown", "source": "
", "id": "32f32816679bb797"}, {"metadata": {}, "cell_type": "markdown", "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.", "id": "5526b4044f2fb5b6"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-02T18:55:55.936404Z", "start_time": "2025-12-02T18:55:54.000590Z"}}, "cell_type": "code", "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\")"], "id": "13c5edccd0d21e5d", "outputs": [], "execution_count": 2}, {"metadata": {}, "cell_type": "markdown", "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"], "id": "74b896636ca24294"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-02T18:55:55.998294Z", "start_time": "2025-12-02T18:55:55.981331Z"}}, "cell_type": "code", "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]"], "id": "f3745dbd8c761421", "outputs": [], "execution_count": 3}, {"metadata": {}, "cell_type": "markdown", "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"], "id": "8237de992529d4de"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-02T18:55:56.027719Z", "start_time": "2025-12-02T18:55:56.023746Z"}}, "cell_type": "code", "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\": 1,\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", "}"], "id": "c4347732b970bb0f", "outputs": [], "execution_count": 4}, {"metadata": {}, "cell_type": "markdown", "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"], "id": "5bc9b5db6d898f18"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-02T19:02:03.975360Z", "start_time": "2025-12-02T18:55:56.066640Z"}}, "cell_type": "code", "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"], "id": "6205f3055b5f6b02", "outputs": [{"data": {"text/plain": ["Majority-Vote | repetition 1/3: 0%| | 0/11 [00:00 `AnnotMix` is able to model the annotators' performances as basis for increasing the correct annotation rate by greedily assigning annotators with higher performances to samples.\n"], "id": "8bb09e8413c8c47b"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-02T19:02:04.214503Z", "start_time": "2025-12-02T19:02:04.038912Z"}}, "cell_type": "code", "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()"], "id": "d908397d36ff9d5d", "outputs": [{"data": {"text/plain": ["
"], "image/png": "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"}, "metadata": {}, "output_type": "display_data", "jetTransient": {"display_id": null}}], "execution_count": 6}], "metadata": {"kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.0"}, "nbsphinx": {"orphan": true}}, "nbformat": 4, "nbformat_minor": 5}