{"cells": [{"metadata": {"ExecuteTime": {"end_time": "2025-12-08T12:23:35.247239Z", "start_time": "2025-12-08T12:23:35.245655Z"}}, "cell_type": "markdown", "source": "# Bayesian Active Learning", "id": "fdc76c70f0c03636"}, {"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//09_bayesian_al.ipynb)"], "id": "c2b48ddbedec9816"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-08T12:23:49.135466Z", "start_time": "2025-12-08T12:23:49.132978Z"}}, "cell_type": "markdown", "source": ["**Notebook Dependencies**\n", "\n", "Uncomment the following cells to install all dependencies for this tutorial."], "id": "53a0f97d7db7c206"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:01:49.056093Z", "start_time": "2025-12-08T16:01:49.054432Z"}}, "cell_type": "code", "source": "# !pip install torch torchvision torchaudio transformers datasets[audio]", "id": "239365aa43eca8e", "outputs": [], "execution_count": 1}, {"metadata": {}, "cell_type": "markdown", "source": "<hr style=\"border-style: solid; border-top: 1px solid; border-right: 0; border-bottom: 0; border-left: 0;\">", "id": "b74db498512bdcd1"}, {"metadata": {}, "cell_type": "markdown", "source": ["This tutorial illustrates how Bayesian active learning query strategies can be applied within ``scikit-activeml`` to an audio classification task. In particular, we demonstrate pool-based active learning on the AudioMNIST dataset, where raw audio signals are first transformed into fixed embeddings using a pretrained Wav2Vec 2.0 model. These embeddings serve as input to a lightweight classification head, enabling efficient training and uncertainty estimation.\n", "\n", "The main focus of this notebook is on **Bayesian active learning**, where epistemic uncertainty is approximated via Monte Carlo (MC) dropout and exploited by Bayesian query strategies available in ``scikit-activeml``, such as uncertainty-based or information-theoretic selection methods. By repeatedly querying the most informative audio samples for annotation, we aim to achieve strong predictive performance with a minimal labeling budget.\n", "\n", "From a structural perspective, this tutorial closely follows the general workflow used in other deep active learning examples in ``scikit-activeml``:\n", "1. dataset preparation and embedding extraction,\n", "2. definition of a neural network ``pytorch`` module,\n", "3. specification of Bayesian query strategies,\n", "4. execution of an active learning loop with iterative querying and retraining.\n", "\n", "Compared to image-based tutorials (e.g., those using frozen Vision Transformers), this notebook highlights how the same active learning principles transfer seamlessly to the audio domain. In doing so, it demonstrates that ``scikit-activeml`` can be combined with modern audio foundation models for speech processing to perform Bayesian active learning on real-world audio data."], "id": "a109acd3b472dc16"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:01:51.997187Z", "start_time": "2025-12-08T16:01:49.096408Z"}}, "cell_type": "code", "source": ["import numpy as np\n", "import matplotlib as mlp\n", "import matplotlib.pyplot as plt\n", "import torch\n", "import warnings\n", "\n", "from copy import deepcopy\n", "from datasets import load_dataset, Audio\n", "from skactiveml.classifier import SkorchClassifier\n", "from skactiveml.pool import (\n", "    RandomSampling,\n", "    UncertaintySampling,\n", "    GreedyBALD,\n", "    BatchBALD,\n", "    QueryByCommittee,\n", "    SubSamplingWrapper,\n", ")\n", "from skactiveml.utils import call_func\n", "from skorch.callbacks import LRScheduler\n", "from torch import nn\n", "from torch.nn import functional as F\n", "from torch.optim.lr_scheduler import CosineAnnealingLR\n", "from tqdm import tqdm\n", "from transformers import AutoFeatureExtractor, Wav2Vec2Model\n", "\n", "warnings.filterwarnings(\"ignore\")\n", "mlp.rcParams[\"figure.facecolor\"] = \"white\"\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "random_state = 0\n", "missing_label = -1"], "id": "d31a01c1996154f1", "outputs": [], "execution_count": 2}, {"metadata": {}, "cell_type": "markdown", "source": ["## Embed AudioMNIST with Wac2Vec\n", "We turn the raw AudioMNIST waveforms into fixed-size feature vectors using a pretrained Wav2Vec 2.0 model. We first resample all audio clips to the sampling rate expected by Wav2Vec, then use the corresponding feature extractor and model to obtain hidden representations. For each recording, we pool the hidden states into a single embedding vector (e.g., by averaging over time). These embeddings are stored as our feature matrix ``X``, while the spoken digit labels form ``y``. All subsequent active learning steps in ``scikit-activeml`` operate only on these precomputed Wav2Vec embeddings, without re-running the foundation model.\n", "\n", "> **Note:** The execution time strongly depends on whether a GPU or CPU will be used."], "id": "62872e4cb3282705"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:05:07.933245Z", "start_time": "2025-12-08T16:01:52.041793Z"}}, "cell_type": "code", "source": ["# Spoken digit dataset: 0\u20139, circa 30k clips of 60 speakers\n", "ds = load_dataset(\"gilkeyio/AudioMNIST\")\n", "\n", "# Use provided train / test splits\n", "train_ds = ds[\"train\"]\n", "test_ds = ds[\"test\"]\n", "\n", "# Ensure a fixed sampling rate for all audio (16 kHz for Wav2Vec2)\n", "train_ds = train_ds.cast_column(\"audio\", Audio(sampling_rate=16_000))\n", "test_ds = test_ds.cast_column(\"audio\", Audio(sampling_rate=16_000))\n", "\n", "# Load audio foundation model (wav2vec2-base)\n", "feature_extractor = AutoFeatureExtractor.from_pretrained(\"facebook/wav2vec2-base\")\n", "model = Wav2Vec2Model.from_pretrained(\"facebook/wav2vec2-base\").to(device)\n", "model.eval()\n", "\n", "\n", "def embed(batch):\n", "    audio_arrays = [a[\"array\"] for a in batch[\"audio\"]]\n", "    sampling_rate = batch[\"audio\"][0][\"sampling_rate\"]\n", "\n", "    inputs = feature_extractor(\n", "        audio_arrays,\n", "        sampling_rate=sampling_rate,\n", "        return_tensors=\"pt\",\n", "        padding=True,\n", "    ).to(device)\n", "\n", "    with torch.no_grad():\n", "        out = model(**inputs).last_hidden_state\n", "        # Global mean pooling\n", "        emb = out.mean(dim=1)\n", "\n", "    batch[\"emb\"] = emb.cpu().numpy()\n", "    return batch\n", "\n", "\n", "# Map without multiprocessing\n", "train_ds = train_ds.map(embed, batched=True, batch_size=2)\n", "test_ds = test_ds.map(embed, batched=True, batch_size=2)\n", "\n", "# Digit labels: 0-9\n", "label_col = \"digit\"\n", "\n", "# Create numpy arrays\n", "X_pool = np.stack(train_ds[\"emb\"], dtype=np.float32)\n", "y_pool = np.array(train_ds[label_col], dtype=np.int64)\n", "X_test = np.stack(test_ds[\"emb\"], dtype=np.float32)\n", "y_test = np.array(test_ds[label_col], dtype=np.int64)\n", "n_features = X_pool.shape[1]\n", "classes = np.unique(y_pool)"], "id": "1945fbc5040ff2bb", "outputs": [{"data": {"text/plain": ["Map:   0%|          | 0/24000 [00:00<?, ? examples/s]"], "application/vnd.jupyter.widget-view+json": {"version_major": 2, "version_minor": 0, "model_id": "2fe6973368f94afb975c126a0aa268f5"}}, "metadata": {}, "output_type": "display_data", "jetTransient": {"display_id": null}}, {"data": {"text/plain": ["Map:   0%|          | 0/6000 [00:00<?, ? examples/s]"], "application/vnd.jupyter.widget-view+json": {"version_major": 2, "version_minor": 0, "model_id": "6ebeeeb6daff4f92a6a82c78af5b4688"}}, "metadata": {}, "output_type": "display_data", "jetTransient": {"display_id": null}}], "execution_count": 3}, {"metadata": {}, "cell_type": "markdown", "source": ["## PyTorch Module with Monte-Carlo Dropout\n", "\n", "This following module assumes that the inputs are fixed embeddings produced by a (possibly frozen) foundational model. During training, dropout is applied directly to the input embeddings with a different random mask for each forward pass. During evaluation, if Monte Carlo (MC) dropout is enabled, a fixed set of dropout masks is sampled once and reused across multiple forward calls, so that each MC sample can be interpreted as a persistent ensemble member."], "id": "7a78eeeeefa76b42"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:05:07.984906Z", "start_time": "2025-12-08T16:05:07.980351Z"}}, "cell_type": "code", "source": ["class ClassificationModule(nn.Module):\n", "    \"\"\"MLP classifier with optional MC dropout on input embeddings.\n", "\n", "    Parameters\n", "    ----------\n", "    n_features : int\n", "        Dimensionality of the input embeddings.\n", "    n_classes : int\n", "        Number of output classes.\n", "    n_hidden_units : int\n", "        Number of hidden units in the hidden layer.\n", "    mc_dropout_p : float, default=0.5\n", "        Dropout probability applied to the input embeddings. Used during\n", "        training for regularization and, if MC sampling is enabled, during\n", "        evaluation by means of fixed dropout masks.\n", "    n_mc_samples : int, default=0\n", "        Number of MC dropout samples in evaluation mode. If\n", "        ``n_mc_samples <= 1`` or ``mc_dropout_p <= 0``, evaluation is\n", "        deterministic and no MC statistics are returned.\n", "    \"\"\"\n", "    def __init__(\n", "        self,\n", "        n_features,\n", "        n_classes,\n", "        n_hidden_units,\n", "        mc_dropout_p=0.5,\n", "        n_mc_samples=0,\n", "    ):\n", "        super().__init__()\n", "        self.linear_1 = nn.Linear(n_features, n_hidden_units)\n", "        self.linear_2 = nn.Linear(n_hidden_units, n_classes)\n", "        self.activation = nn.ReLU()\n", "\n", "        self.mc_dropout_p = mc_dropout_p\n", "        self.n_mc_samples = n_mc_samples\n", "\n", "        # Fixed dropout masks (n_mc_samples, n_features), used only in eval.\n", "        self.register_buffer(\"mc_masks\", None)\n", "\n", "    def _mc_enabled(self):\n", "        \"\"\"Return True if MC dropout is configured to be active in eval.\"\"\"\n", "        return (\n", "            not self.training\n", "            and self.n_mc_samples is not None\n", "            and self.n_mc_samples > 1\n", "            and self.mc_dropout_p > 0.0\n", "        )\n", "\n", "    def _init_mc_masks(self, device, n_features):\n", "        \"\"\"Sample fixed dropout masks if MC is enabled and masks are missing.\n", "        \"\"\"\n", "        if not self._mc_enabled():\n", "            self.mc_masks = None\n", "            return\n", "\n", "        expected_shape = (self.n_mc_samples, n_features)\n", "        if self.mc_masks is not None and self.mc_masks.shape == expected_shape:\n", "            return\n", "\n", "        keep_prob = 1.0 - self.mc_dropout_p\n", "        mask = torch.empty(\n", "            *expected_shape,\n", "            device=device,\n", "        ).bernoulli_(keep_prob) / keep_prob\n", "        self.mc_masks = mask\n", "\n", "    def _forward_head(self, x):\n", "        \"\"\"Shared MLP head.\n", "\n", "        Parameters\n", "        ----------\n", "        x : torch.Tensor of shape (batch_size, n_features)\n", "            Input embeddings or masked embeddings.\n", "\n", "        Returns\n", "        -------\n", "        logits : torch.Tensor of shape (batch_size, n_classes)\n", "            Class logits.\n", "        \"\"\"\n", "        hidden = self.activation(self.linear_1(x))\n", "        logits = self.linear_2(hidden)\n", "        return logits\n", "\n", "    def forward(self, x):\n", "        \"\"\"Compute logits and, in evaluation mode, optional MC statistics.\n", "\n", "        Parameters\n", "        ----------\n", "        x : torch.Tensor of shape (n_samples, n_features)\n", "            Input embeddings.\n", "\n", "        Returns\n", "        -------\n", "        Training mode (``self.training is True``)\n", "            logits : torch.Tensor of shape (n_samples, n_classes)\n", "                Class logits from a single forward pass with standard dropout\n", "                on the input embeddings.\n", "\n", "        Evaluation mode, MC disabled\n", "            logits : torch.Tensor of shape (n_samples, n_classes)\n", "                Deterministic class logits from a single forward pass without\n", "                dropout on the input embeddings.\n", "\n", "        Evaluation mode, MC enabled\n", "            logits_mean : torch.Tensor of shape (n_samples, n_classes)\n", "                Mean logits over MC ensemble members, i.e.\n", "                ``logits_mc.mean(axis=1)``.\n", "            logits_mc : torch.Tensor of shape (n_samples, n_mc_samples, n_classes)\n", "                Logits for each MC ensemble member, obtained by applying the\n", "                fixed dropout masks to the input embeddings.\n", "        \"\"\"\n", "        n_samples, n_features = x.shape\n", "\n", "        # Training: standard dropout with varying masks\n", "        if self.training:\n", "            if self.mc_dropout_p > 0.0:\n", "                x_dropped = F.dropout(x, p=self.mc_dropout_p, training=True)\n", "            else:\n", "                x_dropped = x\n", "            logits = self._forward_head(x_dropped)\n", "            return logits\n", "\n", "        # Evaluation, MC disabled: deterministic forward without dropout\n", "        if not self._mc_enabled():\n", "            logits = self._forward_head(x)\n", "            return logits\n", "\n", "        # Evaluation, MC enabled: use fixed masks as ensemble members\n", "        self._init_mc_masks(x.device, n_features)\n", "        if self.mc_masks is None:\n", "            # Safety fallback: behave as if MC were disabled\n", "            logits = self._forward_head(x)\n", "            return logits\n", "\n", "        # x: (B, F) -> (B, 1, F)\n", "        x_expanded = x.unsqueeze(1)\n", "        # mc_masks: (S, F) -> (1, S, F)\n", "        mc_masks_expanded = self.mc_masks.unsqueeze(0)\n", "\n", "        # Apply fixed masks: (B, S, F)\n", "        x_masked = x_expanded * mc_masks_expanded\n", "\n", "        # Flatten batch and sample dims for shared head: (B * S, F)\n", "        x_masked_flat = x_masked.reshape(-1, n_features)\n", "        logits_mc_flat = self._forward_head(x_masked_flat)\n", "        # Reshape back to (B, S, C)\n", "        logits_mc = logits_mc_flat.view(n_samples, self.n_mc_samples, -1)\n", "\n", "        logits_mean = logits_mc.mean(dim=1)\n", "        return logits_mean, logits_mc"], "id": "1a8c8f89df3ce616", "outputs": [], "execution_count": 4}, {"metadata": {}, "cell_type": "markdown", "source": ["## Bayesian Skorch Classifier\n", "\n", "In this step, we define a ``BayesianSkorchClassifier`` that extends ``SkorchClassifier`` with a sample_proba method, which returns the class probabilities predicted by each individual ensemble member (e.g., MC dropout samples). We then initialize the classifier with the ClassificationModule as ``pytorch`` module, configure MC dropout via ``n_mc_samples`` and ``mc_dropout_p``, and set standard training hyperparameters such as optimizer, learning rate, batch size, and learning rate scheduler."], "id": "ced770af8b09b8fb"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:05:08.030485Z", "start_time": "2025-12-08T16:05:08.026422Z"}}, "cell_type": "code", "source": ["class BayesianSkorchClassifier(SkorchClassifier):\n", "    \"\"\"\n", "    Helper class implement a function returning the predicted class probabilities\n", "    predicted by the individual ensemble members.\n", "    \"\"\"\n", "\n", "    def sample_proba(self, X):\n", "        \"\"\"Returns the predicted class probabilities predicted by\n", "         the individual ensemble members.\n", "\n", "         Parameters\n", "         ----------\n", "         X : numpy.ndarray of shape (n_samples, n_features)\n", "            Test samples\n", "\n", "        Returns\n", "        -------\n", "        P_mc : numpy.ndarray of shape (n_members, n_samples, n_classes)\n", "            Probabilities predicted by the individual ensemble members.\n", "        \"\"\"\n", "        # Swap axes to have desired shape.\n", "        P_mc = self.predict_proba(X, extra_outputs=[\"probas_mc\"])[-1].swapaxes(0, 1)\n", "        return P_mc\n", "\n", "\n", "# Initialize classifier including training hyperparameters.\n", "clf_init = BayesianSkorchClassifier(\n", "    module=ClassificationModule,\n", "    criterion=nn.CrossEntropyLoss,\n", "    forward_outputs={\"proba\": (0, nn.Softmax(dim=-1)), \"probas_mc\": (1, nn.Softmax(dim=-1))},\n", "    neural_net_param_dict={\n", "        # Module-related parameters.\n", "        \"module__n_features\": n_features,\n", "        \"module__n_hidden_units\": 128,\n", "        \"module__n_classes\": len(classes),\n", "        \"module__n_mc_samples\": 10,\n", "        \"module__mc_dropout_p\": 0.2,\n", "        # Optimizer-related parameters.\n", "        \"max_epochs\": 50,\n", "        \"batch_size\": 16,\n", "        \"lr\": 0.01,\n", "        \"optimizer\": torch.optim.RAdam,\n", "        \"callbacks\": [\n", "            (\"lr_scheduler\", LRScheduler(policy=CosineAnnealingLR, T_max=50))\n", "        ],\n", "        # General parameters.\n", "        \"verbose\": 0,\n", "        \"device\": device,\n", "        \"train_split\": False,\n", "        \"iterator_train__shuffle\": True,\n", "    },\n", "    classes=classes,\n", "    missing_label=missing_label,\n", ").initialize()"], "id": "86e08db36c0d3778", "outputs": [], "execution_count": 5}, {"metadata": {}, "cell_type": "markdown", "source": ["## Active Classification\n", "For our classifier, we evaluate five different query strategies regarding their sample selection. For this purpose, we start with ``n_init_labels=64`` initial labels selected via random sampling and make ``n_cycles=10`` iterations of an active learning cycle with ``batch_size=32``."], "id": "53f53ca730aa54fb"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:18:22.014635Z", "start_time": "2025-12-08T16:17:35.964345Z"}}, "cell_type": "code", "source": ["# Define setup.\n", "n_cycles = 10\n", "batch_size = 32\n", "n_sub_set = 5000\n", "n_init_labels = 64\n", "qs_dict = {\n", "    \"RandomSampling\": RandomSampling(\n", "        random_state=random_state, missing_label=missing_label\n", "    ),\n", "    \"UncertaintySampling\": UncertaintySampling(\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "        method=\"margin_sampling\",\n", "    ),\n", "    \"QBC\": QueryByCommittee(\n", "        method=\"vote_entropy\",\n", "        sample_predictions_method_name=\"sample_proba\",\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "    ),\n", "    \"GreedyBALD\": GreedyBALD(\n", "        sample_predictions_method_name=\"sample_proba\",\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "    ),\n", "    \"BatchBALD\": BatchBALD(\n", "        sample_predictions_method_name=\"sample_proba\",\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "    ),\n", "}\n", "acc_dict = {key: np.zeros(n_cycles + 1) for key in qs_dict}\n", "\n", "\n", "# Perform active learning with each query strategy.\n", "for qs_name, qs in qs_dict.items():\n", "    print(f\"Execute active learning using {qs_name}.\")\n", "    # Set seed and copy classifier for consistent initialization.\n", "    torch.manual_seed(random_state)\n", "    torch.cuda.manual_seed(random_state)\n", "    clf = deepcopy(clf_init)\n", "\n", "    # Wrapper to subsample unlabeled samples.\n", "    qs = SubSamplingWrapper(\n", "        query_strategy=qs,\n", "        max_candidates=n_sub_set,\n", "        exclude_non_subsample=True,\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "    )\n", "    qs_init = RandomSampling(random_state=random_state, missing_label=missing_label)\n", "\n", "    # Create array with 64 initial labels.\n", "    y = np.full_like(y_pool, fill_value=missing_label, dtype=np.int64)\n", "    init_indices = np.random.RandomState(0).choice(\n", "        np.arange(len(y)), size=n_init_labels, replace=False\n", "    )\n", "    y[init_indices] = y_pool[init_indices]\n", "\n", "    # Execute active learning cycle.\n", "    for c in tqdm(range(n_cycles)):\n", "        # Fit and evaluate clf.\n", "        acc = clf.fit(X_pool, y).score(X_test, y_test)\n", "        acc_dict[qs_name][c] = acc\n", "\n", "        # Select and update training data.\n", "        query_idx = call_func(\n", "            qs.query,\n", "            X=X_pool,\n", "            y=y,\n", "            clf=clf,\n", "            fit_clf=False,\n", "            ensemble=clf,\n", "            fit_ensemble=False,\n", "            batch_size=batch_size,\n", "        )\n", "        y[query_idx] = y_pool[query_idx]\n", "\n", "    # Fit and evaluate clf.\n", "    clf.fit(X_pool, y)\n", "    acc_dict[qs_name][n_cycles] = clf.score(X_test, y_test)"], "id": "cef2ac8b873523c9", "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Execute active learning using RandomSampling.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:06<00:00,  1.52it/s]\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Execute active learning using UncertaintySampling.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:07<00:00,  1.38it/s]\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Execute active learning using QBC.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:07<00:00,  1.38it/s]\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Execute active learning using GreedyBALD.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:07<00:00,  1.36it/s]\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Execute active learning using BatchBALD.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:12<00:00,  1.24s/it]\n"]}], "execution_count": 6}, {"metadata": {}, "cell_type": "markdown", "source": ["## Visualize Results\n", "In the following, we plot the obtained learning curves including the area under learning curve (AULC) scores per query strategy."], "id": "a75b9e609395597d"}, {"metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:18:22.110798Z", "start_time": "2025-12-08T16:18:22.017097Z"}}, "cell_type": "code", "source": ["cycles = np.arange(n_cycles + 1, dtype=int)\n", "plt.figure(figsize=(16, 9))\n", "for qs_name, acc in acc_dict.items():\n", "    plt.plot(\n", "        cycles * batch_size,\n", "        acc,\n", "        label=f\"{qs_name}: AULC={round(acc.mean(), 3)}\",\n", "    )\n", "plt.xticks(cycles * batch_size, fontsize=\"x-large\")\n", "plt.yticks(np.arange(0.5, 1.0, 0.1), fontsize=\"x-large\")\n", "plt.grid()\n", "plt.xlabel(\"# labeled samples\", fontsize=\"x-large\")\n", "plt.ylabel(\"test accuracy\", fontsize=\"x-large\")\n", "plt.legend(loc=\"lower right\", fontsize=\"x-large\")\n", "plt.show()#%%\n"], "id": "29fb5f84c2666a20", "outputs": [{"data": {"text/plain": ["<Figure size 1600x900 with 1 Axes>"], "image/png": "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"}, "metadata": {}, "output_type": "display_data", "jetTransient": {"display_id": null}}], "execution_count": 7}], "metadata": {"kernelspec": {"display_name": "Python 3 (ipykernel)", "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": "2.7.6"}, "nbsphinx": {"orphan": true}}, "nbformat": 4, "nbformat_minor": 5}