{"cells": [{"cell_type": "markdown", "id": "784e01ac", "metadata": {}, "source": ["# Pool-based Multilabel Active Learning - Getting Started\n", "\n", "This notebook introduces a compact multilabel active learning workflow with\n", "`scikit-activeml`. We use BirdSet embeddings as a realistic feature pool, but\n", "the focus stays on the workflow itself: how multilabel targets are\n", "represented, how a classifier and query strategies are connected, and how to\n", "read the resulting learning curves.\n", "\n", "You will learn:\n", "- how to prepare BirdSet embeddings and multilabel targets for\n", " `scikit-activeml`,\n", "- how `MISSING_LABEL` represents unknown labels in the unlabeled pool,\n", "- how to compare task-agnostic and multilabel-specific query strategies in\n", " one active-learning loop,\n", "- how to read the result plot and the final metric summary, including the\n", " caveats of multilabel metrics on a sparsely labeled data set."]}, {"cell_type": "markdown", "id": "c27b46b4", "metadata": {}, "source": ["> **_Google Colab Note:_** If the notebook fails to run after\n", "> installing the needed packages, try to restart the runtime (Ctrl + M) under\n", "> 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/development/generated/tutorials_colab//30_pool_multilabel_getting_started.ipynb)"]}, {"cell_type": "markdown", "id": "1f0a5c3d", "metadata": {}, "source": ["**Notebook Dependencies**\n", "\n", "Uncomment the following cell to install all dependencies for this tutorial.\n", "\n", "**Data and runtime:** the notebook reuses an existing `BirdSet_BASEAL`\n", "directory or downloads the official archive (about 215 MiB, 303 MB extracted)\n", "from the [Zenodo record](https://zenodo.org/records/19340660) when the data is\n", "missing. Only the `HSN_BASEAL` subset (69 MB) is used below. A complete run\n", "takes about two minutes on a GPU.\n", "\n", "**Citation:** the bundled exports are derived from BirdSet and were embedded\n", "with `Perch v2`. If you use this data, cite BirdSet, cite the Perch 2.0\n", "model/paper, and acknowledge the upstream source record listed in the\n", "subset's `metadata.csv`."]}, {"cell_type": "code", "execution_count": 1, "id": "03dfc429", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:26:32.938664Z", "iopub.status.busy": "2026-08-12T10:26:32.938548Z", "iopub.status.idle": "2026-08-12T10:26:32.940495Z", "shell.execute_reply": "2026-08-12T10:26:32.940271Z"}}, "outputs": [], "source": ["# !pip install scikit-activeml[opt] torch tqdm"]}, {"cell_type": "markdown", "id": "239f646a", "metadata": {}, "source": ["## General\n", "\n", "In multilabel classification, each sample is associated with a binary\n", "indicator vector such as `[1, 0, 1, 0, ...]` because several classes may be\n", "active at the same time.\n", "\n", "`scikit-activeml` does not guess this structure. Classifiers and query\n", "strategies receive `target_type=\"multi-label\"` together with a per-output\n", "class vocabulary `classes=[[0, 1], ..., [0, 1]]`, i.e. every target dimension\n", "is its own binary label. Two rules follow from the resolved target semantics\n", "and hold throughout this notebook:\n", "\n", "- a row of `y` is either **fully** labeled or **fully** unlabeled, i.e. a\n", " partially annotated sample is not representable,\n", "- unknown rows are filled with `MISSING_LABEL` and count as one unlabeled\n", " sample, not as `n_classes` unlabeled entries.\n", "\n", "Details on target resolution are documented in\n", "[Target and Annotation Semantics](https://scikit-activeml.github.io/latest/target_semantics.html).\n", "\n", "Inside the active-learning loop, we keep two versions of the pool labels:\n", "- `Y_train`: the full multilabel targets, which act as the oracle,\n", "- `Y_known`: the currently revealed labels, where unknown rows are stored as\n", " `MISSING_LABEL`.\n", "\n", "Each cycle follows the same pattern: fit on the currently known labels, query\n", "the next batch, reveal the true labels for that batch, refit the classifier,\n", "and evaluate on a fixed assessment split."]}, {"cell_type": "markdown", "id": "5c2d7d53", "metadata": {}, "source": ["## Imports and Runtime Setup\n", "\n", "The imports below show the core pieces of the tutorial: BirdSet data loading,\n", "multilabel metrics, a `SkorchClassifier`, and five pool-based query\n", "strategies."]}, {"cell_type": "code", "execution_count": 2, "id": "f810d175", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:26:32.941613Z", "iopub.status.busy": "2026-08-12T10:26:32.941428Z", "iopub.status.idle": "2026-08-12T10:26:34.905225Z", "shell.execute_reply": "2026-08-12T10:26:34.904840Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Using device: cuda\n"]}], "source": ["import csv\n", "import json\n", "import warnings\n", "import urllib.request\n", "import zipfile\n", "from pathlib import Path\n", "\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torch\n", "from tqdm import tqdm\n", "\n", "from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.metrics import average_precision_score, f1_score\n", "\n", "from skactiveml.classifier import SkorchClassifier, SklearnClassifier\n", "from skactiveml.pool import (\n", " CoreSet,\n", " LabelCardinalityInconsistency,\n", " MaxLossReductionMaxConfidence,\n", " RandomSampling,\n", " SubSamplingWrapper,\n", " UHerding,\n", ")\n", "from skactiveml.utils import MISSING_LABEL, call_func, is_labeled\n", "\n", "from skorch.callbacks import LRScheduler\n", "from torch import nn\n", "from torch.optim.lr_scheduler import CosineAnnealingLR\n", "\n", "warnings.filterwarnings(\"ignore\")\n", "mpl.rcParams[\"figure.facecolor\"] = \"white\"\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "print(f\"Using device: {device}\")"]}, {"cell_type": "markdown", "id": "6aa489e3", "metadata": {}, "source": ["## Configuration\n", "\n", "These are the few parameters worth changing first:\n", "- `DATA_ROOT` points to an existing BirdSet export if you already have one,\n", "- `DATASET_NAME` selects one multilabel pool (`HSN_BASEAL`, `POW_BASEAL`, or\n", " `UHH_BASEAL`),\n", "- `ASSESSMENT_SPLIT` names the held-out split; the bundled exports provide\n", " `train` and `validation` only,\n", "- `INITIAL_LABELS`, `QUERY_BATCH_SIZE`, and `N_CYCLES` define the annotation\n", " budget,\n", "- `SELECTED_STRATEGIES` lets you swap query strategies without touching the\n", " loop."]}, {"cell_type": "code", "execution_count": 3, "id": "6ee5cc2c", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:26:34.906452Z", "iopub.status.busy": "2026-08-12T10:26:34.906267Z", "iopub.status.idle": "2026-08-12T10:26:34.909474Z", "shell.execute_reply": "2026-08-12T10:26:34.909233Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Dataset: HSN_BASEAL\n", "Assessment split: validation\n", "Initial labels: 150\n", "Batch size: 75\n", "Cycles: 8\n", "Repetitions: 5\n", "Strategies: ['Random', 'CoreSet', 'UHerding', 'LCI', 'MMC']\n"]}], "source": ["DATA_ROOT = Path(\"BirdSet_BASEAL\")\n", "DATASET_NAME = \"HSN_BASEAL\"\n", "ASSESSMENT_SPLIT = \"validation\"\n", "\n", "INITIAL_LABELS = 150\n", "QUERY_BATCH_SIZE = 75\n", "N_CYCLES = 8\n", "N_REPETITIONS = 5\n", "BASE_SEED = 42\n", "SEEDS = range(BASE_SEED, BASE_SEED + N_REPETITIONS)\n", "SELECTED_STRATEGIES = [\"Random\", \"CoreSet\", \"UHerding\", \"LCI\", \"MMC\"]\n", "\n", "LABELS_FILENAME = \"labels.csv\"\n", "EMBEDDING_SUBDIR = Path(\"embeddings\") / \"perch_v2\"\n", "LABEL_SEPARATOR = \";\"\n", "\n", "ZENODO_RECORD_URL = \"https://zenodo.org/api/records/19340660\"\n", "ZENODO_ARCHIVE_NAME = \"BirdSet_BASEAL.zip\"\n", "\n", "MODEL_MAX_EPOCHS = 15\n", "MODEL_BATCH_SIZE = 32\n", "MODEL_LEARNING_RATE = 0.01\n", "MAX_CANDIDATES = 2000\n", "\n", "print(f\"Dataset: {DATASET_NAME}\")\n", "print(f\"Assessment split: {ASSESSMENT_SPLIT}\")\n", "print(f\"Initial labels: {INITIAL_LABELS}\")\n", "print(f\"Batch size: {QUERY_BATCH_SIZE}\")\n", "print(f\"Cycles: {N_CYCLES}\")\n", "print(f\"Repetitions: {N_REPETITIONS}\")\n", "print(f\"Strategies: {SELECTED_STRATEGIES}\")"]}, {"cell_type": "markdown", "id": "6c364ab1", "metadata": {}, "source": ["## Data Preparation\n", "\n", "The next cell deals only with data availability: it checks whether the\n", "requested BirdSet bundle is already present and otherwise resolves the\n", "`BirdSet_BASEAL.zip` download URL from the Zenodo record and extracts the\n", "archive."]}, {"cell_type": "code", "execution_count": 4, "id": "9f0cc792", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:26:34.910486Z", "iopub.status.busy": "2026-08-12T10:26:34.910306Z", "iopub.status.idle": "2026-08-12T10:26:34.913190Z", "shell.execute_reply": "2026-08-12T10:26:34.912950Z"}}, "outputs": [], "source": ["def ensure_birdset_baseal_data(dataset_name, data_root=DATA_ROOT):\n", " \"\"\"Download and extract the BirdSet export if it is not available yet.\"\"\"\n", " dataset_dir = data_root / dataset_name\n", " if (dataset_dir / LABELS_FILENAME).is_file() and (\n", " dataset_dir / EMBEDDING_SUBDIR\n", " ).is_dir():\n", " print(f\"Using existing BirdSet export: {dataset_dir}\")\n", " return dataset_dir\n", "\n", " record = json.load(urllib.request.urlopen(ZENODO_RECORD_URL))\n", " file_info = next(\n", " f for f in record[\"files\"] if f[\"key\"] == ZENODO_ARCHIVE_NAME\n", " )\n", " archive_path = data_root.parent / ZENODO_ARCHIVE_NAME\n", " with tqdm(unit=\"B\", unit_scale=True, desc=ZENODO_ARCHIVE_NAME) as progress:\n", "\n", " def report(n_blocks, block_size, total_size):\n", " progress.total = total_size\n", " progress.update(n_blocks * block_size - progress.n)\n", "\n", " urllib.request.urlretrieve(\n", " file_info[\"links\"][\"self\"], archive_path, reporthook=report\n", " )\n", " with zipfile.ZipFile(archive_path) as archive:\n", " archive.extractall(data_root.parent)\n", " archive_path.unlink()\n", "\n", " print(f\"BirdSet export is ready at: {dataset_dir}\")\n", " return dataset_dir"]}, {"cell_type": "markdown", "id": "d9cba028", "metadata": {}, "source": ["## Load the Multilabel Pool\n", "\n", "This cell turns the BirdSet export into the arrays used by `scikit-activeml`.\n", "`X_train` and `Y_train` form the pool, `X_assessment` and `Y_assessment` stay\n", "fixed for evaluation, and the labels are encoded as binary indicator vectors.\n", "\n", "Note the label sparsity reported below: on `HSN_BASEAL`, a sample carries\n", "about 0.52 labels on average and less than half of the samples carry any\n", "positive label at all. This shapes the metrics in the next section."]}, {"cell_type": "code", "execution_count": 5, "id": "754bcbd6", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:26:34.914198Z", "iopub.status.busy": "2026-08-12T10:26:34.914020Z", "iopub.status.idle": "2026-08-12T10:26:35.622350Z", "shell.execute_reply": "2026-08-12T10:26:35.621985Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Using existing BirdSet export: BirdSet_BASEAL/HSN_BASEAL\n"]}, {"name": "stdout", "output_type": "stream", "text": ["HSN_BASEAL\n", " pool samples: 6600\n", " assessment samples: 1800 (validation)\n", " features: 1536\n", " classes: 19\n", " mean labels/sample: train=0.52, validation=0.52\n", " samples with >=1 label: train=44.9%, validation=44.7%\n"]}], "source": ["def load_birdset_pool(\n", " dataset_name, data_root=DATA_ROOT, assessment_split=ASSESSMENT_SPLIT\n", "):\n", " \"\"\"Load embeddings and multilabel targets of one BirdSet pool.\"\"\"\n", " dataset_dir = data_root / dataset_name\n", " with (dataset_dir / LABELS_FILENAME).open(newline=\"\") as fp:\n", " rows = [\n", " row\n", " for row in csv.DictReader(fp)\n", " if row[\"split\"] in (\"train\", assessment_split)\n", " ]\n", " row_labels = [\n", " [\n", " name.strip()\n", " for name in row[\"label\"].split(LABEL_SEPARATOR)\n", " if name.strip()\n", " ]\n", " for row in rows\n", " ]\n", " class_names = np.asarray(\n", " sorted({name for names in row_labels for name in names}), dtype=object\n", " )\n", " class_to_index = {name: idx for idx, name in enumerate(class_names)}\n", "\n", " X = np.stack(\n", " [\n", " np.load(dataset_dir / EMBEDDING_SUBDIR / row[\"filename\"])\n", " for row in rows\n", " ]\n", " ).astype(np.float32)\n", " Y = np.zeros((len(rows), len(class_names)), dtype=np.uint8)\n", " for sample_idx, names in enumerate(row_labels):\n", " Y[sample_idx, [class_to_index[name] for name in names]] = 1\n", " is_train = np.asarray([row[\"split\"] == \"train\" for row in rows])\n", " if not is_train.any() or is_train.all():\n", " raise ValueError(\n", " f\"{dataset_name} must contain train and {assessment_split} rows\"\n", " )\n", "\n", " return {\n", " \"dataset_name\": dataset_name,\n", " \"assessment_split\": assessment_split,\n", " \"X_train\": X[is_train],\n", " \"Y_train\": Y[is_train],\n", " \"X_assessment\": X[~is_train],\n", " \"Y_assessment\": Y[~is_train],\n", " \"n_features\": X.shape[1],\n", " \"n_classes\": len(class_names),\n", " \"class_names\": class_names,\n", " }\n", "\n", "\n", "def print_dataset_summary(dataset):\n", " \"\"\"Print pool sizes and the label sparsity of a loaded data set.\"\"\"\n", " split = dataset[\"assessment_split\"]\n", " n_labels_train = dataset[\"Y_train\"].sum(axis=1)\n", " n_labels_assessment = dataset[\"Y_assessment\"].sum(axis=1)\n", " print(dataset[\"dataset_name\"])\n", " print(f\" pool samples: {len(n_labels_train)}\")\n", " print(f\" assessment samples: {len(n_labels_assessment)} ({split})\")\n", " print(f\" features: {dataset['n_features']}\")\n", " print(f\" classes: {dataset['n_classes']}\")\n", " print(\n", " f\" mean labels/sample: \"\n", " f\"train={n_labels_train.mean():.2f}, \"\n", " f\"{split}={n_labels_assessment.mean():.2f}\"\n", " )\n", " print(\n", " f\" samples with >=1 label: \"\n", " f\"train={np.mean(n_labels_train > 0):.1%}, \"\n", " f\"{split}={np.mean(n_labels_assessment > 0):.1%}\"\n", " )\n", "\n", "\n", "ensure_birdset_baseal_data(DATASET_NAME)\n", "dataset = load_birdset_pool(DATASET_NAME)\n", "print_dataset_summary(dataset)"]}, {"cell_type": "markdown", "id": "b24cd70f", "metadata": {}, "source": ["## Metrics and Classifier\n", "\n", "We keep the evaluation helpers and the classifier close together because they\n", "define what the active learner is trying to optimize. Three metrics are\n", "tracked, and each needs one caveat on this data set:\n", "\n", "- **F1-macro** thresholds the per-label sigmoids at 0.5 and averages the\n", " per-class F1 scores. Several classes have only a handful of positive\n", " samples in the assessment split, so this metric reacts strongly to a few\n", " rare classes and varies noticeably across repetitions.\n", "- **Top-1 accuracy** checks whether the highest-scoring label of a sample is\n", " actually active. It is computed **only on the samples that carry at least\n", " one positive label**; including the label-free samples would cap the metric\n", " at their share (about 45 % here) and make a good model look bad.\n", "- **mAP** is the macro-averaged average precision over all classes with at\n", " least one positive sample in the assessment split. It is threshold-free and\n", " therefore the most stable of the three.\n", "\n", "The important classifier detail is `classes=[[0, 1], ..., [0, 1]]` together\n", "with `target_type=\"multi-label\"`, which tells `scikit-activeml` that every\n", "target dimension is a binary label. `forward_outputs` additionally exposes\n", "the logits and the hidden representation, which the query strategies below\n", "consume."]}, {"cell_type": "code", "execution_count": 6, "id": "fb2acaef", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:26:35.623578Z", "iopub.status.busy": "2026-08-12T10:26:35.623460Z", "iopub.status.idle": "2026-08-12T10:26:35.628216Z", "shell.execute_reply": "2026-08-12T10:26:35.627965Z"}}, "outputs": [], "source": ["def topk_accuracy(probas, targets, topk=1):\n", " \"\"\"Top-k accuracy on samples with at least one positive label.\"\"\"\n", " has_label = targets.sum(axis=1) > 0\n", " probas, targets = probas[has_label], targets[has_label]\n", " topk_idx = np.argpartition(-probas, kth=topk - 1, axis=1)[:, :topk]\n", " row_ids = np.arange(targets.shape[0])[:, None]\n", " return float(np.mean(np.any(targets[row_ids, topk_idx], axis=1)))\n", "\n", "\n", "def macro_map_valid_classes(y_true, y_score):\n", " \"\"\"Macro-average the average precision over non-empty classes.\"\"\"\n", " valid_scores = [\n", " average_precision_score(y_true[:, class_idx], y_score[:, class_idx])\n", " for class_idx in range(y_true.shape[1])\n", " if y_true[:, class_idx].sum() > 0\n", " ]\n", " return float(np.mean(valid_scores)) if valid_scores else np.nan\n", "\n", "\n", "METRIC_FUNCS = {\n", " \"F1-macro\": lambda y_true, y_pred, y_proba: f1_score(\n", " y_true, y_pred, average=\"macro\", zero_division=0\n", " ),\n", " \"Top-1 accuracy\": lambda y_true, y_pred, y_proba: topk_accuracy(\n", " y_proba, y_true, topk=1\n", " ),\n", " \"mAP\": lambda y_true, y_pred, y_proba: macro_map_valid_classes(\n", " y_true, y_proba\n", " ),\n", "}\n", "\n", "\n", "class ClassificationModule(nn.Module):\n", " def __init__(self, n_features, n_classes, n_hidden_units=128):\n", " super().__init__()\n", " self.linear_1 = nn.Linear(n_features, n_hidden_units)\n", " self.bn = nn.BatchNorm1d(n_hidden_units)\n", " self.activation = nn.ReLU()\n", " self.linear_2 = nn.Linear(n_hidden_units, n_classes)\n", "\n", " def forward(self, x):\n", " emb = self.activation(self.bn(self.linear_1(x)))\n", " logits = self.linear_2(emb)\n", " return logits, emb\n", "\n", "\n", "def build_classifier(dataset, random_state):\n", " \"\"\"Create a multilabel MLP probing classifier on frozen embeddings.\"\"\"\n", " return SkorchClassifier(\n", " module=ClassificationModule,\n", " criterion=nn.BCEWithLogitsLoss,\n", " sample_dtype=np.float32,\n", " forward_outputs={\n", " \"proba\": (0, nn.Sigmoid()),\n", " \"logits\": (0, None),\n", " \"emb\": (1, None),\n", " },\n", " neural_net_param_dict={\n", " \"module__n_features\": dataset[\"n_features\"],\n", " \"module__n_classes\": dataset[\"n_classes\"],\n", " \"max_epochs\": MODEL_MAX_EPOCHS,\n", " \"batch_size\": MODEL_BATCH_SIZE,\n", " \"lr\": MODEL_LEARNING_RATE,\n", " \"optimizer\": torch.optim.RAdam,\n", " \"callbacks\": [\n", " (\n", " \"lr_scheduler\",\n", " LRScheduler(\n", " policy=CosineAnnealingLR, T_max=MODEL_MAX_EPOCHS\n", " ),\n", " )\n", " ],\n", " \"verbose\": 0,\n", " \"device\": device,\n", " \"train_split\": False,\n", " \"iterator_train__shuffle\": True,\n", " \"iterator_train__drop_last\": True,\n", " },\n", " # Each output dimension is its own binary label.\n", " classes=[[0, 1] for _ in range(dataset[\"n_classes\"])],\n", " missing_label=MISSING_LABEL,\n", " random_state=random_state,\n", " target_type=\"multi-label\",\n", " )"]}, {"cell_type": "markdown", "id": "4a7123cf", "metadata": {}, "source": ["## Query Strategies and Active-learning Loop\n", "\n", "Each strategy sees the same pool, the same initial labels, and the same\n", "classifier architecture. Two groups are compared:\n", "\n", "- **task-agnostic** strategies that work for any target type: `RandomSampling`\n", " as the baseline, `CoreSet` as a pure diversity criterion, and `UHerding`,\n", " which combines uncertainty with coverage,\n", "- **multilabel-specific** strategies: `LabelCardinalityInconsistency` (`LCI`),\n", " which prefers samples whose predicted label count disagrees with the\n", " observed label cardinality, and `MaxLossReductionMaxConfidence` (`MMC`),\n", " which pairs the multilabel classifier with a label-cardinality\n", " `discriminator`.\n", "\n", "Two implementation details are worth pointing out:\n", "\n", "- `SubSamplingWrapper` draws at most `MAX_CANDIDATES` (2000) of the unlabeled\n", " samples per cycle, i.e. of 6450 in the first and 5850 in the last cycle.\n", " Because of `exclude_non_subsample=True`, the remaining unlabeled samples are\n", " hidden from the wrapped strategy, which keeps the runtime of the\n", " coverage-based strategies manageable. Passing `random_state` makes that\n", " subsample reproducible and identical across strategies.\n", "- `CoreSet` operates on the classifier's hidden representation rather than on\n", " the raw Perch embeddings; `embed_samples_func` performs that mapping. The\n", " classifier is already fitted when `query` is called, so all strategies are\n", " invoked with `fit_clf=False`.\n", "\n", "`call_func` forwards only those keyword arguments that the wrapped strategy\n", "actually accepts, which is why the same call works for `RandomSampling` and\n", "for `MMC`."]}, {"cell_type": "code", "execution_count": 7, "id": "16399fa7", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:26:35.629231Z", "iopub.status.busy": "2026-08-12T10:26:35.629052Z", "iopub.status.idle": "2026-08-12T10:26:35.633642Z", "shell.execute_reply": "2026-08-12T10:26:35.633368Z"}}, "outputs": [], "source": ["def embed_with_classifier(clf):\n", " \"\"\"Return a function mapping samples to the classifier's embeddings.\"\"\"\n", "\n", " def embed_samples_func(X):\n", " return clf.predict(X, extra_outputs=\"emb\")[1]\n", "\n", " return embed_samples_func\n", "\n", "\n", "def build_query_strategy(strategy_name, seed, clf):\n", " \"\"\"Create a sub-sampling strategy and its extra `query` arguments.\"\"\"\n", " embed_samples_func, query_kwargs = None, {}\n", " if strategy_name == \"Random\":\n", " strategy = RandomSampling(random_state=seed)\n", " elif strategy_name == \"CoreSet\":\n", " strategy = CoreSet(random_state=seed)\n", " # CoreSet measures diversity in the classifier's embedding space.\n", " embed_samples_func = embed_with_classifier(clf)\n", " elif strategy_name == \"UHerding\":\n", " # UHerding needs both classifier logits and embeddings.\n", " strategy = UHerding(\n", " random_state=seed,\n", " predict_proba_dict={\"extra_outputs\": [\"logits\", \"emb\"]},\n", " )\n", " elif strategy_name == \"LCI\":\n", " strategy = LabelCardinalityInconsistency(random_state=seed)\n", " elif strategy_name == \"MMC\":\n", " strategy = MaxLossReductionMaxConfidence(random_state=seed)\n", " # MMC predicts the label cardinality of a candidate with a\n", " # discriminator, which is fitted on the labeled samples internally.\n", " query_kwargs[\"discriminator\"] = SklearnClassifier(\n", " RandomForestClassifier(random_state=seed), missing_label=-1\n", " )\n", " else:\n", " raise ValueError(f\"unknown query strategy: {strategy_name}\")\n", "\n", " query_strategy = SubSamplingWrapper(\n", " query_strategy=strategy,\n", " max_candidates=MAX_CANDIDATES,\n", " exclude_non_subsample=True,\n", " embed_samples_func=embed_samples_func,\n", " missing_label=MISSING_LABEL,\n", " random_state=seed,\n", " target_type=\"multi-label\",\n", " )\n", " return query_strategy, query_kwargs\n", "\n", "\n", "def run_active_learning(dataset, strategy_name, seed):\n", " \"\"\"Run one active-learning experiment and return its metric curves.\"\"\"\n", " np.random.seed(seed)\n", " torch.manual_seed(seed)\n", " rng = np.random.default_rng(seed)\n", "\n", " clf = build_classifier(dataset, random_state=seed)\n", " query_strategy, query_kwargs = build_query_strategy(\n", " strategy_name, seed=seed, clf=clf\n", " )\n", "\n", " # Unknown rows stay at MISSING_LABEL until they are queried.\n", " Y_known = np.full(dataset[\"Y_train\"].shape, MISSING_LABEL)\n", " initial_indices = rng.choice(\n", " len(dataset[\"X_train\"]), size=INITIAL_LABELS, replace=False\n", " )\n", " Y_known[initial_indices] = dataset[\"Y_train\"][initial_indices]\n", "\n", " metric_history = {metric_name: [] for metric_name in METRIC_FUNCS}\n", " labeled_counts = []\n", "\n", " def refit_and_evaluate():\n", " clf.fit(dataset[\"X_train\"], Y_known)\n", " y_pred = clf.predict(dataset[\"X_assessment\"])\n", " y_proba = clf.predict_proba(dataset[\"X_assessment\"])\n", " for metric_name, metric_func in METRIC_FUNCS.items():\n", " metric_history[metric_name].append(\n", " metric_func(dataset[\"Y_assessment\"], y_pred, y_proba)\n", " )\n", " # A multilabel row counts as one labeled sample, not as n_classes.\n", " labeled_counts.append(\n", " int(np.sum(is_labeled(Y_known, target_type=\"multi-label\")))\n", " )\n", "\n", " refit_and_evaluate()\n", " for _ in tqdm(\n", " range(N_CYCLES), desc=f\"{strategy_name} | seed={seed}\", leave=False\n", " ):\n", " query_idx = call_func(\n", " query_strategy.query,\n", " X=dataset[\"X_train\"],\n", " y=Y_known,\n", " batch_size=QUERY_BATCH_SIZE,\n", " clf=clf,\n", " fit_clf=False,\n", " **query_kwargs,\n", " )\n", " Y_known[query_idx] = dataset[\"Y_train\"][query_idx]\n", " refit_and_evaluate()\n", "\n", " return {\"metrics\": metric_history, \"labeled_counts\": labeled_counts}"]}, {"cell_type": "markdown", "id": "8145c12d", "metadata": {}, "source": ["## Run One Starter Experiment\n", "\n", "The next cell runs the experiment on one BirdSet pool. The results are stored\n", "in a simple dictionary: each strategy maps to one run per repetition, and each\n", "run contains the metric curves plus the number of revealed labels after every\n", "cycle."]}, {"cell_type": "code", "execution_count": 8, "id": "4dec644f", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:26:35.634633Z", "iopub.status.busy": "2026-08-12T10:26:35.634441Z", "iopub.status.idle": "2026-08-12T10:28:26.392443Z", "shell.execute_reply": "2026-08-12T10:28:26.392159Z"}}, "outputs": [], "source": ["results = {strategy_name: [] for strategy_name in SELECTED_STRATEGIES}\n", "\n", "for seed in tqdm(SEEDS, total=N_REPETITIONS, desc=\"repetitions\"):\n", " for strategy_name in SELECTED_STRATEGIES:\n", " results[strategy_name].append(\n", " run_active_learning(dataset, strategy_name, seed=seed)\n", " )"]}, {"cell_type": "markdown", "id": "282adcff", "metadata": {}, "source": ["## Plot the Learning Curves\n", "\n", "We now aggregate the runs across repetitions. The x-axis shows the number of\n", "fully labeled pool samples, so it corresponds directly to your annotation\n", "budget, and the shaded band is one standard deviation across repetitions."]}, {"cell_type": "code", "execution_count": 9, "id": "27d51b2c", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:28:26.393785Z", "iopub.status.busy": "2026-08-12T10:28:26.393571Z", "iopub.status.idle": "2026-08-12T10:28:26.667437Z", "shell.execute_reply": "2026-08-12T10:28:26.667145Z"}}, "outputs": [{"data": {"image/png": "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", "text/plain": ["
"]}, "metadata": {}, "output_type": "display_data"}], "source": ["def plot_results(results, dataset):\n", " \"\"\"Plot mean learning curves with one standard deviation per strategy.\"\"\"\n", " metric_names = list(METRIC_FUNCS)\n", " fig, axes = plt.subplots(\n", " 1,\n", " len(metric_names),\n", " figsize=(5.2 * len(metric_names), 4.0),\n", " sharex=True,\n", " tight_layout=True,\n", " )\n", " axes = np.atleast_1d(axes)\n", "\n", " for ax_idx, (ax, metric_name) in enumerate(zip(axes, metric_names)):\n", " for strategy_name, runs in results.items():\n", " budgets = np.mean([run[\"labeled_counts\"] for run in runs], axis=0)\n", " curves = np.asarray(\n", " [run[\"metrics\"][metric_name] for run in runs], dtype=float\n", " )\n", " mean_curve, std_curve = curves.mean(axis=0), curves.std(axis=0)\n", " ax.plot(\n", " budgets,\n", " mean_curve,\n", " marker=\"o\",\n", " label=strategy_name if ax_idx == 0 else None,\n", " )\n", " if len(runs) > 1:\n", " ax.fill_between(\n", " budgets,\n", " mean_curve - std_curve,\n", " mean_curve + std_curve,\n", " alpha=0.15,\n", " )\n", "\n", " ax.set_title(metric_name)\n", " ax.set_xlabel(\"Fully labeled pool samples\")\n", " ax.grid(True, alpha=0.3)\n", "\n", " axes[0].set_ylabel(\"Score\")\n", " fig.legend(\n", " loc=\"upper center\",\n", " bbox_to_anchor=(0.5, 1.0),\n", " ncol=len(results),\n", " frameon=True,\n", " )\n", " fig.suptitle(\n", " f\"{dataset['dataset_name']} | assessment split: \"\n", " f\"{dataset['assessment_split']}\",\n", " y=1.06,\n", " )\n", " plt.show()\n", "\n", "\n", "plot_results(results, dataset)"]}, {"cell_type": "markdown", "id": "5b6c1a24", "metadata": {}, "source": ["## Final Metric Summary\n", "\n", "The table below reports the scores after the last cycle, i.e. at the full\n", "annotation budget of `INITIAL_LABELS + N_CYCLES * QUERY_BATCH_SIZE` labeled\n", "samples."]}, {"cell_type": "code", "execution_count": 10, "id": "8d2e4f71", "metadata": {"execution": {"iopub.execute_input": "2026-08-12T10:28:26.668573Z", "iopub.status.busy": "2026-08-12T10:28:26.668464Z", "iopub.status.idle": "2026-08-12T10:28:26.671796Z", "shell.execute_reply": "2026-08-12T10:28:26.671545Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Scores at 750 labeled samples (mean +- std over 5 repetitions)\n", "Strategy F1-macro Top-1 accuracy mAP\n", "Random 0.298 +- 0.026 0.882 +- 0.005 0.431 +- 0.043\n", "CoreSet 0.460 +- 0.012 0.907 +- 0.004 0.669 +- 0.020\n", "UHerding 0.399 +- 0.016 0.904 +- 0.008 0.659 +- 0.073\n", "LCI 0.325 +- 0.028 0.894 +- 0.006 0.477 +- 0.056\n", "MMC 0.419 +- 0.034 0.911 +- 0.007 0.660 +- 0.048\n"]}], "source": ["def print_final_scores(results):\n", " \"\"\"Print the mean and standard deviation of the last cycle's scores.\"\"\"\n", " metric_names = list(METRIC_FUNCS)\n", " budget = INITIAL_LABELS + N_CYCLES * QUERY_BATCH_SIZE\n", " print(\n", " f\"Scores at {budget} labeled samples \"\n", " f\"(mean +- std over {N_REPETITIONS} repetitions)\"\n", " )\n", " print(\"Strategy \" + \"\".join(f\"{name:>20}\" for name in metric_names))\n", " for strategy_name, runs in results.items():\n", " cells = []\n", " for metric_name in metric_names:\n", " finals = [run[\"metrics\"][metric_name][-1] for run in runs]\n", " cells.append(f\"{np.mean(finals):.3f} +- {np.std(finals):.3f}\")\n", " print(f\"{strategy_name:<10}\" + \"\".join(f\"{c:>20}\" for c in cells))\n", "\n", "\n", "print_final_scores(results)"]}, {"cell_type": "markdown", "id": "9c3f7ab5", "metadata": {}, "source": ["## What to Try Next\n", "\n", "- Swap `DATASET_NAME` to `POW_BASEAL` or `UHH_BASEAL` to see how the ranking\n", " of the strategies changes with the label distribution of another pool.\n", "- Change `SELECTED_STRATEGIES` or add further multilabel-capable strategies\n", " from the\n", " [strategy overview](https://scikit-activeml.github.io/latest/generated/strategy_overview.html).\n", "- Raise `N_CYCLES` or `QUERY_BATCH_SIZE` to study a larger annotation budget,\n", " and `MAX_CANDIDATES` to trade runtime against candidate coverage."]}], "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}