tutorials/adapting_pretrained_pipeline.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pyannote/pyannote-audio/blob/develop/tutorials/adapting_pretrained_pipeline.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "npzkG4poB2BH"
      },
      "source": [
        "# Adapting pyannote.audio 2.1 pretrained speaker diarization pipeline to your own data\n",
        "\n",
        "> \"How I reached 1st place at Ego4D 2022, 1st place at Albayzin 2022, and 6th place at VoxSRC 2022 speaker diarization challenges\"\n",
        "\n",
        "[pyannote.audio](https://github.com/pyannote/pyannote-audio) is an open-source toolkit written in Python for speaker diarization. \n",
        "\n",
        "Version 2.1 introduces a major overhaul of the default speaker diarization pipeline, made of three main stages: speaker segmentation applied to a short sliding window, neural speaker embedding of each (local) speakers, and (global) agglomerative clustering.\n",
        "\n",
        "Despite its decent out-of-the-box performance, the default pipeline may suffer from the domain mismatch problem (common to most machine learning models) and not perform well on your own data. This tutorial will guide you through two recipes to adapt it to your own data and (hopefully) get better performance. Depending on the number and duration of labeled conversations, you may either focus on optimizing hyper-parameters or additionally fine-tune the internal speaker segmentation model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pnaQ4JSLF8Ms"
      },
      "source": [
        "⚠ Make sure that you switch to a GPU runtime (Runtime > Change runtime type).  \n",
        "If you don't, everything will be extremely slow."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CZjbjOBBDrdm"
      },
      "source": [
        "## Installation\n",
        "\n",
        "Let's start by installing `pyannote.audio` 2.1.1 (and `rich` for pretty progress bars)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_kYxY82Jzz3s"
      },
      "outputs": [],
      "source": [
        "!pip install -qq pyannote.audio==2.1.1\n",
        "!pip install -qq rich"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ndQ10VIf2W1c"
      },
      "source": [
        "⚠ Restart the runtime (Runtime > Restart runtime).  \n",
        "If you don't, `pyannote.database` will throw an error below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lz-b8j6RD7H6"
      },
      "source": [
        "## Data preparation\n",
        "\n",
        "First things first: we need data... Annotated data! Ideally, lots of annotated data! \n",
        "\n",
        "For the purpose of this tutorial, we will rely on the AMI-SDM (single distance microphone) corpus. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uSQVKFDC0cOe"
      },
      "outputs": [],
      "source": [
        "# download AMI-SDM mini corpus\n",
        "%cd /content/\n",
        "!git clone https://github.com/pyannote/AMI-diarization-setup\n",
        "%cd /content/AMI-diarization-setup/pyannote/\n",
        "!bash download_ami_sdm_mini.sh"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wTKkOeMr2QUL",
        "outputId": "d9cc39fd-4cc2-44fe-a922-533370221d31"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u001b[92m\u001b[1m\u001b[4mtrain\u001b[0m\n",
            "   28 files\n",
            "   8h46m annotated\n",
            "   6h11m of speech (71%)\n",
            "   112 speakers\n",
            "\u001b[92m\u001b[1m\u001b[4mdevelopment\u001b[0m\n",
            "   3 files\n",
            "   0h56m annotated\n",
            "   0h40m of speech (72%)\n",
            "   12 speakers\n",
            "\u001b[92m\u001b[1m\u001b[4mtest\u001b[0m\n",
            "   3 files\n",
            "   0h56m annotated\n",
            "   0h39m of speech (70%)\n",
            "   12 speakers\n"
          ]
        }
      ],
      "source": [
        "!PYANNOTE_DATABASE_CONFIG=\"/content/AMI-diarization-setup/pyannote/database.yml\" pyannote-database info AMI-SDM.SpeakerDiarization.mini"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "09LrQFIfp0zC"
      },
      "source": [
        "Note that we use a \"mini\" version of AMI-SDM so that the tutorial can be run in half an hour but the full version is also available for you to get better results. \n",
        "\n",
        "If you want to try it, replace `download_ami_sdm_mini.sh` by `download_ami_sdm.sh` and `AMI-SDM.SpeakerDiarization.mini` by `AMI-SDM.SpeakerDiarization.only_words` and you are good to go! "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "l6V8Exw41XBp"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "os.environ[\"PYANNOTE_DATABASE_CONFIG\"] = \"/content/AMI-diarization-setup/pyannote/database.yml\"\n",
        "from pyannote.database import get_protocol, FileFinder\n",
        "dataset = get_protocol(\"AMI-SDM.SpeakerDiarization.mini\", {\"audio\": FileFinder()})"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HivpZEgZEVAu"
      },
      "source": [
        "## Pretrained pipeline\n",
        "\n",
        "Let's start by running the pretrained pipeline on the test set and evaluate its performance.\n",
        "\n",
        "Official [pyannote.audio](https://github.com/pyannote/pyannote-audio) pipelines (i.e. those under the [`pyannote` organization](https://hf.co/pyannote) umbrella) are open-source, but gated. It means that you have to first accept users conditions on their respective Huggingface page to access the pretrained weights and hyper-parameters. \n",
        "\n",
        "To load the speaker diarization pipeline used in this tutorial, you have to \n",
        "* visit [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization) and accept the terms\n",
        "* visit [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation) (used internally by the speaker diarization pipeline)and accept the terms\n",
        "* log in using `notebook_login`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FbXEQUGXscTQ"
      },
      "outputs": [],
      "source": [
        "from huggingface_hub import notebook_login\n",
        "notebook_login()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "l7eN_Y792Cxt"
      },
      "outputs": [],
      "source": [
        "from pyannote.audio import Pipeline\n",
        "pretrained_pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization\", use_auth_token=True) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lDIIp7iaICUC",
        "outputId": "b4880a85-692b-470d-f133-d95128bdecd9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The pretrained pipeline reaches a Diarization Error Rate (DER) of 32.5% on AMI-SDM.SpeakerDiarization.mini test set.\n"
          ]
        }
      ],
      "source": [
        "# this takes approximately 2min to run on Google Colab GPU\n",
        "from pyannote.metrics.diarization import DiarizationErrorRate\n",
        "metric = DiarizationErrorRate()\n",
        "\n",
        "for file in dataset.test():\n",
        "    # apply pretrained pipeline\n",
        "    file[\"pretrained pipeline\"] = pretrained_pipeline(file)\n",
        "\n",
        "    # evaluate its performance\n",
        "    metric(file[\"annotation\"], file[\"pretrained pipeline\"], uem=file[\"annotated\"])\n",
        "\n",
        "print(f\"The pretrained pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 147
        },
        "id": "r4UydYQkKsxW",
        "outputId": "7069d8e5-7dc7-4701-bcd5-1663998cfd1d"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<pyannote.core.annotation.Annotation at 0x7f51bdcefb50>"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "file[\"annotation\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 147
        },
        "id": "s4C7xMQlKwVX",
        "outputId": "930c571f-069b-44ad-f87e-ce8d471176a6"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<pyannote.core.annotation.Annotation at 0x7f51bdbad1c0>"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "file[\"pretrained pipeline\"]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrYuCLLUKALA"
      },
      "source": [
        "## Fine-tuning the segmentation model\n",
        "\n",
        "When a sufficiently large training set of labeled conversations is available, fine-tuning the internal speaker segmentation model may lead to significant performance boost. \n",
        "\n",
        "Starting from the pretrained model..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "jeUDgr4f55v6"
      },
      "outputs": [],
      "source": [
        "from pyannote.audio import Model\n",
        "model = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SAyCf7ontua_"
      },
      "source": [
        "... we prepare it for fine-tuning on the training dataset:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Kk_a7ABQ6PPH"
      },
      "outputs": [],
      "source": [
        "from pyannote.audio.tasks import Segmentation\n",
        "task = Segmentation(\n",
        "    dataset, \n",
        "    duration=model.specifications.duration, \n",
        "    max_num_speakers=len(model.specifications.classes), \n",
        "    batch_size=32,\n",
        "    num_workers=2, \n",
        "    loss=\"bce\", \n",
        "    vad_loss=\"bce\")\n",
        "model.task = task\n",
        "model.setup(stage=\"fit\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TgobhVTKt9sH"
      },
      "source": [
        "The actual training is done with [`lightning`](https://github.com/Lightning-AI/lightning):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f_bVYrNo6TmI"
      },
      "outputs": [],
      "source": [
        "# this takes approximately 15min to run on Google Colab GPU\n",
        "from types import MethodType\n",
        "from torch.optim import Adam\n",
        "from pytorch_lightning.callbacks import (\n",
        "    EarlyStopping,\n",
        "    ModelCheckpoint,\n",
        "    RichProgressBar,\n",
        ")\n",
        "\n",
        "# we use Adam optimizer with 1e-4 learning rate\n",
        "def configure_optimizers(self):\n",
        "    return Adam(self.parameters(), lr=1e-4)\n",
        "\n",
        "model.configure_optimizers = MethodType(configure_optimizers, model)\n",
        "\n",
        "# we monitor diarization error rate on the validation set\n",
        "# and use to keep the best checkpoint and stop early\n",
        "monitor, direction = task.val_monitor\n",
        "checkpoint = ModelCheckpoint(\n",
        "    monitor=monitor,\n",
        "    mode=direction,\n",
        "    save_top_k=1,\n",
        "    every_n_epochs=1,\n",
        "    save_last=False,\n",
        "    save_weights_only=False,\n",
        "    filename=\"{epoch}\",\n",
        "    verbose=False,\n",
        ")\n",
        "early_stopping = EarlyStopping(\n",
        "    monitor=monitor,\n",
        "    mode=direction,\n",
        "    min_delta=0.0,\n",
        "    patience=10,\n",
        "    strict=True,\n",
        "    verbose=False,\n",
        ")\n",
        "\n",
        "callbacks = [RichProgressBar(), checkpoint, early_stopping]\n",
        "\n",
        "# we train for at most 20 epochs (might be shorter in case of early stopping)\n",
        "from pytorch_lightning import Trainer\n",
        "trainer = Trainer(accelerator=\"gpu\", \n",
        "                  callbacks=callbacks, \n",
        "                  max_epochs=20,\n",
        "                  gradient_clip_val=0.5)\n",
        "trainer.fit(model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "830LvZfdd3Rn"
      },
      "outputs": [],
      "source": [
        "# save path to the best checkpoint for later use\n",
        "finetuned_model = checkpoint.best_model_path\n",
        "\n",
        "# uncomment to download the checkpoint\n",
        "#from google.colab import files\n",
        "#files.download(finetuned_model)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2NVGAIMd-uPI"
      },
      "source": [
        "## Optimizing the pipeline hyper-parameters\n",
        "\n",
        "The pretrained `pyannote/speaker-diarization` pipeline relies on its own set of hyper-parameters adapted to the internal `pyannote/segmentation` pretrained model:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8OUIBHP7-xk_",
        "outputId": "20b3af76-d2d3-4bf9-eb58-2589f8e86939"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'segmentation': {'min_duration_off': 0.5817029604921046,\n",
              "  'threshold': 0.4442333667381752},\n",
              " 'clustering': {'method': 'centroid',\n",
              "  'min_cluster_size': 15,\n",
              "  'threshold': 0.7153814381597874}}"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "pretrained_hyperparameters = pretrained_pipeline.parameters(instantiated=True)\n",
        "pretrained_hyperparameters"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y1rRE4NqJmb5"
      },
      "source": [
        "There is no reason the above hyper-parameters are optimal for the newly finetuned speaker segmentation model. Let's optimize them:\n",
        "\n",
        "* `segmentation.threshold` ($\\theta$  in the [technical report](https://huggingface.co/pyannote/speaker-diarization/resolve/main/technical_report_2.1.pdf), between 0 and 1) controls the aggressiveness of speaker activity detection (i.e. a higher value will result in less detected speech); \n",
        "* `clustering.threshold` ($\\delta$  in the report, between 0 and 2) controls the number of speakers (i.e. a higher value will result in less speakers).\n",
        "* `segmentation.min_duration_off` ($\\Delta$ in the report, in seconds) controls whether intra-speaker pauses are filled. This usually depends on the downstream application so it is better to first force it to zero (i.e. never fill intra-speaker pauses) during optimization.\n",
        "* `clustering.centroid` is the linkage used by the agglomerative clustering step. `centroid` has been found to be slightly better than `average`. \n",
        "* `clustering.min_cluster_size` controls what to do with small speaker clusters. Clusters smaller than that are assigned to the most similar large cluster. `15` is a good default value.\n",
        "\n",
        "We start by optimizing `segmentation.threshold` by assuming that the subsequent clustering step is perfect (cf. `OracleClustering`)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FSWW7bIphgAI"
      },
      "outputs": [],
      "source": [
        "# this takes approximately 5min to run on Google Colab GPU\n",
        "from pyannote.audio.pipelines import SpeakerDiarization\n",
        "from pyannote.pipeline import Optimizer\n",
        "\n",
        "pipeline = SpeakerDiarization(\n",
        "    segmentation=finetuned_model,\n",
        "    clustering=\"OracleClustering\",  \n",
        ")\n",
        "# as reported in the technical report, min_duration_off can safely be set to 0.0\n",
        "pipeline.freeze({\"segmentation\": {\"min_duration_off\": 0.0}})\n",
        "\n",
        "optimizer = Optimizer(pipeline)\n",
        "dev_set = list(dataset.development())\n",
        "\n",
        "iterations = optimizer.tune_iter(dev_set, show_progress=False)\n",
        "best_loss = 1.0\n",
        "for i, iteration in enumerate(iterations):\n",
        "    print(f\"Best segmentation threshold so far: {iteration['params']['segmentation']['threshold']}\")\n",
        "    if i > 20: break   # 50 iterations should give slightly better results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pAUx-1Pw3Uc9"
      },
      "source": [
        "Then, we use the optimized value of `segmentation.threshold` and optimize `clustering.threshold`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "CSzOWLL5Q29-"
      },
      "outputs": [],
      "source": [
        "best_segmentation_threshold = optimizer.best_params[\"segmentation\"][\"threshold\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M_pQkyQ5RCjl"
      },
      "outputs": [],
      "source": [
        "# this takes approximately 5min to run on Google Colab GPU\n",
        "pipeline = SpeakerDiarization(\n",
        "    segmentation=finetuned_model,\n",
        "    embedding=pretrained_pipeline.embedding,\n",
        "    embedding_exclude_overlap=pretrained_pipeline.embedding_exclude_overlap,\n",
        "    clustering=pretrained_pipeline.klustering,\n",
        ")\n",
        "\n",
        "pipeline.freeze({\n",
        "    \"segmentation\": {\n",
        "        \"threshold\": best_segmentation_threshold,\n",
        "        \"min_duration_off\": 0.0,\n",
        "    },\n",
        "    \"clustering\": {\n",
        "        \"method\": \"centroid\",\n",
        "        \"min_cluster_size\": 15,\n",
        "    },\n",
        "})\n",
        "\n",
        "optimizer = Optimizer(pipeline)\n",
        "iterations = optimizer.tune_iter(dev_set, show_progress=False)\n",
        "best_loss = 1.0\n",
        "for i, iteration in enumerate(iterations):\n",
        "    print(f\"Best clustering threshold so far: {iteration['params']['clustering']['threshold']}\")\n",
        "    if i > 20: break  # 50 iterations should give slightly better results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BDA2XT-wAzDO"
      },
      "source": [
        "Finally, we use the optimized values of `segmentation.threshold` and `clustering.threshold` to evaluate the performance of the finetuned pipeline:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "GBJv2j1U_5mj"
      },
      "outputs": [],
      "source": [
        "best_clustering_threshold = optimizer.best_params['clustering']['threshold']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ir1VUqNEimcN",
        "outputId": "d8edfb16-8f97-4d84-d4d2-3066d8b7c791"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The finetuned pipeline reaches a Diarization Error Rate (DER) of 26.6% on AMI-SDM.SpeakerDiarization.mini test set.\n"
          ]
        }
      ],
      "source": [
        "# this takes approximately 2min to run on Google Colab GPU\n",
        "finetuned_pipeline = SpeakerDiarization(\n",
        "    segmentation=finetuned_model,\n",
        "    embedding=pretrained_pipeline.embedding,\n",
        "    embedding_exclude_overlap=pretrained_pipeline.embedding_exclude_overlap,\n",
        "    clustering=pretrained_pipeline.klustering,\n",
        ")\n",
        "\n",
        "finetuned_pipeline.instantiate({\n",
        "    \"segmentation\": {\n",
        "        \"threshold\": best_segmentation_threshold,\n",
        "        \"min_duration_off\": 0.0,\n",
        "    },\n",
        "    \"clustering\": {\n",
        "        \"method\": \"centroid\",\n",
        "        \"min_cluster_size\": 15,\n",
        "        \"threshold\": best_clustering_threshold,\n",
        "    },\n",
        "})\n",
        "\n",
        "metric = DiarizationErrorRate()\n",
        "\n",
        "for file in dataset.test():\n",
        "    # apply finetuned pipeline\n",
        "    file[\"finetuned pipeline\"] = finetuned_pipeline(file)\n",
        "\n",
        "    # evaluate its performance\n",
        "    metric(file[\"annotation\"], file[\"finetuned pipeline\"], uem=file[\"annotated\"])\n",
        "\n",
        "print(f\"The finetuned pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 147
        },
        "id": "LFvNtdZTBDZh",
        "outputId": "f72da25d-7df7-4d8f-97b1-b5ca0f2febe7"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<pyannote.core.annotation.Annotation at 0x7f52d9dfc970>"
            ]
          },
          "execution_count": 37,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "file[\"finetuned pipeline\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 147
        },
        "id": "odzLUrqaBHgV",
        "outputId": "1864ccc7-076e-41bf-ba63-13df32d57fda"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<pyannote.core.annotation.Annotation at 0x7f51bcebc3d0>"
            ]
          },
          "execution_count": 38,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "file[\"annotation\"]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "muYEOZ36VJo5"
      },
      "source": [
        "## Conclusion\n",
        "\n",
        "In just about half an hour (and 6 hours of training data), we managed to reduce the diarization error rate from 32.5% to 26.6%.\n",
        "\n",
        "[Yours truly](https://herve.niderb.fr) used this very recipe for their submissions to several speaker diarization benchmarks organized in 2022. I reached:\n",
        "\n",
        "* 6th place at [VoxSRC 2022](https://mm.kaist.ac.kr/datasets/voxceleb/voxsrc) speaker diarization challenge\n",
        "* 1st place at [Ego4D 2022](https://ego4d-data.org/) audio-only speaker diarization challenge\n",
        "* 1st place at [Albayzin 2022](http://catedrartve.unizar.es/albayzin2022results.html) speaker diarization challenge\n",
        "\n",
        "The [technical report](https://huggingface.co/pyannote/speaker-diarization/resolve/main/technical_report_2.1.pdf) contains a detailed description of the pipeline, as well as an extensive evaluation of its performance on multiple benchmarking datasets.\n",
        "\n",
        "For technical questions and bug reports, please check [pyannote.audio](https://github.com/pyannote/pyannote-audio) Github repository so that my (or anyone's) public answer benefits other people as well. \n",
        "\n",
        "For scientific consulting enquiries, please contact [me](herve@niderb.fr)."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "authorship_tag": "ABX9TyMc87txSanOjHXPQP0Zpu9J",
      "include_colab_link": true,
      "provenance": [],
      "toc_visible": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}