From 6b066bf2be5d198525a363e7c7aa6d1306f20ca4 Mon Sep 17 00:00:00 2001 From: Bilal-Rahou <86656831+Bilal-Rahou@users.noreply.github.com> Date: Tue, 10 Oct 2023 20:34:06 +0200 Subject: [PATCH 01/19] feat: update intro tutorial to pyannote.audio 3.0 --- tutorials/intro.ipynb | 7832 ++++++++++++++++++++--------------------- 1 file changed, 3827 insertions(+), 4005 deletions(-) diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index 3793bfe09..75344267a 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -1,4066 +1,3888 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "9-KmdPlBYnp6" - }, - "source": [ - "\"Open" - ] + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "9-KmdPlBYnp6" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1Fs2d8otYnp7" + }, + "source": [ + "[`pyannote.audio`](https://github.com/pyannote/pyannote-audio) is an open-source toolkit written in Python for **speaker diarization**. \n", + "\n", + "Based on [`PyTorch`](https://pytorch.org) machine learning framework, it provides a set of trainable end-to-end neural building blocks that can be combined and jointly optimized to build speaker diarization pipelines. \n", + "\n", + "`pyannote.audio` also comes with pretrained [models](https://huggingface.co/models?other=pyannote-audio-model) and [pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) covering a wide range of domains for voice activity detection, speaker segmentation, overlapped speech detection, speaker embedding reaching state-of-the-art performance for most of them. \n", + "\n", + "**This notebook will teach you how to apply those pretrained pipelines on your own data.**\n", + "\n", + "Make sure you run it using a GPU (or it might otherwise be slow...)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tckHJKZnYnp7" + }, + "source": [ + "## Installation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, - { - "cell_type": "markdown", - "metadata": { - "id": "1Fs2d8otYnp7" - }, - "source": [ - "[`pyannote.audio`](https://github.com/pyannote/pyannote-audio) is an open-source toolkit written in Python for **speaker diarization**. \n", - "\n", - "Based on [`PyTorch`](https://pytorch.org) machine learning framework, it provides a set of trainable end-to-end neural building blocks that can be combined and jointly optimized to build speaker diarization pipelines. \n", - "\n", - "`pyannote.audio` also comes with pretrained [models](https://huggingface.co/models?other=pyannote-audio-model) and [pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) covering a wide range of domains for voice activity detection, speaker segmentation, overlapped speech detection, speaker embedding reaching state-of-the-art performance for most of them. \n", - "\n", - "**This notebook will teach you how to apply those pretrained pipelines on your own data.**\n", - "\n", - "Make sure you run it using a GPU (or it might otherwise be slow...)" - ] + "id": "ai082p4HYnp7", + "outputId": "bb673846-8b58-4743-cea2-6c6270632d7f" + }, + "outputs": [], + "source": [ + "!pip install -qq pyannote.audio==3.0.1\n", + "!pip install -qq ipython==7.34.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qggK-7VBYnp8" + }, + "source": [ + "# Visualization with `pyannote.core`\n", + "\n", + "For the purpose of this notebook, we will download and use an audio file coming from the [AMI corpus](http://groups.inf.ed.ac.uk/ami/corpus/), which contains a conversation between 4 people in a meeting room." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "uJWoQiJgYnp8" + }, + "outputs": [], + "source": [ + "!wget -q http://groups.inf.ed.ac.uk/ami/AMICorpusMirror/amicorpus/ES2004a/audio/ES2004a.Mix-Headset.wav\n", + "DEMO_FILE = {'uri': 'ES2004a.Mix-Headset', 'audio': 'ES2004a.Mix-Headset.wav'}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EPIapoCJYnp8" + }, + "source": [ + "Because AMI is a benchmarking dataset, it comes with manual annotations (a.k.a *groundtruth*). \n", + "Let us load and visualize the expected output of the speaker diarization pipeline.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "Mmm0Q22JYnp8" + }, + "outputs": [], + "source": [ + "!wget -q https://raw.githubusercontent.com/pyannote/AMI-diarization-setup/main/only_words/rttms/test/ES2004a.rttm" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 }, + "id": "ToqCwl_FYnp9", + "outputId": "a1d9631f-b198-44d1-ff6d-ec304125a9f4" + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "tckHJKZnYnp7" - }, - "source": [ - "## Installation" + "data": { + "image/png": "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\n", + "text/plain": [ + "" ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# load groundtruth\n", + "from pyannote.database.util import load_rttm\n", + "_, groundtruth = load_rttm('ES2004a.rttm').popitem()\n", + "\n", + "# visualize groundtruth\n", + "groundtruth" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p_R9T9Y5Ynp9" + }, + "source": [ + "For the rest of this notebook, we will only listen to and visualize a one-minute long excerpt of the file (but will process the whole file anyway)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 230 }, + "id": "bAHza4Y1Ynp-", + "outputId": "c4cc2369-bfe4-4ac2-bb71-37602e7c7a8a" + }, + "outputs": [ { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ai082p4HYnp7", - "outputId": "bb673846-8b58-4743-cea2-6c6270632d7f", - "vscode": { - "languageId": "python" - } - }, - "outputs": [], - "source": [ - "!pip install -qq https://github.com/pyannote/pyannote-audio/archive/refs/heads/develop.zip\n", - "!pip install -qq ipython==7.34.0" + "data": { + "image/png": "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\n", + "text/plain": [ + "" ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyannote.core import Segment, notebook\n", + "# make notebook visualization zoom on 600s < t < 660s time range\n", + "EXCERPT = Segment(600, 660)\n", + "notebook.crop = EXCERPT\n", + "\n", + "# visualize excerpt groundtruth\n", + "groundtruth" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L3FQXT5FYnp-" + }, + "source": [ + "This nice visualization is brought to you by [`pyannote.core`](http://pyannote.github.io/pyannote-core/) and basically indicates when each speaker speaks. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 62 }, + "id": "rDhZ3bXEYnp-", + "outputId": "a82efe4e-2f9c-48bd-94fb-c62af3a3cb43" + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "qggK-7VBYnp8" - }, - "source": [ - "# Visualization with `pyannote.core`\n", - "\n", - "For the purpose of this notebook, we will download and use an audio file coming from the [AMI corpus](http://groups.inf.ed.ac.uk/ami/corpus/), which contains a conversation between 4 people in a meeting room." + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" ] - }, + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyannote.audio import Audio \n", + "from IPython.display import Audio as IPythonAudio\n", + "waveform, sr = Audio(mono=\"downmix\").crop(DEMO_FILE, EXCERPT)\n", + "IPythonAudio(waveform.flatten(), rate=sr)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hkzox7QIYnp_" + }, + "source": [ + "# Processing your own audio file (optional)\n", + "\n", + "In case you just want to go ahead with the demo file, skip this section entirely.\n", + "\n", + "In case you want to try processing your own audio file, proceed with running this section. It will offer you to upload an audio file (preferably a `wav` file but all formats supported by [`SoundFile`](https://pysoundfile.readthedocs.io/en/latest/) should work just fine)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3hmFmLzFYnp_" + }, + "source": [ + "## Upload audio file" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xC05jFO_Ynp_", + "outputId": "c5502632-56ae-4adb-8bdc-112deedc8893" + }, + "outputs": [], + "source": [ + "import google.colab\n", + "own_file, _ = google.colab.files.upload().popitem()\n", + "OWN_FILE = {'audio': own_file}\n", + "notebook.reset()\n", + "\n", + "# load audio waveform and play it\n", + "waveform, sample_rate = Audio(mono=\"downmix\")(OWN_FILE)\n", + "IPythonAudio(data=waveform.squeeze(), rate=sample_rate, autoplay=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ctw4nLaPYnp_" + }, + "source": [ + "Simply replace `DEMO_FILE` by `OWN_FILE` in the rest of the notebook.\n", + "\n", + "Note, however, that unless you provide a groundtruth annotation in the next cell, you will (obviously) not be able to visualize groundtruth annotation nor evaluate the performance of the diarization pipeline quantitatively" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x9AQgDzFYnp_" + }, + "source": [ + "## Upload groundtruth (optional)\n", + "\n", + "The groundtruth file is expected to use the RTTM format, with one line per speech turn with the following convention:\n", + "\n", + "```\n", + "SPEAKER {file_name} 1 {start_time} {duration} {speaker_name} \n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iZaFudpDYnp_", + "outputId": "981274fa-e654-4091-c838-91c81f921e5d" + }, + "outputs": [ { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "uJWoQiJgYnp8", - "vscode": { - "languageId": "python" - } - }, - "outputs": [], - "source": [ - "!wget -q http://groups.inf.ed.ac.uk/ami/AMICorpusMirror/amicorpus/ES2004a/audio/ES2004a.Mix-Headset.wav\n", - "DEMO_FILE = {'uri': 'ES2004a.Mix-Headset', 'audio': 'ES2004a.Mix-Headset.wav'}" + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ], + "text/plain": [ + "" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "markdown", - "metadata": { - "id": "EPIapoCJYnp8" - }, - "source": [ - "Because AMI is a benchmarking dataset, it comes with manual annotations (a.k.a *groundtruth*). \n", - "Let us load and visualize the expected output of the speaker diarization pipeline.\n" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving sample.rttm to sample.rttm\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "Mmm0Q22JYnp8", - "vscode": { - "languageId": "python" - } - }, - "outputs": [], - "source": [ - "!wget -q https://raw.githubusercontent.com/pyannote/AMI-diarization-setup/main/only_words/rttms/test/ES2004a.rttm" + "data": { + "image/png": "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", + "text/plain": [ + "" ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "groundtruth_rttm, _ = google.colab.files.upload().popitem()\n", + "groundtruths = load_rttm(groundtruth_rttm)\n", + "if OWN_FILE['audio'] in groundtruths:\n", + " groundtruth = groundtruths[OWN_FILE['audio']]\n", + "else:\n", + " _, groundtruth = groundtruths.popitem()\n", + "groundtruth" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5MclWK2GYnp_" + }, + "source": [ + "# Speaker diarization with `pyannote.pipeline`\n", + "\n", + "We are about to run a full speaker diarization pipeline, that includes speaker segmentation, speaker embedding, and a final clustering step. **Brace yourself!**\n", + "\n", + "To load the speaker diarization pipeline, \n", + "\n", + "* accept the user conditions on [hf.co/pyannote/speaker-diarization-3.0](https://hf.co/pyannote/speaker-diarization-3.0)\n", + "* accept the user conditions on [hf.co/pyannote/segmentation-3.0](https://hf.co/pyannote/segmentation-3.0)\n", + "* login using `notebook_login` below" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 301, + "referenced_widgets": [ + "c8731777ce834e58a76a295076200cfc", + "859b12a6d95b4c6f987791ca848122b9", + "94756148d2e94a93ae233baba20af683", + "ba18cded436e486da34882d821d8f1eb", + "99898e6ee64a46bd832af112e79b58b7", + "79184c8c2a6f4b7493bb7f6983f18a09", + "ea95ffd922c0455d957120f034e541f8", + "13525aa369a9410a83343952ab511f3c", + "b2be65e192384c948fb8987d4cfca505", + "333b42ca7aa44788b1c22724eb11bcc3", + "0e382d66f09f4958a40baa7ab83c4ccb", + "6a45ce374e2e47ba9457d02e02522748", + "765485a1d3f941d28b79782dcffbf401", + "3499ef4dd9f243d9bef00b396e78ed69" + ] }, + "id": "r5u7VMb-YnqB", + "outputId": "c714a997-d4f8-417a-e5ad-0a4924333859" + }, + "outputs": [ { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 233 - }, - "id": "ToqCwl_FYnp9", - "outputId": "a1d9631f-b198-44d1-ff6d-ec304125a9f4", - "vscode": { - "languageId": "python" - } + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6e56329c30c0441c8d45df3975e75a76", + "version_major": 2, + "version_minor": 0 }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# load groundtruth\n", - "from pyannote.database.util import load_rttm\n", - "_, groundtruth = load_rttm('ES2004a.rttm').popitem()\n", - "\n", - "# visualize groundtruth\n", - "groundtruth" + "text/plain": [ + "VBox(children=(HTML(value='
" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.core import Segment, notebook\n", - "# make notebook visualization zoom on 600s < t < 660s time range\n", - "EXCERPT = Segment(600, 660)\n", - "notebook.crop = EXCERPT\n", - "\n", - "# visualize excerpt groundtruth\n", - "groundtruth" + "data": { + "image/png": "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\n", + "text/plain": [ + "" ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diarization" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DLhErS6wYnqB" + }, + "source": [ + "# Evaluation with `pyannote.metrics`\n", + "\n", + "Because groundtruth is available, we can evaluate the quality of the diarization pipeline by computing the [diarization error rate](http://pyannote.github.io/pyannote-metrics/reference.html#diarization)." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "id": "vNHQRTUIYnqB" + }, + "outputs": [], + "source": [ + "from pyannote.metrics.diarization import DiarizationErrorRate\n", + "metric = DiarizationErrorRate()\n", + "der = metric(groundtruth, diarization)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "9d0vKQ0fYnqB", + "outputId": "9a664753-cd84-4211-9153-d33e929bb252" + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "L3FQXT5FYnp-" - }, - "source": [ - "This nice visualization is brought to you by [`pyannote.core`](http://pyannote.github.io/pyannote-core/) and basically indicates when each speaker speaks. " - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "diarization error rate = 19.8%\n" + ] + } + ], + "source": [ + "print(f'diarization error rate = {100 * der:.1f}%')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Xz5QJV9nYnqB" + }, + "source": [ + "This implementation of diarization error rate is brought to you by [`pyannote.metrics`](http://pyannote.github.io/pyannote-metrics/).\n", + "\n", + "It can also be used to improve visualization by find the optimal one-to-one mapping between groundtruth and hypothesized speakers." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 230 }, + "id": "xMLf4mrYYnqB", + "outputId": "ed08bcc8-24c6-439c-a244-3a673ff480b0" + }, + "outputs": [ { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 62 - }, - "id": "rDhZ3bXEYnp-", - "outputId": "a82efe4e-2f9c-48bd-94fb-c62af3a3cb43", - "vscode": { - "languageId": "python" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.audio import Audio \n", - "from IPython.display import Audio as IPythonAudio\n", - "waveform, sr = Audio(mono=\"downmix\").crop(DEMO_FILE, EXCERPT)\n", - "IPythonAudio(waveform.flatten(), rate=sr)" + "data": { + "image/png": "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\n", + "text/plain": [ + "" ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mapping = metric.optimal_mapping(groundtruth, diarization)\n", + "diarization.rename_labels(mapping=mapping)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 230 }, + "id": "Z0ewsLlQYnqB", + "outputId": "8a8cd040-ee1d-48f7-d4be-eef9e08e9e55" + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "hkzox7QIYnp_" - }, - "source": [ - "# Processing your own audio file (optional)\n", - "\n", - "In case you just want to go ahead with the demo file, skip this section entirely.\n", - "\n", - "In case you want to try processing your own audio file, proceed with running this section. It will offer you to upload an audio file (preferably a `wav` file but all formats supported by [`SoundFile`](https://pysoundfile.readthedocs.io/en/latest/) should work just fine)." + "data": { + "image/png": "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\n", + "text/plain": [ + "" ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "groundtruth" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MxlrTbyPYnqB" + }, + "source": [ + "# Going further \n", + "\n", + "We have only scratched the surface in this introduction. \n", + "\n", + "More details can be found in the [`pyannote.audio` Github repository](https://github.com/pyannote/pyannote-audio).\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "include_colab_link": true, + "provenance": [] + }, + "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": "3.11.5" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "0125df9fa8e14b3db0e2bce299529812": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_407e250e244b4985b1ce8c9d32a8af7d", + "max": 318, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8127c4258e374ad986ce1f8b4c70f704", + "value": 318 + } }, - { - "cell_type": "markdown", - "metadata": { - "id": "3hmFmLzFYnp_" - }, - "source": [ - "## Upload audio file" - ] + "0821b47ae70444dfa38b84719c4836a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "xC05jFO_Ynp_", - "outputId": "c5502632-56ae-4adb-8bdc-112deedc8893", - "vscode": { - "languageId": "python" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " Upload widget is only available when the cell has been executed in the\n", - " current browser session. Please rerun this cell to enable.\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saving sample.wav to sample.wav\n" - ] - }, - { - "data": { - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } + "0adb304bf90f4079a4031caea1cfb924": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b4bf8076fdf4d19843a3246c8bd61ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0d10fb0edc9144b1a1fc1f2c9e322410": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d33fba0d78fb41f983c55f5cd2a0a740", + "placeholder": "​", + "style": "IPY_MODEL_fd47487fc8734594823f8afa00c4239d", + "value": "Downloading: 100%" + } + }, + "0d80273cabbc42ba9a408fb1144151c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0e382d66f09f4958a40baa7ab83c4ccb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "13525aa369a9410a83343952ab511f3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1600b9cd09c446e581b7912e35c9f56e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "16c0017f65b649f5ac5bebf1c955a1fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17856a72e4e948039a66c51e8244cb50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "183c55d5d3ce4058ae338c81344547c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_70efa83bf3ea45b4bd8cc41f57613328", + "IPY_MODEL_338747810ac74b4e83e356a01459c8a5", + "IPY_MODEL_ac0bcfa1ef6e4e78a7769c4cb2e8762f" ], - "source": [ - "import google.colab\n", - "own_file, _ = google.colab.files.upload().popitem()\n", - "OWN_FILE = {'audio': own_file}\n", - "notebook.reset()\n", - "\n", - "# load audio waveform and play it\n", - "waveform, sample_rate = Audio(mono=\"downmix\")(OWN_FILE)\n", - "IPythonAudio(data=waveform.squeeze(), rate=sample_rate, autoplay=True)" - ] + "layout": "IPY_MODEL_6efb7939bb954dc8ba116680139eb257" + } }, - { - "cell_type": "markdown", - "metadata": { - "id": "ctw4nLaPYnp_" - }, - "source": [ - "Simply replace `DEMO_FILE` by `OWN_FILE` in the rest of the notebook.\n", - "\n", - "Note, however, that unless you provide a groundtruth annotation in the next cell, you will (obviously) not be able to visualize groundtruth annotation nor evaluate the performance of the diarization pipeline quantitatively" - ] + "1946386483ed4947a2184cdb4ea6e434": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } }, - { - "cell_type": "markdown", - "metadata": { - "id": "x9AQgDzFYnp_" - }, - "source": [ - "## Upload groundtruth (optional)\n", - "\n", - "The groundtruth file is expected to use the RTTM format, with one line per speech turn with the following convention:\n", - "\n", - "```\n", - "SPEAKER {file_name} 1 {start_time} {duration} {speaker_name} \n", - "```" - ] + "23d4e25ec6c541818d5927b69576d278": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "iZaFudpDYnp_", - "outputId": "981274fa-e654-4091-c838-91c81f921e5d", - "vscode": { - "languageId": "python" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " Upload widget is only available when the cell has been executed in the\n", - " current browser session. Please rerun this cell to enable.\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saving sample.rttm to sample.rttm\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } + "27f6f437c5264368bc2c679942ad1e53": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28004251b0e44a6c9dfa7ce1b30dcb18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e98cf7a63c814ffd94f69928f0700ebf", + "IPY_MODEL_6a4dee55cbae4959bd7fe3c4d92242b1", + "IPY_MODEL_8dba487876124827919079519406ecb8" ], - "source": [ - "groundtruth_rttm, _ = google.colab.files.upload().popitem()\n", - "groundtruths = load_rttm(groundtruth_rttm)\n", - "if OWN_FILE['audio'] in groundtruths:\n", - " groundtruth = groundtruths[OWN_FILE['audio']]\n", - "else:\n", - " _, groundtruth = groundtruths.popitem()\n", - "groundtruth" - ] + "layout": "IPY_MODEL_5c211704f90946afbae2f66a7586ce70" + } }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "id": "5MclWK2GYnp_" - }, - "source": [ - "# Speaker diarization with `pyannote.pipeline`\n", - "\n", - "We are about to run a full speaker diarization pipeline, that includes speaker segmentation, speaker embedding, and a final clustering step. **Brace yourself!**\n", - "\n", - "To load the speaker diarization pipeline, \n", - "\n", - "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization)\n", - "* accept the user conditions on [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation)\n", - "* login using `notebook_login` below" - ] + "2b2d7912186a49dd9891ae12c77482c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 301, - "referenced_widgets": [ - "c8731777ce834e58a76a295076200cfc", - "859b12a6d95b4c6f987791ca848122b9", - "94756148d2e94a93ae233baba20af683", - "ba18cded436e486da34882d821d8f1eb", - "99898e6ee64a46bd832af112e79b58b7", - "79184c8c2a6f4b7493bb7f6983f18a09", - "ea95ffd922c0455d957120f034e541f8", - "13525aa369a9410a83343952ab511f3c", - "b2be65e192384c948fb8987d4cfca505", - "333b42ca7aa44788b1c22724eb11bcc3", - "0e382d66f09f4958a40baa7ab83c4ccb", - "6a45ce374e2e47ba9457d02e02522748", - "765485a1d3f941d28b79782dcffbf401", - "3499ef4dd9f243d9bef00b396e78ed69" - ] - }, - "id": "r5u7VMb-YnqB", - "outputId": "c714a997-d4f8-417a-e5ad-0a4924333859", - "vscode": { - "languageId": "python" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Login successful\n", - "Your token has been saved to /root/.huggingface/token\n" - ] - } + "2cbf0faadd4842c8b22e10541ff9de4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d7a0b901d7044d5b1f273a3e9bea560": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "304e9682570b4abeb1719001c04449d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "32accb0adfa24c62a75c15c8ec88df8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_23d4e25ec6c541818d5927b69576d278", + "max": 128619, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_54d9456703324160aced03ee5fef2943", + "value": 128619 + } + }, + "333b42ca7aa44788b1c22724eb11bcc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "338747810ac74b4e83e356a01459c8a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4c1e9affaba4045a3ec903091b6f454", + "max": 500, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1946386483ed4947a2184cdb4ea6e434", + "value": 500 + } + }, + "341615c971b04033b7293d82fc40f35c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3499ef4dd9f243d9bef00b396e78ed69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "358c3a67f8b54c4c899e095611fa116b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38b3054ad59549e4b4f2de4697139a87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0adb304bf90f4079a4031caea1cfb924", + "placeholder": "​", + "style": "IPY_MODEL_40021e0b59fe4e1e9bac351dbec57c6c", + "value": "Downloading: 100%" + } + }, + "3bd33a372aad4c438f64d73c97f14c6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "40021e0b59fe4e1e9bac351dbec57c6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "404f7ce06a01470fbb0b747981d00e84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_38b3054ad59549e4b4f2de4697139a87", + "IPY_MODEL_7d90af87c9574f5ca21fca058c39bf02", + "IPY_MODEL_fee75343289f42fb8d6dfb4bf26fe368" ], - "source": [ - "from huggingface_hub import notebook_login\n", - "notebook_login()" - ] + "layout": "IPY_MODEL_f21c0c6379d74898ac6aadcb6fc14a8a" + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 273, - "referenced_widgets": [ - "183c55d5d3ce4058ae338c81344547c5", - "70efa83bf3ea45b4bd8cc41f57613328", - "338747810ac74b4e83e356a01459c8a5", - "ac0bcfa1ef6e4e78a7769c4cb2e8762f", - "6efb7939bb954dc8ba116680139eb257", - "6242493d251a47609c0c44f1dbe82958", - "f439c1de68ac4c799d81fdb29d053d10", - "e4c1e9affaba4045a3ec903091b6f454", - "1946386483ed4947a2184cdb4ea6e434", - "549a30c85c47466eadedbd24da42e304", - "bedc7d916b9745f097094c5c51a81f06", - "d12f07e25bf5422facc38c3463700994", - "eae11f84c2644ada8295b445c924baec", - "bcf766d2a2c641f0aa2af596c7da1b18", - "74bf69aa6eaa4a8594b2ea9a0fb20957", - "2d7a0b901d7044d5b1f273a3e9bea560", - "2cbf0faadd4842c8b22e10541ff9de4e", - "ab32c7daa1d9404fb921f39fbc4fc05c", - "ee537ee5470f4d7b816a8c8f96948b4d", - "652e97509a914f3b914665c4889c6d11", - "ebc9801e164a44b3b6f8dc7f590e1c79", - "0821b47ae70444dfa38b84719c4836a6", - "c3358d32ac814ea6bc5714402c5bc62d", - "ecd8e5e364d34ea8bfbba4fbd467384d", - "0125df9fa8e14b3db0e2bce299529812", - "e3169ca885e04536a709d5751173ce9a", - "70abdfd99be84f7b9b8d24fee9eec022", - "554e567a83b348f88092c6ba01830930", - "6e334cad2e94462cae6e722bd6f11a9e", - "407e250e244b4985b1ce8c9d32a8af7d", - "8127c4258e374ad986ce1f8b4c70f704", - "358c3a67f8b54c4c899e095611fa116b", - "e1c9df12fa034c93a9b3530ea4a7c5aa", - "404f7ce06a01470fbb0b747981d00e84", - "38b3054ad59549e4b4f2de4697139a87", - "7d90af87c9574f5ca21fca058c39bf02", - "fee75343289f42fb8d6dfb4bf26fe368", - "f21c0c6379d74898ac6aadcb6fc14a8a", - "0adb304bf90f4079a4031caea1cfb924", - "40021e0b59fe4e1e9bac351dbec57c6c", - "ed169fd606274f2ebbb3e8f32ab42431", - "304e9682570b4abeb1719001c04449d6", - "16c0017f65b649f5ac5bebf1c955a1fd", - "5e2c207db5424f91829bf5c52040a9f2", - "8011d68253ac4080a637659ef3383dc4", - "e928540e99564d808cb2d12c92daa498", - "fc9a3c4ae0a947ec91a227360a80f602", - "f91dcd9f30c743d69f9d4b7e8d1beba5", - "6ede83f870a24e71b5182fcc458cdc42", - "c9974003727a401797953ef2885db5a2", - "77a361d1ff214e8799891bbeb28a0789", - "27f6f437c5264368bc2c679942ad1e53", - "e7728d9c55e44274966f8f6dbc445c54", - "2b2d7912186a49dd9891ae12c77482c7", - "1600b9cd09c446e581b7912e35c9f56e", - "28004251b0e44a6c9dfa7ce1b30dcb18", - "e98cf7a63c814ffd94f69928f0700ebf", - "6a4dee55cbae4959bd7fe3c4d92242b1", - "8dba487876124827919079519406ecb8", - "5c211704f90946afbae2f66a7586ce70", - "aba21021d3bb4565a58ffa40049810db", - "f7812fa7fbf744c1b261b985d085e28e", - "d7071582bfbe4ec4b2c3c9843e5481ae", - "0d80273cabbc42ba9a408fb1144151c9", - "67fcc38a1e5d4eb39381685447e397de", - "0b4bf8076fdf4d19843a3246c8bd61ac", - "d182e37b4a404158bee8446fc2728bd9", - "603e99f45afb4910a99f7684ffd21b6a", - "d13ba6030aff42bca48c72ff071c44c0", - "a899f4bc6ed842d397723cca582669e6", - "a02030ba8f324d93a7ed6cc793d70a3b", - "b26354d0278f447d92c7e1ad4c211d64", - "3bd33a372aad4c438f64d73c97f14c6a", - "c8e0c9a60ef34d2caee9d55a3c21c3d4", - "764aa53d75324d73ab06936c52fd8fc8", - "341615c971b04033b7293d82fc40f35c", - "17856a72e4e948039a66c51e8244cb50", - "41eb32a6fef141ff9cc3ce6e4d771822", - "0d10fb0edc9144b1a1fc1f2c9e322410", - "32accb0adfa24c62a75c15c8ec88df8c", - "bf299285318b4a04a88569cc581ecd75", - "ac2950d08fc145ba9eb9cf5824b1ee18", - "d33fba0d78fb41f983c55f5cd2a0a740", - "fd47487fc8734594823f8afa00c4239d", - "23d4e25ec6c541818d5927b69576d278", - "54d9456703324160aced03ee5fef2943", - "bacfb50c001047c4824a05c9f2ee2e40", - "c53a1cf68fcd4388abf1f0379891089a" - ] - }, - "id": "lUq1UvoJYnqB", - "outputId": "8c052808-d0b2-4f2e-8771-f86114ae3fe3", - "vscode": { - "languageId": "python" - } - }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "183c55d5d3ce4058ae338c81344547c5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Downloading: 0%| | 0.00/500 [00:00" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } + "54d9456703324160aced03ee5fef2943": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "554e567a83b348f88092c6ba01830930": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c211704f90946afbae2f66a7586ce70": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e2c207db5424f91829bf5c52040a9f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "603e99f45afb4910a99f7684ffd21b6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b26354d0278f447d92c7e1ad4c211d64", + "placeholder": "​", + "style": "IPY_MODEL_3bd33a372aad4c438f64d73c97f14c6a", + "value": "Downloading: 100%" + } + }, + "6242493d251a47609c0c44f1dbe82958": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "652e97509a914f3b914665c4889c6d11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "67fcc38a1e5d4eb39381685447e397de": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a45ce374e2e47ba9457d02e02522748": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + }, + "6a4dee55cbae4959bd7fe3c4d92242b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d7071582bfbe4ec4b2c3c9843e5481ae", + "max": 1921, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0d80273cabbc42ba9a408fb1144151c9", + "value": 1921 + } + }, + "6e334cad2e94462cae6e722bd6f11a9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6ede83f870a24e71b5182fcc458cdc42": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6efb7939bb954dc8ba116680139eb257": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70abdfd99be84f7b9b8d24fee9eec022": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70efa83bf3ea45b4bd8cc41f57613328": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6242493d251a47609c0c44f1dbe82958", + "placeholder": "​", + "style": "IPY_MODEL_f439c1de68ac4c799d81fdb29d053d10", + "value": "Downloading: 100%" + } + }, + "74bf69aa6eaa4a8594b2ea9a0fb20957": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ebc9801e164a44b3b6f8dc7f590e1c79", + "placeholder": "​", + "style": "IPY_MODEL_0821b47ae70444dfa38b84719c4836a6", + "value": " 17.7M/17.7M [00:00<00:00, 54.3MB/s]" + } + }, + "764aa53d75324d73ab06936c52fd8fc8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "765485a1d3f941d28b79782dcffbf401": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "77a361d1ff214e8799891bbeb28a0789": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "79184c8c2a6f4b7493bb7f6983f18a09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "7d90af87c9574f5ca21fca058c39bf02": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ed169fd606274f2ebbb3e8f32ab42431", + "max": 1920, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_304e9682570b4abeb1719001c04449d6", + "value": 1920 + } + }, + "8011d68253ac4080a637659ef3383dc4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e928540e99564d808cb2d12c92daa498", + "IPY_MODEL_fc9a3c4ae0a947ec91a227360a80f602", + "IPY_MODEL_f91dcd9f30c743d69f9d4b7e8d1beba5" ], - "source": [ - "diarization" - ] + "layout": "IPY_MODEL_6ede83f870a24e71b5182fcc458cdc42" + } }, - { - "cell_type": "markdown", - "metadata": { - "id": "DLhErS6wYnqB" - }, - "source": [ - "# Evaluation with `pyannote.metrics`\n", - "\n", - "Because groundtruth is available, we can evaluate the quality of the diarization pipeline by computing the [diarization error rate](http://pyannote.github.io/pyannote-metrics/reference.html#diarization)." - ] + "8127c4258e374ad986ce1f8b4c70f704": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "vNHQRTUIYnqB", - "vscode": { - "languageId": "python" - } - }, - "outputs": [], - "source": [ - "from pyannote.metrics.diarization import DiarizationErrorRate\n", - "metric = DiarizationErrorRate()\n", - "der = metric(groundtruth, diarization)" - ] + "859b12a6d95b4c6f987791ca848122b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ea95ffd922c0455d957120f034e541f8", + "placeholder": "​", + "style": "IPY_MODEL_13525aa369a9410a83343952ab511f3c", + "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "9d0vKQ0fYnqB", - "outputId": "9a664753-cd84-4211-9153-d33e929bb252", - "vscode": { - "languageId": "python" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "diarization error rate = 19.2%\n" - ] - } + "8dba487876124827919079519406ecb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_67fcc38a1e5d4eb39381685447e397de", + "placeholder": "​", + "style": "IPY_MODEL_0b4bf8076fdf4d19843a3246c8bd61ac", + "value": " 1.92k/1.92k [00:00<00:00, 63.2kB/s]" + } + }, + "94756148d2e94a93ae233baba20af683": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "PasswordModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "PasswordModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Token:", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_b2be65e192384c948fb8987d4cfca505", + "placeholder": "​", + "style": "IPY_MODEL_333b42ca7aa44788b1c22724eb11bcc3", + "value": "" + } + }, + "99898e6ee64a46bd832af112e79b58b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_765485a1d3f941d28b79782dcffbf401", + "placeholder": "​", + "style": "IPY_MODEL_3499ef4dd9f243d9bef00b396e78ed69", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks.
" + } + }, + "a02030ba8f324d93a7ed6cc793d70a3b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a899f4bc6ed842d397723cca582669e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_341615c971b04033b7293d82fc40f35c", + "placeholder": "​", + "style": "IPY_MODEL_17856a72e4e948039a66c51e8244cb50", + "value": " 5.53M/5.53M [00:00<00:00, 21.7MB/s]" + } + }, + "ab32c7daa1d9404fb921f39fbc4fc05c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aba21021d3bb4565a58ffa40049810db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac0bcfa1ef6e4e78a7769c4cb2e8762f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_549a30c85c47466eadedbd24da42e304", + "placeholder": "​", + "style": "IPY_MODEL_bedc7d916b9745f097094c5c51a81f06", + "value": " 500/500 [00:00<00:00, 5.05kB/s]" + } + }, + "ac2950d08fc145ba9eb9cf5824b1ee18": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b26354d0278f447d92c7e1ad4c211d64": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b2be65e192384c948fb8987d4cfca505": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba18cded436e486da34882d821d8f1eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_0e382d66f09f4958a40baa7ab83c4ccb", + "style": "IPY_MODEL_6a45ce374e2e47ba9457d02e02522748", + "tooltip": "" + } + }, + "bacfb50c001047c4824a05c9f2ee2e40": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bcf766d2a2c641f0aa2af596c7da1b18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee537ee5470f4d7b816a8c8f96948b4d", + "max": 17719103, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_652e97509a914f3b914665c4889c6d11", + "value": 17719103 + } + }, + "bedc7d916b9745f097094c5c51a81f06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bf299285318b4a04a88569cc581ecd75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bacfb50c001047c4824a05c9f2ee2e40", + "placeholder": "​", + "style": "IPY_MODEL_c53a1cf68fcd4388abf1f0379891089a", + "value": " 129k/129k [00:00<00:00, 155kB/s]" + } + }, + "c3358d32ac814ea6bc5714402c5bc62d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ecd8e5e364d34ea8bfbba4fbd467384d", + "IPY_MODEL_0125df9fa8e14b3db0e2bce299529812", + "IPY_MODEL_e3169ca885e04536a709d5751173ce9a" ], - "source": [ - "print(f'diarization error rate = {100 * der:.1f}%')" - ] + "layout": "IPY_MODEL_70abdfd99be84f7b9b8d24fee9eec022" + } }, - { - "cell_type": "markdown", - "metadata": { - "id": "Xz5QJV9nYnqB" - }, - "source": [ - "This implementation of diarization error rate is brought to you by [`pyannote.metrics`](http://pyannote.github.io/pyannote-metrics/).\n", - "\n", - "It can also be used to improve visualization by find the optimal one-to-one mapping between groundtruth and hypothesized speakers." - ] + "c53a1cf68fcd4388abf1f0379891089a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 230 - }, - "id": "xMLf4mrYYnqB", - "outputId": "ed08bcc8-24c6-439c-a244-3a673ff480b0", - "vscode": { - "languageId": "python" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } + "c8731777ce834e58a76a295076200cfc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_859b12a6d95b4c6f987791ca848122b9", + "IPY_MODEL_94756148d2e94a93ae233baba20af683", + "IPY_MODEL_ba18cded436e486da34882d821d8f1eb", + "IPY_MODEL_99898e6ee64a46bd832af112e79b58b7" ], - "source": [ - "mapping = metric.optimal_mapping(groundtruth, diarization)\n", - "diarization.rename_labels(mapping=mapping)" - ] + "layout": "IPY_MODEL_79184c8c2a6f4b7493bb7f6983f18a09" + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 230 - }, - "id": "Z0ewsLlQYnqB", - "outputId": "8a8cd040-ee1d-48f7-d4be-eef9e08e9e55", - "vscode": { - "languageId": "python" - } - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABjwAAADyCAYAAAD5q2z1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3RV5Zk/8CeQCzEhCRcDwXJTRLygoHQs6kztVAHrEmtntFJEpY5WB7V2quO4vNE6WmlrqaOzdGS0Y50q01bbsVbrXSvC4JVaKwuRCrZKoCYSAkJAsn9/8OPUlEsSck5Odvh81spaZO/3vPvd593nOfucL9m7IEmSJAAAAAAAAFKsR74HAAAAAAAA0FECDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYHHDpx99tlRUFCw3c9bb72103WTJk3KPH7YsGE7bHPjjTdm2rzzzjtx4oknxl577RXV1dVx2WWXxUcffZRZv3LlyvjSl74UI0eOjB49esQll1yy3TgfeOCBGDduXFRVVUVZWVmMGTMm7rnnntw+OSmXlrmNiFizZk3MmDEjampqoqSkJEaOHBkPP/xw7p6cFNs2d+eff/5262bMmBEFBQVx9tlnt2jbVeZ5m7lz50ZBQUF8/vOf7+Cz0b1le64jIubPnx+f+9znok+fPtGrV68YPXp0fO9734stW7a0aFdfXx9Tp06NioqKqKqqinPOOSfWrVuXWb9x48Y4++yzY/To0VFYWLjDuXzmmWd2OKba2tosPDsAAAAAe7bCfGz0g/WbOnV7fcqK2/2YSZMmxQ9+8IMWy/bee++drispKWnx+ze/+c0499xzWyzr3bt3RERs2bIlTjzxxBg4cGDMnz8/Vq5cGWeeeWYUFRXFDTfcEBERTU1Nsffee8dVV10Vs2fP3uEY+/btG1deeWWMGjUqiouL46GHHorp06dHdXV1TJw4sd373FENTQ2dur3Kksrdelwa5nbTpk1x/PHHR3V1dfz0pz+NffbZJ1asWBFVVVW7tc8dtaFhY6dur7SyV7sfM3jw4Jg7d27Mnj07SktLI2LrF9D33ntvDBkypEXbrjLP2yxfvjwuvfTS+Ou//ut273c2bamr69Tt9ezXb7cel825/tnPfhannXZaTJ8+PZ5++umoqqqKJ554Iv75n/85FixYED/+8Y+joKAgIiKmTp0aK1eujMcffzw2b94c06dPj/POOy/uvffeiNh6XJSWlsbFF18c999//y73YcmSJVFRUZH5vbq6ereeCwAAAAD+LC+BxwnffrpTt/d/32j/l/8lJSUxcODAdq/bpnfv3jtt89hjj8Ubb7wRTzzxRAwYMCDGjBkT1113XVx++eUxc+bMKC4ujmHDhsXNN98cERF33XXXDvs59thjW/z+1a9+Ne6+++6YN29eXgKPaY98qVO39+Dnf7lbj0vD3N51111RX18f8+fPj6KioojY+lcH+fLDM3/aqdv7yv+e0e7HHH744bFs2bJ44IEHYurUqRGx9a+ghgwZEsOHD2/RtqvMc8TWL8mnTp0a3/jGN+K5556LNWvWtGe3s6r20DGdur193v3Dbj0uW3O9fv36OPfcc2Py5Mlxxx13ZJb/wz/8QwwYMCAmT54cP/7xj+OLX/xiLF68OH71q1/Fiy++GOPGjYuIiFtuuSU+97nPxXe/+90YNGhQlJWVxW233RYREc8///wu57K6ujpvASYAAABAd+WSVnmwYMGCGD16dAwYMCCzbOLEibF27dr43e9+t1t9JkkSTz75ZCxZsiT+5m/+JltDpZ2yNbcPPvhgjB8/PmbMmBEDBgyIQw45JG644YbtLrFDS1/+8pdb/G/+u+66K6ZPn5717WTzNfzNb34zqqur45xzzsn2MLu1bMz1Y489FnV1dXHppZdut+6kk06KkSNHxn333RcRW+e8qqoqE3ZERBx33HHRo0ePWLhwYbvHP2bMmKipqYnjjz8+nn/++XY/HgAAAIDtCTx24qGHHory8vLMz6mnnrrTdeXl5ZnL2Gxz+eWXb9fmueeei4iI2traFl+URkTm9/Zex72hoSHKy8ujuLg4TjzxxLjlllvi+OOP351d3mOkYW5///vfx09/+tPYsmVLPPzww3H11VfHTTfdFP/6r/+6u7u9RzjjjDNi3rx5sWLFilixYkU8//zzccYZ2/+1SFeZ53nz5sWdd94Zc+bMae+u7vGyMddvvvlmREQceOCBO9zGqFGjMm1qa2u3u+xUYWFh9O3bt11zXlNTE7fffnvcf//9cf/998fgwYPj2GOPjVdeeaXNfQAAAACwY3m5pFUafOYzn8lcmiQioqysbKfrIrbeT+PjLrvsssyNc7fZZ599sj7O3r17x6JFi2LdunXx5JNPxj/90z/Fvvvuu93lrvizNMxtc3NzVFdXxx133BE9e/aMI444It599934zne+E9dee21Wt9Wd7L333nHiiSfGf/3Xf0WSJHHiiSdG//79t2vXFea5sbExpk2bFnPmzNnhGNm1bM51kiQ5HevHHXDAAXHAAQdkfj/qqKNi2bJlMXv27Ljnnns6bRwAAAAA3VFeAo9H/vkz+dhsu5SVlcWIESPavW6b/v3777TNwIED44UXXmixbNWqVZl17dGjR4/MdsaMGROLFy+Ob33rW3kJPO454d5O3+buSMPc1tTURFFRUfTs2TOz7MADD4za2trYtGlTFBcXt7mvbDjzh3/fqdvriC9/+ctx4YUXRkTEv//7v++wTVeY52XLlsXy5cvjpJNOyixrbm6OiK1/ObBkyZLYb7/92tRXtgx8bVGnbq+jOjrXI0eOjIiIxYsXx1FHHbXd+sWLF8dBBx0UEVvndfXq1S3Wf/TRR1FfX9/uuv2X/uqv/irmzZvXoT4AAAAAyFPg0aesc7+s7WrGjx8f119/faxevTpziZTHH388KioqMl+u7a7m5uZoamrKxjDbrbKkMi/b7UqyNbdHH3103HvvvdHc3Bw9emy98tybb74ZNTU1nR52RESUVvbq9G3urkmTJsWmTZuioKAgJk6cmJNtZGOeR40aFb/97W9bLLvqqquisbExbr755hg8eHDWx92anv36dfo2O6Kjcz1hwoTo27dv3HTTTdsFHg8++GAsXbo0rrvuuojYOudr1qyJl19+OY444oiIiHjqqaeiubk5jjzyyA7tx6JFi6KmpqZDfQAAAADgkla7pampabtrthcWFra4nEpjY+N2bfbaa6+oqKiICRMmxEEHHRTTpk2Lb3/721FbWxtXXXVVzJgxI0pKSjLtFy3a+r+t161bF3/6059i0aJFUVxcnPlC9Vvf+laMGzcu9ttvv2hqaoqHH3447rnnnu0u30LbdZW5veCCC+LWW2+Nr371q3HRRRfF0qVL44YbboiLL744V7vebfTs2TMWL16c+feOdIV57tWrVxxyyCEt+q+qqoqI2G45O9bRuS4rK4v/+I//iNNPPz3OO++8uPDCC6OioiKefPLJuOyyy+Lv//7v47TTTouIrX9hNWnSpDj33HPj9ttvj82bN8eFF14Yp59+egwaNCjT9xtvvBGbNm2K+vr6aGxszBwDY8aMiYiI73//+zF8+PA4+OCDY+PGjfGf//mf8dRTT8Vjjz2W9ecHAAAAYI+TsJ2zzjorOfnkk3e6LiK2+znggAMybYYOHbrDNl/5ylcybZYvX56ccMIJSWlpadK/f//k61//erJ58+YW29pRH0OHDs2sv/LKK5MRI0YkvXr1Svr06ZOMHz8+mTt3bnafjG4mLXObJEkyf/785Mgjj0xKSkqSfffdN7n++uuTjz76KHtPRjeyq3lNkiQ5+eSTk7POOivTtivNc3v2g+zPdZIkya9//etk4sSJSUVFRVJcXJwcfPDByXe/+93tXm91dXXJlClTkvLy8qSioiKZPn160tjY2KLNzo6dbWbNmpXst99+Sa9evZK+ffsmxx57bPLUU0918FkBAAAAIEmSpCBJOvFurQAAAAAAADnQI98DAAAAAAAA6CiBBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKlXmKuOm5ub47333ovevXtHQUFBrjYDAAAAAACkQJIk0djYGIMGDYoePbL/9xg5Czzee++9GDx4cK66BwAAAAAAUugPf/hDfOITn8h6vzkLPHr37h0RWwdeUVGRq80AAAAAAAApsHbt2hg8eHAmP8i2nAUe2y5jVVFRIfAAAAAAAAAiInJ2Gww3LQcAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6OQ881td/mOtNQLf0x5Xvxnd/clP8ceW7+R4K3Uz9xvq4d/GPon5jfURsrdMv3febrNbrXPSZZltWrYq1N30vtqxale+hZE132KdsHadpOt7/8vXf0XaQbbk49j7e5/uNTTHn6bfi/camrPXPnq2zjil1GSC3ukud7S77EdG99oXOlfPAY8OajbneBHRLtXW18euip6K2rjbfQ6Gb+WBjfcxdcm988P9PGj78YEO8PPe38eEHG7K2jVz0mWZbVq+Oxu/Nji2rV+d7KFnTHfYpW8dpmo73v3z9d7QdZFsujr2P9/l+Y1Pc+cwygQdZ01nHlLoMkFvdpc52l/2I6F77QudySSsAAAAAACD1BB4AAAAAAEDqFeZ6A03rN8WGBpe1gvba9OHmiIhY/9H6aGhqyPNo6E7WbVq3w+VN67JXr5vWbcpKP91N85qG2FJXl+9hZEXzmu5Tlzp67KfxeF+3ad0u31t2Viegs7R2jLa3r7/UuGFzfLA+fa9dup7GDZs7dXvZfG0A8Gfd7fy3O7xfdLc5ofPkPPB49Ppno7SoNNebgW6noV99xOSIm5bPilie79GwJ/jlNU/mewjdXt3pU/I9BHZgTzz2r55/Zb6HALuU62P0oh++lNP+IVfUbwDawvsFezKXtAIAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEi9nN/DY+KVn45hhwzJ9Wag23l1yaKY996j8fVhl8eYAw/L93DoRpY3vL3D63me+M3PRr9hfbKyjbrlH+yR90VoTb+590XRQQfmexhZsfmNxd3mniQdPfbTeLxfd9T1Maxy+E7X76xOQGdp7Rhtjx0dz7ecOS5GDOydlf7Zs71V29ip94TJ5msDgD/rbue/3eH9orvNCZ0n54FHSVlxlFb2yvVmoNsp3qsoIiLKCsuisqQyz6OhOykvLt/h8pLy7NXrkvLirPTT3fSoqoye/frlexhZsaWq+9Sljh77aTzey4vLd/nesrM6AZ2ltWO0vX39pd6lRdGnLH2vXbqe3qVFnbq9bL42APiz7nb+2x3eL7rbnNB5XNIKAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6vWcOXPmzFx03NTUFDfeeGP8y7/8S/SucpMZaK/mLUk0Ll8fnxr1qajoXZHv4dDN9OpZGqP3PjRKC0sjIqKotDAGHTIgirN4481c9JlmBWVlUTJ+fPQo7z7vid1hn7J1nKbpeP/L139H20G25eLY+3ifpcU944jhfWOvksKs9c+erbOOKXUZILe6S53tLvsR0b32hT/blhtcccUVUVJSkvX+C5IkSbLea0SsXbs2Kisro6GhISoqfFkLAAAAAAB7slznBi5pBQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8uoH6jfVx7+IfRf3G+i7RT67taJwdHfv7jU0x5+m34v3Gpqy0y5Zcba+z94PcM6fp1hXmryuMAei61AjypS3n+bvzWWDLqlWx9qbvxZZVq3ZrXB19PLBVe95fvBd1nnw91+Y4+zyndEV1OT4eBR7dwAcb62Puknvjgw4GFdnqJ9d2NM6Ojv39xqa485llbQo82tIuW3K1vc7eD3LPnKZbV5i/rjAGoOtSI8iXtpzn785ngS2rV0fj92bHltWrd2tcHX08sFV73l+8F3WefD3X5jj7PKd0RXXrBB4AAAAAAAC7JPAAAAAAAABST+ABAAAAAACkXmG+B0D2rNu0LhqaGjr0+DT5+P5ma+yNGzbHB+s37XJ9PrQ2rt3pj+4p28cKnaMrvSYdQ8COdKU6xZ5pV591OvJZoHlNQ2ypq9utxwHZ05ZzUO9Fna+zPxuY49zxOY+upHHDRzntX+DRjVw9/8p8D6FT5WJ/L/rhS1nvMxu66rjoehwrdJRjCICuKFefdepOn5KTfoH2cQ7aNZmX7sNc0pV81LQ+p/27pBUAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDquYdHN3LdUdfHsMrhu/345Q1vp+o+IB/f32yN/ZYzx8WIgb13uv6t2sa8XPewtXG1V772g9zL9rFC5+hKr0nHELAjXalOsWfa1WedjnwW6Df3vig66MB2P27zG4vd/wOyqC3noN6LOl9nfzYwx7njcx5dyaKl78Xfzspd/wKPbqS8uDwqSyo79Pg0+fj+ZmvsvUuLok9Z8S7X50Nr49qd/uiesn2s0Dm60mvSMQTsSFeqU+yZdvVZpyOfBXpUVUbPfv3a/bgtVbv/uQvYXlvOQb0Xdb7O/mxgjnPH5zy6kt6luY0kXNIKAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9XrOnDlzZi46bmpqihtvvDGuuOKKKCkpycUm+JhePUtj9N6HRmlhaZfoJ9d2NM6Ojr20uGccMbxv7FWy6+vItbVdtuRqe529H+SeOU23rjB/XWEMQNelRpAvbTnP353PAgVlZVEyfnz0KN+9e4B09PHAVu15f/Fe1Hny9Vyb4+zznNLVNDU1xc3f+07OcoOCJEmSrPcaEWvXro3KyspoaGiIioqKXGwCAAAAAABIiVznBi5pBQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN47CHeb2yKOU+/Fe83NnWoDQDs6eo31se9i38U9Rvrd7kMAAAA6FwCjz3E+41Nceczy1oNPFprAwB7ug821sfcJffGBx8LN3a0DAAAAOhcAg8AAAAAACD1BB4AAAAAAEDqFeZ7AHSuxg2b44P1m3a6DgBom3Wb1kVDU0Pm3wAAAEB+CTz2MBf98KV8DwEAuoWr51+Z7yEAAAAAH+OSVgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKnnHh57mFvOHBcjBvbe4bq3ahvd4wMA2ui6o66PYZXDIyJiecPb7ukBAAAAeSbw2MP0Li2KPmXFO10HALRNeXF5VJZUZv4NAAAA5JdLWgEAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gcceon/vkjjn2P2if++SDrUBgD1dn1594/QDvhR9evXd5TIAAACgcxUkSZLkouO1a9dGZWVlNDQ0REVFRS42AQAAAAAApESucwN/4QEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1CnPVcZIkERGxdu3aXG0CAAAAAABIiW15wbb8INtyFnjU1dVFRMTgwYNztQkAAAAAACBl6urqorKyMuv95izw6Nu3b0REvPPOOzkZOJAOa9eujcGDB8cf/vCHqKioyPdwgDxQBwB1AIhQCwB1AIhoaGiIIUOGZPKDbMtZ4NGjx9bbg1RWVipgQFRUVKgFsIdTBwB1AIhQCwB1APhzfpD1fnPSKwAAAAAAQCcSeAAAAAAAAKnXc+bMmTNz1nnPnnHsscdGYWHOrpwFpIBaAKgDgDoARKgFgDoA5LYOFCRJkmS9VwAAAAAAgE7kklYAAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABSr92Bx7vvvhtnnHFG9OvXL0pLS2P06NHx0ksvZdYnSRLXXHNN1NTURGlpaRx33HGxdOnSFn3U19fH1KlTo6KiIqqqquKcc86JdevWdXxvgE7RWh144IEHYsKECdGvX78oKCiIRYsWbdfHxo0bY8aMGdGvX78oLy+Pv/u7v4tVq1Z15m4AHbSrWrB58+a4/PLLY/To0VFWVhaDBg2KM888M957770WfTgngHRr7Zxg5syZMWrUqCgrK4s+ffrEcccdFwsXLmzRhzoA6dZaHfi4888/PwoKCuL73/9+i+XqAKRfa7Xg7LPPjoKCghY/kyZNatGHWgDp1pZzgsWLF8fkyZOjsrIyysrK4pOf/GS88847mfXZ+L6wXYHHBx98EEcffXQUFRXFI488Em+88UbcdNNN0adPn0ybb3/72/Fv//Zvcfvtt8fChQujrKwsJk6cGBs3bsy0mTp1avzud7+Lxx9/PB566KH49a9/Heedd167Bg7kR1vqwPr16+OYY46JWbNm7bSfr33ta/GLX/wifvKTn8Szzz4b7733XnzhC1/ojF0AsqC1WvDhhx/GK6+8EldffXW88sor8cADD8SSJUti8uTJLfpxTgDp1ZZzgpEjR8att94av/3tb2PevHkxbNiwmDBhQvzpT3/KtFEHIL3aUge2+dnPfhb/93//F4MGDdpunToA6dbWWjBp0qRYuXJl5ue+++5rsV4tgPRqSx1YtmxZHHPMMTFq1Kh45pln4rXXXourr746evXqlWmTle8Lk3a4/PLLk2OOOWan65ubm5OBAwcm3/nOdzLL1qxZk5SUlCT33XdfkiRJ8sYbbyQRkbz44ouZNo888khSUFCQvPvuu+0ZDpAHrdWBj3v77beTiEheffXVFsvXrFmTFBUVJT/5yU8yyxYvXpxERLJgwYKsjhfIjfbUgm1eeOGFJCKSFStWJEninADSbnfqQENDQxIRyRNPPJEkiToAadfWOvDHP/4x2WeffZLXX389GTp0aDJ79uzMOnUA0q8tteCss85KTj755J2uVwsg3dpSB774xS8mZ5xxxk7XZ+v7wnb9hceDDz4Y48aNi1NPPTWqq6tj7NixMWfOnMz6t99+O2pra+O4447LLKusrIwjjzwyFixYEBERCxYsiKqqqhg3blymzXHHHRc9evTY7s/bga6ntTrQFi+//HJs3ry5Ra0YNWpUDBkyJFMrgK5td2pBQ0NDFBQURFVVVUQ4J4C0a28d2LRpU9xxxx1RWVkZhx12WESoA5B2bakDzc3NMW3atLjsssvi4IMP3q4PdQDSr63nBM8880xUV1fHAQccEBdccEHU1dVl1qkFkG6t1YHm5ub45S9/GSNHjoyJEydGdXV1HHnkkfHzn/880yZb3xe2K/D4/e9/H7fddlvsv//+8eijj8YFF1wQF198cdx9990REVFbWxsREQMGDGjxuAEDBmTW1dbWRnV1dYv1hYWF0bdv30wboOtqrQ60RW1tbRQXF2e+9Nzm47UC6NraWws2btwYl19+eUyZMiUqKioiwjkBpF1b68BDDz0U5eXl0atXr5g9e3Y8/vjj0b9//4hQByDt2lIHZs2aFYWFhXHxxRfvsA91ANKvLbVg0qRJ8cMf/jCefPLJmDVrVjz77LNxwgknxJYtWyJCLYC0a60OrF69OtatWxc33nhjTJo0KR577LE45ZRT4gtf+EI8++yzEZG97wsL2zPw5ubmGDduXNxwww0RETF27Nh4/fXX4/bbb4+zzjqrPV0BKaUOABHtqwWbN2+O0047LZIkidtuuy0fwwVyoK114DOf+UwsWrQo3n///ZgzZ06cdtppsXDhwu2+1ADSp7U68PLLL8fNN98cr7zyShQUFOR5tECutOWc4PTTT8+0Hz16dBx66KGx3377xTPPPBOf/exn8zJuIHtaqwPNzc0REXHyySfH1772tYiIGDNmTMyfPz9uv/32+PSnP521sbTrLzxqamrioIMOarHswAMPzNxJfeDAgRER2905fdWqVZl1AwcOjNWrV7dY/9FHH0V9fX2mDdB1tVYH2mLgwIGxadOmWLNmTYvlH68VQNfW1lqwLexYsWJFPP7445vo3U4AAAbjSURBVJm/7ohwTgBp19Y6UFZWFiNGjIhPfepTceedd0ZhYWHceeedEaEOQNq1Vgeee+65WL16dQwZMiQKCwujsLAwVqxYEV//+tdj2LBhEaEOQHewO98T7LvvvtG/f/946623IkItgLRrrQ70798/CgsLW80WsvF9YbsCj6OPPjqWLFnSYtmbb74ZQ4cOjYiI4cOHx8CBA+PJJ5/MrF+7dm0sXLgwxo8fHxER48ePjzVr1sTLL7+cafPUU09Fc3NzHHnkke0ZDpAHrdWBtjjiiCOiqKioRa1YsmRJvPPOO5laAXRtbakF28KOpUuXxhNPPBH9+vVr0d45AaTb7p4TNDc3R1NTU0SoA5B2rdWBadOmxWuvvRaLFi3K/AwaNCguu+yyePTRRyNCHYDuYHfOCf74xz9GXV1d1NTURIRaAGnXWh0oLi6OT37yk7tsk7XvC9t8e/MkSV544YWksLAwuf7665OlS5cmP/rRj5K99tor+e///u9MmxtvvDGpqqpK/vd//zd57bXXkpNPPjkZPnx4smHDhkybSZMmJWPHjk0WLlyYzJs3L9l///2TKVOmtGcoQJ60pQ7U1dUlr776avLLX/4yiYhk7ty5yauvvpqsXLky0+b8889PhgwZkjz11FPJSy+9lIwfPz4ZP358PnYJ2A2t1YJNmzYlkydPTj7xiU8kixYtSlauXJn5aWpqyvTjnADSq7U6sG7duuSKK65IFixYkCxfvjx56aWXkunTpyclJSXJ66+/nulHHYD0astng780dOjQZPbs2S2WqQOQbq3VgsbGxuTSSy9NFixYkLz99tvJE088kRx++OHJ/vvvn2zcuDHTj1oA6dWWc4IHHnggKSoqSu64445k6dKlyS233JL07Nkzee655zJtsvF9YbsCjyRJkl/84hfJIYcckpSUlCSjRo1K7rjjjhbrm5ubk6uvvjoZMGBAUlJSknz2s59NlixZ0qJNXV1dMmXKlKS8vDypqKhIpk+fnjQ2NrZ3KECetFYHfvCDHyQRsd3Ptddem2mzYcOG5B//8R+TPn36JHvttVdyyimntAhEgK5vV7Xg7bff3mEdiIjk6aefzrRzTgDptqs6sGHDhuSUU05JBg0alBQXFyc1NTXJ5MmTkxdeeKFFH+oApFtrnw3+0o4CD3UA0m9XteDDDz9MJkyYkOy9995JUVFRMnTo0OTcc89NamtrW/ShFkC6teWc4M4770xGjBiR9OrVKznssMOSn//85y3WZ+P7woIkSZJ2/HUKAAAAAABAl9Oue3gAAAAAAAB0RQIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAA6LCzzz47Pv/5z+d7GAAAwB6sMN8DAAAAuraCgoJdrr/22mvj5ptvjiRJOmlEAAAA2xN4AAAAu7Ry5crMv//nf/4nrrnmmliyZElmWXl5eZSXl+djaAAAABkuaQUAAOzSwIEDMz+VlZVRUFDQYll5efl2l7Q69thj46KLLopLLrkk+vTpEwMGDIg5c+bE+vXrY/r06dG7d+8YMWJEPPLIIy229frrr8cJJ5wQ5eXlMWDAgJg2bVq8//77nb3LAABACgk8AACAnLj77rujf//+8cILL8RFF10UF1xwQZx66qlx1FFHxSuvvBITJkyIadOmxYcffhgREWvWrIm//du/jbFjx8ZLL70Uv/rVr2LVqlVx2mmn5XlPAACANBB4AAAAOXHYYYfFVVddFfvvv39cccUV0atXr+jfv3+ce+65sf/++8c111wTdXV18dprr0VExK233hpjx46NG264IUaNGhVjx46Nu+66K55++ul4880387w3AABAV+ceHgAAQE4ceuihmX/37Nkz+vXrF6NHj84sGzBgQERErF69OiIifvOb38TTTz+9w/uBLFu2LEaOHJnjEQMAAGkm8AAAAHKiqKioxe8FBQUtlhUUFERERHNzc0RErFu3Lk466aSYNWvWdn3V1NTkcKQAAEB3IPAAAAC6hMMPPzzuv//+GDZsWBQW+qgCAAC0j3t4AAAAXcKMGTOivr4+pkyZEi+++GIsW7YsHn300Zg+fXps2bIl38MDAAC6OIEHAADQJQwaNCief/752LJlS0yYMCFGjx4dl1xySVRVVUWPHj66AAAAu1aQJEmS70EAAAAAAAB0hP8mBQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1/h//ffiQt3ubxgAAAABJRU5ErkJggg==", - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } + "c8e0c9a60ef34d2caee9d55a3c21c3d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c9974003727a401797953ef2885db5a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d12f07e25bf5422facc38c3463700994": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eae11f84c2644ada8295b445c924baec", + "IPY_MODEL_bcf766d2a2c641f0aa2af596c7da1b18", + "IPY_MODEL_74bf69aa6eaa4a8594b2ea9a0fb20957" ], - "source": [ - "groundtruth" - ] + "layout": "IPY_MODEL_2d7a0b901d7044d5b1f273a3e9bea560" + } }, - { - "cell_type": "markdown", - "metadata": { - "id": "MxlrTbyPYnqB" - }, - "source": [ - "# Going further \n", - "\n", - "We have only scratched the surface in this introduction. \n", - "\n", - "More details can be found in the [`pyannote.audio` Github repository](https://github.com/pyannote/pyannote-audio).\n" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "include_colab_link": true, - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "0125df9fa8e14b3db0e2bce299529812": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_407e250e244b4985b1ce8c9d32a8af7d", - "max": 318, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_8127c4258e374ad986ce1f8b4c70f704", - "value": 318 - } - }, - "0821b47ae70444dfa38b84719c4836a6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0adb304bf90f4079a4031caea1cfb924": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0b4bf8076fdf4d19843a3246c8bd61ac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0d10fb0edc9144b1a1fc1f2c9e322410": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d33fba0d78fb41f983c55f5cd2a0a740", - "placeholder": "​", - "style": "IPY_MODEL_fd47487fc8734594823f8afa00c4239d", - "value": "Downloading: 100%" - } - }, - "0d80273cabbc42ba9a408fb1144151c9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "0e382d66f09f4958a40baa7ab83c4ccb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "13525aa369a9410a83343952ab511f3c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "1600b9cd09c446e581b7912e35c9f56e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "16c0017f65b649f5ac5bebf1c955a1fd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "17856a72e4e948039a66c51e8244cb50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "183c55d5d3ce4058ae338c81344547c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_70efa83bf3ea45b4bd8cc41f57613328", - "IPY_MODEL_338747810ac74b4e83e356a01459c8a5", - "IPY_MODEL_ac0bcfa1ef6e4e78a7769c4cb2e8762f" - ], - "layout": "IPY_MODEL_6efb7939bb954dc8ba116680139eb257" - } - }, - "1946386483ed4947a2184cdb4ea6e434": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "23d4e25ec6c541818d5927b69576d278": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "27f6f437c5264368bc2c679942ad1e53": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "28004251b0e44a6c9dfa7ce1b30dcb18": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e98cf7a63c814ffd94f69928f0700ebf", - "IPY_MODEL_6a4dee55cbae4959bd7fe3c4d92242b1", - "IPY_MODEL_8dba487876124827919079519406ecb8" - ], - "layout": "IPY_MODEL_5c211704f90946afbae2f66a7586ce70" - } - }, - "2b2d7912186a49dd9891ae12c77482c7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2cbf0faadd4842c8b22e10541ff9de4e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2d7a0b901d7044d5b1f273a3e9bea560": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "304e9682570b4abeb1719001c04449d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "32accb0adfa24c62a75c15c8ec88df8c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_23d4e25ec6c541818d5927b69576d278", - "max": 128619, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_54d9456703324160aced03ee5fef2943", - "value": 128619 - } - }, - "333b42ca7aa44788b1c22724eb11bcc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "338747810ac74b4e83e356a01459c8a5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_e4c1e9affaba4045a3ec903091b6f454", - "max": 500, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_1946386483ed4947a2184cdb4ea6e434", - "value": 500 - } - }, - "341615c971b04033b7293d82fc40f35c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3499ef4dd9f243d9bef00b396e78ed69": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "358c3a67f8b54c4c899e095611fa116b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "38b3054ad59549e4b4f2de4697139a87": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_0adb304bf90f4079a4031caea1cfb924", - "placeholder": "​", - "style": "IPY_MODEL_40021e0b59fe4e1e9bac351dbec57c6c", - "value": "Downloading: 100%" - } - }, - "3bd33a372aad4c438f64d73c97f14c6a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "40021e0b59fe4e1e9bac351dbec57c6c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "404f7ce06a01470fbb0b747981d00e84": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_38b3054ad59549e4b4f2de4697139a87", - "IPY_MODEL_7d90af87c9574f5ca21fca058c39bf02", - "IPY_MODEL_fee75343289f42fb8d6dfb4bf26fe368" - ], - "layout": "IPY_MODEL_f21c0c6379d74898ac6aadcb6fc14a8a" - } - }, - "407e250e244b4985b1ce8c9d32a8af7d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "41eb32a6fef141ff9cc3ce6e4d771822": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_0d10fb0edc9144b1a1fc1f2c9e322410", - "IPY_MODEL_32accb0adfa24c62a75c15c8ec88df8c", - "IPY_MODEL_bf299285318b4a04a88569cc581ecd75" - ], - "layout": "IPY_MODEL_ac2950d08fc145ba9eb9cf5824b1ee18" - } - }, - "549a30c85c47466eadedbd24da42e304": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "54d9456703324160aced03ee5fef2943": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "554e567a83b348f88092c6ba01830930": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5c211704f90946afbae2f66a7586ce70": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5e2c207db5424f91829bf5c52040a9f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "603e99f45afb4910a99f7684ffd21b6a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b26354d0278f447d92c7e1ad4c211d64", - "placeholder": "​", - "style": "IPY_MODEL_3bd33a372aad4c438f64d73c97f14c6a", - "value": "Downloading: 100%" - } - }, - "6242493d251a47609c0c44f1dbe82958": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "652e97509a914f3b914665c4889c6d11": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "67fcc38a1e5d4eb39381685447e397de": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6a45ce374e2e47ba9457d02e02522748": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ButtonStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "button_color": null, - "font_weight": "" - } - }, - "6a4dee55cbae4959bd7fe3c4d92242b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d7071582bfbe4ec4b2c3c9843e5481ae", - "max": 1921, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_0d80273cabbc42ba9a408fb1144151c9", - "value": 1921 - } - }, - "6e334cad2e94462cae6e722bd6f11a9e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "6ede83f870a24e71b5182fcc458cdc42": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6efb7939bb954dc8ba116680139eb257": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "70abdfd99be84f7b9b8d24fee9eec022": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "70efa83bf3ea45b4bd8cc41f57613328": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_6242493d251a47609c0c44f1dbe82958", - "placeholder": "​", - "style": "IPY_MODEL_f439c1de68ac4c799d81fdb29d053d10", - "value": "Downloading: 100%" - } - }, - "74bf69aa6eaa4a8594b2ea9a0fb20957": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ebc9801e164a44b3b6f8dc7f590e1c79", - "placeholder": "​", - "style": "IPY_MODEL_0821b47ae70444dfa38b84719c4836a6", - "value": " 17.7M/17.7M [00:00<00:00, 54.3MB/s]" - } - }, - "764aa53d75324d73ab06936c52fd8fc8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "765485a1d3f941d28b79782dcffbf401": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "77a361d1ff214e8799891bbeb28a0789": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "79184c8c2a6f4b7493bb7f6983f18a09": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": "center", - "align_self": null, - "border": null, - "bottom": null, - "display": "flex", - "flex": null, - "flex_flow": "column", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "50%" - } - }, - "7d90af87c9574f5ca21fca058c39bf02": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ed169fd606274f2ebbb3e8f32ab42431", - "max": 1920, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_304e9682570b4abeb1719001c04449d6", - "value": 1920 - } - }, - "8011d68253ac4080a637659ef3383dc4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e928540e99564d808cb2d12c92daa498", - "IPY_MODEL_fc9a3c4ae0a947ec91a227360a80f602", - "IPY_MODEL_f91dcd9f30c743d69f9d4b7e8d1beba5" - ], - "layout": "IPY_MODEL_6ede83f870a24e71b5182fcc458cdc42" - } - }, - "8127c4258e374ad986ce1f8b4c70f704": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "859b12a6d95b4c6f987791ca848122b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ea95ffd922c0455d957120f034e541f8", - "placeholder": "​", - "style": "IPY_MODEL_13525aa369a9410a83343952ab511f3c", - "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" - } - }, - "8dba487876124827919079519406ecb8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_67fcc38a1e5d4eb39381685447e397de", - "placeholder": "​", - "style": "IPY_MODEL_0b4bf8076fdf4d19843a3246c8bd61ac", - "value": " 1.92k/1.92k [00:00<00:00, 63.2kB/s]" - } - }, - "94756148d2e94a93ae233baba20af683": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "PasswordModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "PasswordModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "PasswordView", - "continuous_update": true, - "description": "Token:", - "description_tooltip": null, - "disabled": false, - "layout": "IPY_MODEL_b2be65e192384c948fb8987d4cfca505", - "placeholder": "​", - "style": "IPY_MODEL_333b42ca7aa44788b1c22724eb11bcc3", - "value": "" - } - }, - "99898e6ee64a46bd832af112e79b58b7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_765485a1d3f941d28b79782dcffbf401", - "placeholder": "​", - "style": "IPY_MODEL_3499ef4dd9f243d9bef00b396e78ed69", - "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " - } - }, - "a02030ba8f324d93a7ed6cc793d70a3b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a899f4bc6ed842d397723cca582669e6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_341615c971b04033b7293d82fc40f35c", - "placeholder": "​", - "style": "IPY_MODEL_17856a72e4e948039a66c51e8244cb50", - "value": " 5.53M/5.53M [00:00<00:00, 21.7MB/s]" - } - }, - "ab32c7daa1d9404fb921f39fbc4fc05c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "aba21021d3bb4565a58ffa40049810db": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ac0bcfa1ef6e4e78a7769c4cb2e8762f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_549a30c85c47466eadedbd24da42e304", - "placeholder": "​", - "style": "IPY_MODEL_bedc7d916b9745f097094c5c51a81f06", - "value": " 500/500 [00:00<00:00, 5.05kB/s]" - } - }, - "ac2950d08fc145ba9eb9cf5824b1ee18": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b26354d0278f447d92c7e1ad4c211d64": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b2be65e192384c948fb8987d4cfca505": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ba18cded436e486da34882d821d8f1eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ButtonModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ButtonView", - "button_style": "", - "description": "Login", - "disabled": false, - "icon": "", - "layout": "IPY_MODEL_0e382d66f09f4958a40baa7ab83c4ccb", - "style": "IPY_MODEL_6a45ce374e2e47ba9457d02e02522748", - "tooltip": "" - } - }, - "bacfb50c001047c4824a05c9f2ee2e40": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "bcf766d2a2c641f0aa2af596c7da1b18": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ee537ee5470f4d7b816a8c8f96948b4d", - "max": 17719103, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_652e97509a914f3b914665c4889c6d11", - "value": 17719103 - } - }, - "bedc7d916b9745f097094c5c51a81f06": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "bf299285318b4a04a88569cc581ecd75": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_bacfb50c001047c4824a05c9f2ee2e40", - "placeholder": "​", - "style": "IPY_MODEL_c53a1cf68fcd4388abf1f0379891089a", - "value": " 129k/129k [00:00<00:00, 155kB/s]" - } - }, - "c3358d32ac814ea6bc5714402c5bc62d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_ecd8e5e364d34ea8bfbba4fbd467384d", - "IPY_MODEL_0125df9fa8e14b3db0e2bce299529812", - "IPY_MODEL_e3169ca885e04536a709d5751173ce9a" - ], - "layout": "IPY_MODEL_70abdfd99be84f7b9b8d24fee9eec022" - } - }, - "c53a1cf68fcd4388abf1f0379891089a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "c8731777ce834e58a76a295076200cfc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "VBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "VBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "VBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_859b12a6d95b4c6f987791ca848122b9", - "IPY_MODEL_94756148d2e94a93ae233baba20af683", - "IPY_MODEL_ba18cded436e486da34882d821d8f1eb", - "IPY_MODEL_99898e6ee64a46bd832af112e79b58b7" - ], - "layout": "IPY_MODEL_79184c8c2a6f4b7493bb7f6983f18a09" - } - }, - "c8e0c9a60ef34d2caee9d55a3c21c3d4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c9974003727a401797953ef2885db5a2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d12f07e25bf5422facc38c3463700994": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_eae11f84c2644ada8295b445c924baec", - "IPY_MODEL_bcf766d2a2c641f0aa2af596c7da1b18", - "IPY_MODEL_74bf69aa6eaa4a8594b2ea9a0fb20957" - ], - "layout": "IPY_MODEL_2d7a0b901d7044d5b1f273a3e9bea560" - } - }, - "d13ba6030aff42bca48c72ff071c44c0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c8e0c9a60ef34d2caee9d55a3c21c3d4", - "max": 5534328, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_764aa53d75324d73ab06936c52fd8fc8", - "value": 5534328 - } - }, - "d182e37b4a404158bee8446fc2728bd9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_603e99f45afb4910a99f7684ffd21b6a", - "IPY_MODEL_d13ba6030aff42bca48c72ff071c44c0", - "IPY_MODEL_a899f4bc6ed842d397723cca582669e6" - ], - "layout": "IPY_MODEL_a02030ba8f324d93a7ed6cc793d70a3b" - } - }, - "d33fba0d78fb41f983c55f5cd2a0a740": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d7071582bfbe4ec4b2c3c9843e5481ae": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e1c9df12fa034c93a9b3530ea4a7c5aa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "e3169ca885e04536a709d5751173ce9a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_358c3a67f8b54c4c899e095611fa116b", - "placeholder": "​", - "style": "IPY_MODEL_e1c9df12fa034c93a9b3530ea4a7c5aa", - "value": " 318/318 [00:00<00:00, 11.0kB/s]" - } - }, - "e4c1e9affaba4045a3ec903091b6f454": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e7728d9c55e44274966f8f6dbc445c54": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e928540e99564d808cb2d12c92daa498": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c9974003727a401797953ef2885db5a2", - "placeholder": "​", - "style": "IPY_MODEL_77a361d1ff214e8799891bbeb28a0789", - "value": "Downloading: 100%" - } - }, - "e98cf7a63c814ffd94f69928f0700ebf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_aba21021d3bb4565a58ffa40049810db", - "placeholder": "​", - "style": "IPY_MODEL_f7812fa7fbf744c1b261b985d085e28e", - "value": "Downloading: 100%" - } - }, - "ea95ffd922c0455d957120f034e541f8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "eae11f84c2644ada8295b445c924baec": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2cbf0faadd4842c8b22e10541ff9de4e", - "placeholder": "​", - "style": "IPY_MODEL_ab32c7daa1d9404fb921f39fbc4fc05c", - "value": "Downloading: 100%" - } - }, - "ebc9801e164a44b3b6f8dc7f590e1c79": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ecd8e5e364d34ea8bfbba4fbd467384d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_554e567a83b348f88092c6ba01830930", - "placeholder": "​", - "style": "IPY_MODEL_6e334cad2e94462cae6e722bd6f11a9e", - "value": "Downloading: 100%" - } - }, - "ed169fd606274f2ebbb3e8f32ab42431": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ee537ee5470f4d7b816a8c8f96948b4d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f21c0c6379d74898ac6aadcb6fc14a8a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f439c1de68ac4c799d81fdb29d053d10": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f7812fa7fbf744c1b261b985d085e28e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f91dcd9f30c743d69f9d4b7e8d1beba5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2b2d7912186a49dd9891ae12c77482c7", - "placeholder": "​", - "style": "IPY_MODEL_1600b9cd09c446e581b7912e35c9f56e", - "value": " 83.3M/83.3M [00:01<00:00, 60.9MB/s]" - } - }, - "fc9a3c4ae0a947ec91a227360a80f602": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_27f6f437c5264368bc2c679942ad1e53", - "max": 83316686, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e7728d9c55e44274966f8f6dbc445c54", - "value": 83316686 - } - }, - "fd47487fc8734594823f8afa00c4239d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "fee75343289f42fb8d6dfb4bf26fe368": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_16c0017f65b649f5ac5bebf1c955a1fd", - "placeholder": "​", - "style": "IPY_MODEL_5e2c207db5424f91829bf5c52040a9f2", - "value": " 1.92k/1.92k [00:00<00:00, 48.3kB/s]" - } - } - } + "d13ba6030aff42bca48c72ff071c44c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c8e0c9a60ef34d2caee9d55a3c21c3d4", + "max": 5534328, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_764aa53d75324d73ab06936c52fd8fc8", + "value": 5534328 + } + }, + "d182e37b4a404158bee8446fc2728bd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_603e99f45afb4910a99f7684ffd21b6a", + "IPY_MODEL_d13ba6030aff42bca48c72ff071c44c0", + "IPY_MODEL_a899f4bc6ed842d397723cca582669e6" + ], + "layout": "IPY_MODEL_a02030ba8f324d93a7ed6cc793d70a3b" + } + }, + "d33fba0d78fb41f983c55f5cd2a0a740": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7071582bfbe4ec4b2c3c9843e5481ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e1c9df12fa034c93a9b3530ea4a7c5aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e3169ca885e04536a709d5751173ce9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_358c3a67f8b54c4c899e095611fa116b", + "placeholder": "​", + "style": "IPY_MODEL_e1c9df12fa034c93a9b3530ea4a7c5aa", + "value": " 318/318 [00:00<00:00, 11.0kB/s]" + } + }, + "e4c1e9affaba4045a3ec903091b6f454": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e7728d9c55e44274966f8f6dbc445c54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e928540e99564d808cb2d12c92daa498": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c9974003727a401797953ef2885db5a2", + "placeholder": "​", + "style": "IPY_MODEL_77a361d1ff214e8799891bbeb28a0789", + "value": "Downloading: 100%" + } + }, + "e98cf7a63c814ffd94f69928f0700ebf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aba21021d3bb4565a58ffa40049810db", + "placeholder": "​", + "style": "IPY_MODEL_f7812fa7fbf744c1b261b985d085e28e", + "value": "Downloading: 100%" + } + }, + "ea95ffd922c0455d957120f034e541f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eae11f84c2644ada8295b445c924baec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2cbf0faadd4842c8b22e10541ff9de4e", + "placeholder": "​", + "style": "IPY_MODEL_ab32c7daa1d9404fb921f39fbc4fc05c", + "value": "Downloading: 100%" + } + }, + "ebc9801e164a44b3b6f8dc7f590e1c79": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ecd8e5e364d34ea8bfbba4fbd467384d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_554e567a83b348f88092c6ba01830930", + "placeholder": "​", + "style": "IPY_MODEL_6e334cad2e94462cae6e722bd6f11a9e", + "value": "Downloading: 100%" + } + }, + "ed169fd606274f2ebbb3e8f32ab42431": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee537ee5470f4d7b816a8c8f96948b4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f21c0c6379d74898ac6aadcb6fc14a8a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f439c1de68ac4c799d81fdb29d053d10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f7812fa7fbf744c1b261b985d085e28e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f91dcd9f30c743d69f9d4b7e8d1beba5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b2d7912186a49dd9891ae12c77482c7", + "placeholder": "​", + "style": "IPY_MODEL_1600b9cd09c446e581b7912e35c9f56e", + "value": " 83.3M/83.3M [00:01<00:00, 60.9MB/s]" + } + }, + "fc9a3c4ae0a947ec91a227360a80f602": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_27f6f437c5264368bc2c679942ad1e53", + "max": 83316686, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e7728d9c55e44274966f8f6dbc445c54", + "value": 83316686 + } + }, + "fd47487fc8734594823f8afa00c4239d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fee75343289f42fb8d6dfb4bf26fe368": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_16c0017f65b649f5ac5bebf1c955a1fd", + "placeholder": "​", + "style": "IPY_MODEL_5e2c207db5424f91829bf5c52040a9f2", + "value": " 1.92k/1.92k [00:00<00:00, 48.3kB/s]" + } } - }, - "nbformat": 4, - "nbformat_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 } From 26ca0514394ee8faef044b1da0fcf99e53cc22c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 16 Oct 2023 15:32:27 +0200 Subject: [PATCH 02/19] feat: add `TimingHook` and list of `Hooks` (#1503) --- CHANGELOG.md | 6 ++ .../audio/pipelines/speaker_diarization.py | 3 + pyannote/audio/pipelines/utils/hook.py | 89 ++++++++++++++++++- 3 files changed, 95 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d63c193d0..b9805e758 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,11 @@ # Changelog +## `develop` branch + + - feat(pipeline): add `TimingHook` for profiling processing time + - feat(pipeline): add support for list of hooks with `Hooks` + - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` + ## Version 3.0.1 (2023-09-28) - fix(pipeline): fix WeSpeaker GPU support diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 18b6565d3..d5cf04e05 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -332,6 +332,9 @@ def iter_waveform_and_mask(): embedding_batches = [] + if hook is not None: + hook("embeddings", None, total=batch_count, completed=0) + for i, batch in enumerate(batches, 1): waveforms, masks = zip(*filter(lambda b: b[0] is not None, batch)) diff --git a/pyannote/audio/pipelines/utils/hook.py b/pyannote/audio/pipelines/utils/hook.py index cb150ea4a..86ecf1ec1 100644 --- a/pyannote/audio/pipelines/utils/hook.py +++ b/pyannote/audio/pipelines/utils/hook.py @@ -20,6 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +import time from copy import deepcopy from typing import Any, Mapping, Optional, Text @@ -64,11 +65,9 @@ class ProgressHook: """ def __init__(self, transient: bool = False): - super().__init__() self.transient = transient def __enter__(self): - self.progress = Progress( TextColumn("[progress.description]{task.description}"), BarColumn(), @@ -90,7 +89,6 @@ def __call__( total: Optional[int] = None, completed: Optional[int] = None, ): - if completed is None: completed = total = 1 @@ -103,3 +101,88 @@ def __call__( # force refresh when completed if completed >= total: self.progress.refresh() + + +class TimingHook: + """Hook to compute processing time of internal steps + + Parameters + ---------- + file_key: str, optional + Key used to store processing time in `file`. + Defaults to "timing_hook". + + Usage + ----- + >>> with TimingHook() as hook: + ... output = pipeline(file, hook=hook) + # file["timing_hook"] contains processing time for each step + """ + + def __init__(self, file_key: str = "timing_hook"): + self.file_key = file_key + + def __enter__(self): + self._pipeline_start_time = time.time() + self._start_time = dict() + self._end_time = dict() + return self + + def __exit__(self, *args): + _pipeline_end_time = time.time() + processing_time = dict() + processing_time["total"] = _pipeline_end_time - self._pipeline_start_time + for step_name, _start_time in self._start_time.items(): + _end_time = self._end_time[step_name] + processing_time[step_name] = _end_time - _start_time + + self._file[self.file_key] = processing_time + + def __call__( + self, + step_name: Text, + step_artifact: Any, + file: Optional[Mapping] = None, + total: Optional[int] = None, + completed: Optional[int] = None, + ): + if not hasattr(self, "_file"): + self._file = file + + if completed is None: + return + + if completed == 0: + self._start_time[step_name] = time.time() + + if completed >= total: + self._end_time[step_name] = time.time() + + +class Hooks: + """List of hooks + + Usage + ----- + >>> with Hooks(ProgessHook(), TimingHook()) as hook: + ... output = pipeline("audio.wav", hook=hook) + + """ + + def __init__(self, *hooks): + self.hooks = hooks + + def __enter__(self): + for hook in self.hooks: + if hasattr(hook, "__enter__"): + hook.__enter__() + return self + + def __exit__(self, *args): + for hook in self.hooks: + if hasattr(hook, "__exit__"): + hook.__exit__(*args) + + def __call__(self, *args: Any, **kwds: Any) -> Any: + for hook in self.hooks: + hook(*args, **kwds) From 4b09aefe4093a681b258626523a1408d754dd90c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sat, 21 Oct 2023 16:11:03 +0200 Subject: [PATCH 03/19] feat(pipeline): add ArtifactHook for saving internal steps (#1511) --- CHANGELOG.md | 169 +++++++++++++------------ pyannote/audio/pipelines/utils/hook.py | 57 +++++++-- 2 files changed, 128 insertions(+), 98 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b9805e758..fcdebb82c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,137 +2,138 @@ ## `develop` branch - - feat(pipeline): add `TimingHook` for profiling processing time - - feat(pipeline): add support for list of hooks with `Hooks` - - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` +- feat(pipeline): add `TimingHook` for profiling processing time +- feat(pipeline): add `ArtifactHook` for saving internal steps +- feat(pipeline): add support for list of hooks with `Hooks` +- BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) +- fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` ## Version 3.0.1 (2023-09-28) - - fix(pipeline): fix WeSpeaker GPU support +- fix(pipeline): fix WeSpeaker GPU support ## Version 3.0.0 (2023-09-26) ### Features and improvements - - feat(pipeline): send pipeline to device with `pipeline.to(device)` - - feat(pipeline): add `return_embeddings` option to `SpeakerDiarization` pipeline - - feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) - - feat(pipeline): add progress hook to pipelines - - feat(task): add [powerset](https://www.isca-speech.org/archive/interspeech_2023/plaquet23_interspeech.html) support to `SpeakerDiarization` task - - feat(task): add support for multi-task models - - feat(task): add support for label scope in speaker diarization task - - feat(task): add support for missing classes in multi-label segmentation task - - feat(model): add segmentation model based on torchaudio self-supervised representation - - feat(pipeline): check version compatibility at load time - - improve(task): load metadata as tensors rather than pyannote.core instances - - improve(task): improve error message on missing specifications +- feat(pipeline): send pipeline to device with `pipeline.to(device)` +- feat(pipeline): add `return_embeddings` option to `SpeakerDiarization` pipeline +- feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) +- feat(pipeline): add progress hook to pipelines +- feat(task): add [powerset](https://www.isca-speech.org/archive/interspeech_2023/plaquet23_interspeech.html) support to `SpeakerDiarization` task +- feat(task): add support for multi-task models +- feat(task): add support for label scope in speaker diarization task +- feat(task): add support for missing classes in multi-label segmentation task +- feat(model): add segmentation model based on torchaudio self-supervised representation +- feat(pipeline): check version compatibility at load time +- improve(task): load metadata as tensors rather than pyannote.core instances +- improve(task): improve error message on missing specifications ### Breaking changes - - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` - - BREAKING(pipeline): pipeline defaults to CPU (use `pipeline.to(device)`) - - BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (use `SpeakerDiarization` pipeline) - - BREAKING(pipeline): remove `segmentation_duration` parameter from `SpeakerDiarization` pipeline (defaults to `duration` of segmentation model) - - BREAKING(task): remove support for variable chunk duration for segmentation tasks - - BREAKING(pipeline): remove support for `FINCHClustering` and `HiddenMarkovModelClustering` - - BREAKING(setup): drop support for Python 3.7 - - BREAKING(io): channels are now 0-indexed (used to be 1-indexed) - - BREAKING(io): multi-channel audio is no longer downmixed to mono by default. - You should update how `pyannote.audio.core.io.Audio` is instantiated: - * replace `Audio()` by `Audio(mono="downmix")`; - * replace `Audio(mono=True)` by `Audio(mono="downmix")`; - * replace `Audio(mono=False)` by `Audio()`. - - BREAKING(model): get rid of (flaky) `Model.introspection` - If, for some weird reason, you wrote some custom code based on that, - you should instead rely on `Model.example_output`. - - BREAKING(interactive): remove support for Prodigy recipes - +- BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` +- BREAKING(pipeline): pipeline defaults to CPU (use `pipeline.to(device)`) +- BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (use `SpeakerDiarization` pipeline) +- BREAKING(pipeline): remove `segmentation_duration` parameter from `SpeakerDiarization` pipeline (defaults to `duration` of segmentation model) +- BREAKING(task): remove support for variable chunk duration for segmentation tasks +- BREAKING(pipeline): remove support for `FINCHClustering` and `HiddenMarkovModelClustering` +- BREAKING(setup): drop support for Python 3.7 +- BREAKING(io): channels are now 0-indexed (used to be 1-indexed) +- BREAKING(io): multi-channel audio is no longer downmixed to mono by default. + You should update how `pyannote.audio.core.io.Audio` is instantiated: + - replace `Audio()` by `Audio(mono="downmix")`; + - replace `Audio(mono=True)` by `Audio(mono="downmix")`; + - replace `Audio(mono=False)` by `Audio()`. +- BREAKING(model): get rid of (flaky) `Model.introspection` + If, for some weird reason, you wrote some custom code based on that, + you should instead rely on `Model.example_output`. +- BREAKING(interactive): remove support for Prodigy recipes ### Fixes and improvements - - fix(pipeline): fix reproducibility issue with Ampere CUDA devices - - fix(pipeline): fix support for IOBase audio - - fix(pipeline): fix corner case with no speaker - - fix(train): prevent metadata preparation to happen twice - - fix(task): fix support for "balance" option - - improve(task): shorten and improve structure of Tensorboard tags +- fix(pipeline): fix reproducibility issue with Ampere CUDA devices +- fix(pipeline): fix support for IOBase audio +- fix(pipeline): fix corner case with no speaker +- fix(train): prevent metadata preparation to happen twice +- fix(task): fix support for "balance" option +- improve(task): shorten and improve structure of Tensorboard tags ### Dependencies update - - setup: switch to torch 2.0+, torchaudio 2.0+, soundfile 0.12+, lightning 2.0+, torchmetrics 0.11+ - - setup: switch to pyannote.core 5.0+, pyannote.database 5.0+, and pyannote.pipeline 3.0+ - - setup: switch to speechbrain 0.5.14+ +- setup: switch to torch 2.0+, torchaudio 2.0+, soundfile 0.12+, lightning 2.0+, torchmetrics 0.11+ +- setup: switch to pyannote.core 5.0+, pyannote.database 5.0+, and pyannote.pipeline 3.0+ +- setup: switch to speechbrain 0.5.14+ ## Version 2.1.1 (2022-10-27) - - BREAKING(pipeline): rewrite speaker diarization pipeline - - feat(pipeline): add option to optimize for DER variant - - feat(clustering): add support for NeMo speaker embedding - - feat(clustering): add FINCH clustering - - feat(clustering): add min_cluster_size hparams to AgglomerativeClustering - - feat(hub): add support for private/gated models - - setup(hub): switch to latest hugginface_hub API - - fix(pipeline): fix support for missing reference in Resegmentation pipeline - - fix(clustering) fix corner case where HMM.fit finds too little states +- BREAKING(pipeline): rewrite speaker diarization pipeline +- feat(pipeline): add option to optimize for DER variant +- feat(clustering): add support for NeMo speaker embedding +- feat(clustering): add FINCH clustering +- feat(clustering): add min_cluster_size hparams to AgglomerativeClustering +- feat(hub): add support for private/gated models +- setup(hub): switch to latest hugginface_hub API +- fix(pipeline): fix support for missing reference in Resegmentation pipeline +- fix(clustering) fix corner case where HMM.fit finds too little states ## Version 2.0.1 (2022-07-20) - - BREAKING: complete rewrite - - feat: much better performance - - feat: Python-first API - - feat: pretrained pipelines (and models) on Huggingface model hub - - feat: multi-GPU training with pytorch-lightning - - feat: data augmentation with torch-audiomentations - - feat: Prodigy recipe for model-assisted audio annotation +- BREAKING: complete rewrite +- feat: much better performance +- feat: Python-first API +- feat: pretrained pipelines (and models) on Huggingface model hub +- feat: multi-GPU training with pytorch-lightning +- feat: data augmentation with torch-audiomentations +- feat: Prodigy recipe for model-assisted audio annotation ## Version 1.1.2 (2021-01-28) - - fix: make sure master branch is used to load pretrained models (#599) +- fix: make sure master branch is used to load pretrained models (#599) ## Version 1.1 (2020-11-08) - - last release before complete rewriting +- last release before complete rewriting ## Version 1.0.1 (2018-07-19) - - fix: fix regression in Precomputed.__call__ (#110, #105) +- fix: fix regression in Precomputed.**call** (#110, #105) ## Version 1.0 (2018-07-03) - - chore: switch from keras to pytorch (with tensorboard support) - - improve: faster & better traning (`AutoLR`, advanced learning rate schedulers, improved batch generators) - - feat: add tunable speaker diarization pipeline (with its own tutorial) - - chore: drop support for Python 2 (use Python 3.6 or later) +- chore: switch from keras to pytorch (with tensorboard support) +- improve: faster & better traning (`AutoLR`, advanced learning rate schedulers, improved batch generators) +- feat: add tunable speaker diarization pipeline (with its own tutorial) +- chore: drop support for Python 2 (use Python 3.6 or later) ## Version 0.3.1 (2017-07-06) - - feat: add python 3 support - - chore: rewrite neural speaker embedding using autograd - - feat: add new embedding architectures - - feat: add new embedding losses - - chore: switch to Keras 2 - - doc: add tutorial for (MFCC) feature extraction - - doc: add tutorial for (LSTM-based) speech activity detection - - doc: add tutorial for (LSTM-based) speaker change detection - - doc: add tutorial for (TristouNet) neural speaker embedding +- feat: add python 3 support +- chore: rewrite neural speaker embedding using autograd +- feat: add new embedding architectures +- feat: add new embedding losses +- chore: switch to Keras 2 +- doc: add tutorial for (MFCC) feature extraction +- doc: add tutorial for (LSTM-based) speech activity detection +- doc: add tutorial for (LSTM-based) speaker change detection +- doc: add tutorial for (TristouNet) neural speaker embedding ## Version 0.2.1 (2017-03-28) - - feat: add LSTM-based speech activity detection - - feat: add LSTM-based speaker change detection - - improve: refactor LSTM-based speaker embedding - - feat: add librosa basic support - - feat: add SMORMS3 optimizer +- feat: add LSTM-based speech activity detection +- feat: add LSTM-based speaker change detection +- improve: refactor LSTM-based speaker embedding +- feat: add librosa basic support +- feat: add SMORMS3 optimizer ## Version 0.1.4 (2016-09-26) - - feat: add 'covariance_type' option to BIC segmentation +- feat: add 'covariance_type' option to BIC segmentation ## Version 0.1.3 (2016-09-23) - - chore: rename sequence generator in preparation of the release of - TristouNet reproducible research package. +- chore: rename sequence generator in preparation of the release of + TristouNet reproducible research package. ## Version 0.1.2 (2016-09-22) - - first public version +- first public version diff --git a/pyannote/audio/pipelines/utils/hook.py b/pyannote/audio/pipelines/utils/hook.py index 86ecf1ec1..fc6e56734 100644 --- a/pyannote/audio/pipelines/utils/hook.py +++ b/pyannote/audio/pipelines/utils/hook.py @@ -33,20 +33,49 @@ ) -def logging_hook( - step_name: Text, - step_artifact: Any, - file: Optional[Mapping] = None, - completed: Optional[int] = None, - total: Optional[int] = None, -): - """Hook to save step_artifact as file[step_name] - - Useful for debugging purposes +class ArtifactHook: + """Hook to save artifacts of each internal step + + Parameters + ---------- + artifacts: list of str, optional + List of steps to save. Defaults to all steps. + file_key: str, optional + Key used to store artifacts in `file`. + Defaults to "artifact". + + Usage + ----- + >>> with ArtifactHook() as hook: + ... output = pipeline(file, hook=hook) + # file["artifact"] contains a dict with artifacts of each step + """ - if completed is None: - file[step_name] = deepcopy(step_artifact) + def __init__(self, *artifacts, file_key: str = "artifact"): + self.artifacts = artifacts + self.file_key = file_key + + def __enter__(self): + return self + + def __exit__(self, *args): + pass + + def __call__( + self, + step_name: Text, + step_artifact: Any, + file: Optional[Mapping] = None, + total: Optional[int] = None, + completed: Optional[int] = None, + ): + if (step_artifact is None) or ( + self.artifacts and step_name not in self.artifacts + ): + return + + file.setdefault(self.file_key, dict())[step_name] = deepcopy(step_artifact) class ProgressHook: @@ -119,7 +148,7 @@ class TimingHook: # file["timing_hook"] contains processing time for each step """ - def __init__(self, file_key: str = "timing_hook"): + def __init__(self, file_key: str = "timing"): self.file_key = file_key def __enter__(self): @@ -164,7 +193,7 @@ class Hooks: Usage ----- - >>> with Hooks(ProgessHook(), TimingHook()) as hook: + >>> with Hooks(ProgessHook(), TimingHook(), ArtifactHook()) as hook: ... output = pipeline("audio.wav", hook=hook) """ From 03f826535995648d5205f5ec22203e2e3006ed61 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sun, 22 Oct 2023 12:04:30 +0200 Subject: [PATCH 04/19] fix: fix of list of Hooks (#1514) --- pyannote/audio/pipelines/utils/hook.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/pipelines/utils/hook.py b/pyannote/audio/pipelines/utils/hook.py index fc6e56734..2a675d1c9 100644 --- a/pyannote/audio/pipelines/utils/hook.py +++ b/pyannote/audio/pipelines/utils/hook.py @@ -212,6 +212,13 @@ def __exit__(self, *args): if hasattr(hook, "__exit__"): hook.__exit__(*args) - def __call__(self, *args: Any, **kwds: Any) -> Any: + def __call__( + self, + step_name: Text, + step_artifact: Any, + file: Optional[Mapping] = None, + total: Optional[int] = None, + completed: Optional[int] = None, + ): for hook in self.hooks: - hook(*args, **kwds) + hook(step_name, step_artifact, file=file, total=total, completed=completed) From 0b45103cb228a81a9d9d776cca92694cb30ddb41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sun, 22 Oct 2023 16:44:32 +0200 Subject: [PATCH 05/19] feat(utils): add "soft" option to Powerset.to_multilabel conversion (#1516) --- CHANGELOG.md | 1 + pyannote/audio/utils/powerset.py | 22 ++++++++++++++-------- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fcdebb82c..c63e65bea 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ - feat(pipeline): add support for list of hooks with `Hooks` - BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` +- feat(utils): add `"soft"` option to `Powerset.to_multilabel` ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index 0f5cfb5bc..810519829 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -84,26 +84,32 @@ def build_cardinality(self) -> torch.Tensor: powerset_k += 1 return cardinality - def to_multilabel(self, powerset: torch.Tensor) -> torch.Tensor: - """Convert predictions from (soft) powerset to (hard) multi-label + def to_multilabel(self, powerset: torch.Tensor, soft: bool = False) -> torch.Tensor: + """Convert predictions from powerset to multi-label Parameter --------- powerset : (batch_size, num_frames, num_powerset_classes) torch.Tensor Soft predictions in "powerset" space. + soft : bool, optional + Return soft multi-label predictions. Defaults to False (i.e. hard predictions) + Assumes that `powerset` are "logits" (not "probabilities"). Returns ------- multi_label : (batch_size, num_frames, num_classes) torch.Tensor - Hard predictions in "multi-label" space. + Predictions in "multi-label" space. """ - hard_powerset = torch.nn.functional.one_hot( - torch.argmax(powerset, dim=-1), - self.num_powerset_classes, - ).float() + if soft: + powerset_probs = torch.exp(powerset) + else: + powerset_probs = torch.nn.functional.one_hot( + torch.argmax(powerset, dim=-1), + self.num_powerset_classes, + ).float() - return torch.matmul(hard_powerset, self.mapping) + return torch.matmul(powerset_probs, self.mapping) def forward(self, powerset: torch.Tensor) -> torch.Tensor: """Alias for `to_multilabel`""" From 40fa67b1ead65d08963b9cfd85541cd833c072ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 7 Nov 2023 09:38:45 +0100 Subject: [PATCH 06/19] fix(pipeline): compute fbank on selected device (#1529) --- CHANGELOG.md | 1 + pyannote/audio/pipelines/speaker_verification.py | 7 ++++--- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c63e65bea..f52704595 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ - BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - feat(utils): add `"soft"` option to `Powerset.to_multilabel` +- improve(pipeline): compute `fbank` on GPU when requested ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 6b39679dd..8a36fc70c 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -556,6 +556,7 @@ def compute_fbank( for waveform in waveforms ] ) + return features - torch.mean(features, dim=1, keepdim=True) def __call__( @@ -578,12 +579,12 @@ def __call__( batch_size, num_channels, num_samples = waveforms.shape assert num_channels == 1 - features = self.compute_fbank(waveforms) + features = self.compute_fbank(waveforms.to(self.device)) _, num_frames, _ = features.shape if masks is None: embeddings = self.session_.run( - output_names=["embs"], input_feed={"feats": features.numpy()} + output_names=["embs"], input_feed={"feats": features.numpy(force=True)} )[0] return embeddings @@ -606,7 +607,7 @@ def __call__( embeddings[f] = self.session_.run( output_names=["embs"], - input_feed={"feats": masked_feature.numpy()[None]}, + input_feed={"feats": masked_feature.numpy(force=True)[None]}, )[0][0] return embeddings From 0e1a726ad2141bc6c4cc9672a2899ac2bb73fe73 Mon Sep 17 00:00:00 2001 From: Olivier <22832930+olvb@users.noreply.github.com> Date: Tue, 7 Nov 2023 12:02:41 +0100 Subject: [PATCH 07/19] fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Olivier Birot Co-authored-by: Hervé BREDIN --- CHANGELOG.md | 1 + pyannote/audio/pipelines/clustering.py | 3 ++- tests/test_clustering.py | 29 ++++++++++++++++++++++++++ 3 files changed, 32 insertions(+), 1 deletion(-) create mode 100644 tests/test_clustering.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f52704595..cb025c0bd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - feat(utils): add `"soft"` option to `Powerset.to_multilabel` - improve(pipeline): compute `fbank` on GPU when requested +- fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index a779016cb..c51cdcc50 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -386,7 +386,8 @@ def cluster( elif num_large_clusters > max_clusters: num_clusters = max_clusters - if num_clusters is not None: + # look for perfect candidate if necessary + if num_clusters is not None and num_large_clusters != num_clusters: # switch stopping criterion from "inter-cluster distance" stopping to "iteration index" _dendrogram = np.copy(dendrogram) _dendrogram[:, 2] = np.arange(num_embeddings - 1) diff --git a/tests/test_clustering.py b/tests/test_clustering.py new file mode 100644 index 000000000..535da47de --- /dev/null +++ b/tests/test_clustering.py @@ -0,0 +1,29 @@ +import numpy as np + +from pyannote.audio.pipelines.clustering import AgglomerativeClustering + + +def test_agglomerative_clustering_num_cluster(): + """ + Make sure AgglomerativeClustering doesn't "over-merge" clusters when initial + clustering already matches target num_clusters, cf + https://github.com/pyannote/pyannote-audio/issues/1525 + """ + + # 2 embeddings different enough + embeddings = np.array([[1.0, 1.0, 1.0, 1.0], [1.0, 2.0, 1.0, 2.0]]) + + # clustering with params that should yield 1 cluster per embedding + clustering = AgglomerativeClustering().instantiate( + { + "method": "centroid", + "min_cluster_size": 0, + "threshold": 0.0, + } + ) + + # request 2 clusters + clusters = clustering.cluster( + embeddings=embeddings, min_clusters=2, max_clusters=2, num_clusters=2 + ) + assert np.array_equal(clusters, np.array([0, 1])) From fb1c5c4bce604ecc2cf383f6669d13f1058c21c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 10 Nov 2023 15:58:52 +0100 Subject: [PATCH 08/19] improve: add support for "soft" option in Powerset.forward --- pyannote/audio/utils/powerset.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index 810519829..b75221e48 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -111,9 +111,9 @@ def to_multilabel(self, powerset: torch.Tensor, soft: bool = False) -> torch.Ten return torch.matmul(powerset_probs, self.mapping) - def forward(self, powerset: torch.Tensor) -> torch.Tensor: + def forward(self, powerset: torch.Tensor, soft: bool = False) -> torch.Tensor: """Alias for `to_multilabel`""" - return self.to_multilabel(powerset) + return self.to_multilabel(powerset, soft=soft) def to_powerset(self, multilabel: torch.Tensor) -> torch.Tensor: """Convert (hard) predictions from multi-label to powerset From e0544b8ce16481001beac195275de55e4525521a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 10 Nov 2023 16:00:27 +0100 Subject: [PATCH 09/19] feat: use strings for track identifiers --- pyannote/audio/pipelines/utils/diarization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/pipelines/utils/diarization.py b/pyannote/audio/pipelines/utils/diarization.py index f494c6073..91413350b 100644 --- a/pyannote/audio/pipelines/utils/diarization.py +++ b/pyannote/audio/pipelines/utils/diarization.py @@ -197,7 +197,7 @@ def to_annotation( min_duration_off=min_duration_off, ) - return binarize(discrete_diarization) + return binarize(discrete_diarization).rename_tracks(generator="string") @staticmethod def to_diarization( From 2787f123cc408dfc6a43fbf437d725fd93b7c537 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 13 Nov 2023 17:12:32 +0100 Subject: [PATCH 10/19] BREAKING(setup): prepare for getting rid of ONNX runtime (#1541) --- CHANGELOG.md | 3 +++ pyannote/audio/pipelines/speaker_verification.py | 16 +++++++++++----- requirements.txt | 1 - 3 files changed, 14 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cb025c0bd..8cd56ad36 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,9 @@ - feat(utils): add `"soft"` option to `Powerset.to_multilabel` - improve(pipeline): compute `fbank` on GPU when requested - fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided +- BREAKING(pipeline): rename `WeSpeakerPretrainedSpeakerEmbedding` to `ONNXWeSpeakerPretrainedSpeakerEmbedding` +- BREAKING(setup): remove `onnxruntime` dependency. + You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 8a36fc70c..9f10f6e51 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -386,7 +386,7 @@ def __call__( return embeddings -class WeSpeakerPretrainedSpeakerEmbedding(BaseInference): +class ONNXWeSpeakerPretrainedSpeakerEmbedding(BaseInference): """Pretrained WeSpeaker speaker embedding Parameters @@ -398,7 +398,7 @@ class WeSpeakerPretrainedSpeakerEmbedding(BaseInference): Usage ----- - >>> get_embedding = WeSpeakerPretrainedSpeakerEmbedding("hbredin/wespeaker-voxceleb-resnet34-LM") + >>> get_embedding = ONNXWeSpeakerPretrainedSpeakerEmbedding("hbredin/wespeaker-voxceleb-resnet34-LM") >>> assert waveforms.ndim == 3 >>> batch_size, num_channels, num_samples = waveforms.shape >>> assert num_channels == 1 @@ -418,7 +418,7 @@ def __init__( ): if not ONNX_IS_AVAILABLE: raise ImportError( - f"'onnxruntime' must be installed to use '{embedding}' embeddings. " + f"'onnxruntime' must be installed to use '{embedding}' embeddings." ) super().__init__() @@ -745,7 +745,12 @@ def PretrainedSpeakerEmbedding( >>> embeddings = get_embedding(waveforms, masks=masks) """ - if isinstance(embedding, str) and "speechbrain" in embedding: + if isinstance(embedding, str) and "pyannote" in embedding: + return PyannoteAudioPretrainedSpeakerEmbedding( + embedding, device=device, use_auth_token=use_auth_token + ) + + elif isinstance(embedding, str) and "speechbrain" in embedding: return SpeechBrainPretrainedSpeakerEmbedding( embedding, device=device, use_auth_token=use_auth_token ) @@ -754,9 +759,10 @@ def PretrainedSpeakerEmbedding( return NeMoPretrainedSpeakerEmbedding(embedding, device=device) elif isinstance(embedding, str) and "wespeaker" in embedding: - return WeSpeakerPretrainedSpeakerEmbedding(embedding, device=device) + return ONNXWeSpeakerPretrainedSpeakerEmbedding(embedding, device=device) else: + # fallback to pyannote in case we are loading a local model return PyannoteAudioPretrainedSpeakerEmbedding( embedding, device=device, use_auth_token=use_auth_token ) diff --git a/requirements.txt b/requirements.txt index 7829ada37..7e71fe024 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,7 +3,6 @@ einops >=0.6.0 huggingface_hub >= 0.13.0 lightning >= 2.0.1 omegaconf >=2.1,<3.0 -onnxruntime-gpu >= 1.16.0 pyannote.core >= 5.0.0 pyannote.database >= 5.0.1 pyannote.metrics >= 3.2 From 884913e1ac838af7d1451e5def997878c91ea46f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Tue, 14 Nov 2023 10:33:56 +0100 Subject: [PATCH 11/19] feat(model): add support for multi-speaker statistics pooling (#1386) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Hervé BREDIN --- CHANGELOG.md | 1 + pyannote/audio/models/blocks/pooling.py | 109 ++++++++++++++------ tests/test_stats_pool.py | 131 ++++++++++++++++++++++++ 3 files changed, 209 insertions(+), 32 deletions(-) create mode 100644 tests/test_stats_pool.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 8cd56ad36..3c8a4d8ff 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ - BREAKING(pipeline): rename `WeSpeakerPretrainedSpeakerEmbedding` to `ONNXWeSpeakerPretrainedSpeakerEmbedding` - BREAKING(setup): remove `onnxruntime` dependency. You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. +- feat(model): add support for multi-speaker statistics pooling ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/models/blocks/pooling.py b/pyannote/audio/models/blocks/pooling.py index debb05d13..b02f6f69e 100644 --- a/pyannote/audio/models/blocks/pooling.py +++ b/pyannote/audio/models/blocks/pooling.py @@ -1,6 +1,6 @@ # MIT License # -# Copyright (c) 2020 CNRS +# Copyright (c) 2020- CNRS # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal @@ -26,6 +26,7 @@ import torch import torch.nn as nn import torch.nn.functional as F +from einops import rearrange class StatsPool(nn.Module): @@ -40,49 +41,93 @@ class StatsPool(nn.Module): """ - def forward( - self, sequences: torch.Tensor, weights: Optional[torch.Tensor] = None - ) -> torch.Tensor: - """Forward pass + def _pool(self, sequences: torch.Tensor, weights: torch.Tensor) -> torch.Tensor: + """Helper function to compute statistics pooling + + Assumes that weights are already interpolated to match the number of frames + in sequences and that they encode the activation of only one speaker. Parameters ---------- - sequences : (batch, channel, frames) torch.Tensor - Sequences. - weights : (batch, frames) torch.Tensor, optional - When provided, compute weighted mean and standard deviation. + sequences : (batch, features, frames) torch.Tensor + Sequences of features. + weights : (batch, frames) torch.Tensor + (Already interpolated) weights. Returns ------- - output : (batch, 2 * channel) torch.Tensor + output : (batch, 2 * features) torch.Tensor Concatenation of mean and (unbiased) standard deviation. """ - if weights is None: - mean = sequences.mean(dim=2) - std = sequences.std(dim=2, unbiased=True) + weights = weights.unsqueeze(dim=1) + # (batch, 1, frames) - else: - weights = weights.unsqueeze(dim=1) - # (batch, 1, frames) + v1 = weights.sum(dim=2) + 1e-8 + mean = torch.sum(sequences * weights, dim=2) / v1 + + dx2 = torch.square(sequences - mean.unsqueeze(2)) + v2 = torch.square(weights).sum(dim=2) + + var = torch.sum(dx2 * weights, dim=2) / (v1 - v2 / v1) + std = torch.sqrt(var) + + return torch.cat([mean, std], dim=1) + + def forward( + self, sequences: torch.Tensor, weights: Optional[torch.Tensor] = None + ) -> torch.Tensor: + """Forward pass - num_frames = sequences.shape[2] - num_weights = weights.shape[2] - if num_frames != num_weights: - warnings.warn( - f"Mismatch between frames ({num_frames}) and weights ({num_weights}) numbers." - ) - weights = F.interpolate( - weights, size=num_frames, mode="linear", align_corners=False - ) + Parameters + ---------- + sequences : (batch, features, frames) torch.Tensor + Sequences of features. + weights : (batch, frames) or (batch, speakers, frames) torch.Tensor, optional + Compute weighted mean and standard deviation, using provided `weights`. - v1 = weights.sum(dim=2) - mean = torch.sum(sequences * weights, dim=2) / v1 + Note + ---- + `sequences` and `weights` might use a different number of frames, in which case `weights` + are interpolated linearly to reach the number of frames in `sequences`. - dx2 = torch.square(sequences - mean.unsqueeze(2)) - v2 = torch.square(weights).sum(dim=2) + Returns + ------- + output : (batch, 2 * features) or (batch, speakers, 2 * features) torch.Tensor + Concatenation of mean and (unbiased) standard deviation. When `weights` are + provided with the `speakers` dimension, `output` is computed for each speaker + separately and returned as (batch, speakers, 2 * channel)-shaped tensor. + """ - var = torch.sum(dx2 * weights, dim=2) / (v1 - v2 / v1) - std = torch.sqrt(var) + if weights is None: + mean = sequences.mean(dim=-1) + std = sequences.std(dim=-1, correction=1) + return torch.cat([mean, std], dim=-1) - return torch.cat([mean, std], dim=1) + if weights.dim() == 2: + has_speaker_dimension = False + weights = weights.unsqueeze(dim=1) + # (batch, frames) -> (batch, 1, frames) + else: + has_speaker_dimension = True + + # interpolate weights if needed + _, _, num_frames = sequences.shape + _, _, num_weights = weights.shape + if num_frames != num_weights: + warnings.warn( + f"Mismatch between frames ({num_frames}) and weights ({num_weights}) numbers." + ) + weights = F.interpolate( + weights, size=num_frames, mode="linear", align_corners=False + ) + + output = rearrange( + torch.vmap(self._pool, in_dims=(None, 1))(sequences, weights), + "speakers batch features -> batch speakers features", + ) + + if not has_speaker_dimension: + return output.squeeze(dim=1) + + return output diff --git a/tests/test_stats_pool.py b/tests/test_stats_pool.py new file mode 100644 index 000000000..e30262eda --- /dev/null +++ b/tests/test_stats_pool.py @@ -0,0 +1,131 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import torch + +from pyannote.audio.models.blocks.pooling import StatsPool + + +def test_stats_pool_weightless(): + x = torch.Tensor([[[2.0, 4.0], [2.0, 4.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + stats_pool = StatsPool() + + y = stats_pool(x) + # (batch = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor([[3.0, 3.0, 1.4142, 1.4142], [1.0, 1.0, 0.0, 0.0]]), + ) + + +def test_stats_pool_one_speaker(): + x = torch.Tensor([[[2.0, 4.0], [2.0, 4.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + w = torch.Tensor( + [ + [0.5, 0.01], + [0.2, 0.1], + ] + ) + # (batch = 2, frames = 2) + + stats_pool = StatsPool() + + y = stats_pool(x, weights=w) + # (batch = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor([[2.0392, 2.0392, 1.4142, 1.4142], [1.0, 1.0, 0.0, 0.0]]), + ) + + +def test_stats_pool_multi_speaker(): + x = torch.Tensor([[[2.0, 4.0], [2.0, 4.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + w = torch.Tensor([[[0.1, 0.2], [0.2, 0.3]], [[0.001, 0.001], [0.2, 0.3]]]) + # (batch = 2, speakers = 2, frames = 2) + + stats_pool = StatsPool() + + y = stats_pool(x, weights=w) + # (batch = 2, speakers = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor( + [ + [[3.3333, 3.3333, 1.4142, 1.4142], [3.2, 3.2, 1.4142, 1.4142]], + [[1.0, 1.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.0]], + ] + ), + ) + + +def test_stats_pool_frame_mismatch(): + x = torch.Tensor([[[2.0, 2.0], [2.0, 2.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + stats_pool = StatsPool() + w = torch.Tensor( + [ + [0.5, 0.5, 0.0], + [0.0, 0.5, 0.5], + ] + ) + # (batch = 2, frames = 3) + + y = stats_pool(x, weights=w) + # (batch = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor([[2.0, 2.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.0]]), + ) + + +def test_stats_pool_all_zero_weights(): + x = torch.Tensor([[[2.0, 4.0], [2.0, 4.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + w = torch.Tensor( + [ + [0.5, 0.01], + [0.0, 0.0], # all zero weights + ] + ) + # (batch = 2, frames = 2) + + stats_pool = StatsPool() + + y = stats_pool(x, weights=w) + # (batch = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor([[2.0392, 2.0392, 1.4142, 1.4142], [0.0, 0.0, 0.0, 0.0]]), + ) From 15b847acfbb4d80ee6262f1814eba97fd2e8f47f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 15 Nov 2023 16:23:40 +0100 Subject: [PATCH 12/19] fix(model): fix pooling layer (#1546) * fix(mps): fix support for MPS * fix: fix (unlikely but possible) division by zero --- pyannote/audio/models/blocks/pooling.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/pyannote/audio/models/blocks/pooling.py b/pyannote/audio/models/blocks/pooling.py index b02f6f69e..22d736a03 100644 --- a/pyannote/audio/models/blocks/pooling.py +++ b/pyannote/audio/models/blocks/pooling.py @@ -69,7 +69,7 @@ def _pool(self, sequences: torch.Tensor, weights: torch.Tensor) -> torch.Tensor: dx2 = torch.square(sequences - mean.unsqueeze(2)) v2 = torch.square(weights).sum(dim=2) - var = torch.sum(dx2 * weights, dim=2) / (v1 - v2 / v1) + var = torch.sum(dx2 * weights, dim=2) / (v1 - v2 / v1 + 1e-8) std = torch.sqrt(var) return torch.cat([mean, std], dim=1) @@ -118,9 +118,7 @@ def forward( warnings.warn( f"Mismatch between frames ({num_frames}) and weights ({num_weights}) numbers." ) - weights = F.interpolate( - weights, size=num_frames, mode="linear", align_corners=False - ) + weights = F.interpolate(weights, size=num_frames, mode="nearest") output = rearrange( torch.vmap(self._pool, in_dims=(None, 1))(sequences, weights), From 343ce66d674c5a1d970bbaf4fc6177ad936c7d82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 09:22:45 +0100 Subject: [PATCH 13/19] feat(model): add WeSpeaker embedding wrapper based on pytorch (#1540) --- CHANGELOG.md | 1 + pyannote/audio/models/embedding/__init__.py | 15 +- .../embedding/wespeaker/LICENSE.WeSpeaker | 21 ++ .../models/embedding/wespeaker/__init__.py | 236 ++++++++++++++ .../models/embedding/wespeaker/convert.py | 62 ++++ .../models/embedding/wespeaker/resnet.py | 302 ++++++++++++++++++ .../audio/pipelines/speaker_verification.py | 2 +- 7 files changed, 637 insertions(+), 2 deletions(-) create mode 100644 pyannote/audio/models/embedding/wespeaker/LICENSE.WeSpeaker create mode 100644 pyannote/audio/models/embedding/wespeaker/__init__.py create mode 100644 pyannote/audio/models/embedding/wespeaker/convert.py create mode 100644 pyannote/audio/models/embedding/wespeaker/resnet.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c8a4d8ff..2dff9c969 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ ## `develop` branch +- feat(pipeline): add WeSpeaker embedding wrapper - feat(pipeline): add `TimingHook` for profiling processing time - feat(pipeline): add `ArtifactHook` for saving internal steps - feat(pipeline): add support for list of hooks with `Hooks` diff --git a/pyannote/audio/models/embedding/__init__.py b/pyannote/audio/models/embedding/__init__.py index 08f8a576c..2819096c2 100644 --- a/pyannote/audio/models/embedding/__init__.py +++ b/pyannote/audio/models/embedding/__init__.py @@ -21,6 +21,19 @@ # SOFTWARE. +from .wespeaker import ( + WeSpeakerResNet34, + WeSpeakerResNet152, + WeSpeakerResNet221, + WeSpeakerResNet293, +) from .xvector import XVectorMFCC, XVectorSincNet -__all__ = ["XVectorSincNet", "XVectorMFCC"] +__all__ = [ + "XVectorSincNet", + "XVectorMFCC", + "WeSpeakerResNet34", + "WeSpeakerResNet152", + "WeSpeakerResNet221", + "WeSpeakerResNet293", +] diff --git a/pyannote/audio/models/embedding/wespeaker/LICENSE.WeSpeaker b/pyannote/audio/models/embedding/wespeaker/LICENSE.WeSpeaker new file mode 100644 index 000000000..136492006 --- /dev/null +++ b/pyannote/audio/models/embedding/wespeaker/LICENSE.WeSpeaker @@ -0,0 +1,21 @@ +Copyright (c) 2021 Shuai Wang (wsstriving@gmail.com) +2022 Zhengyang Chen (chenzhengyang117@gmail.com) +2023 Bing Han (hanbing97@sjtu.edu.cn) + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +File `resnet.py` has been borrowed from WeSpeaker that is available under the Apache License, Version 2.0. + +The original file is available at https://github.com/wenet-e2e/wespeaker/blob/c20d765295359e681321625fbefc1a02e8794163/wespeaker/models/resnet.py + +Neither Shuai Wang (@wsstriving on Github) nor myself (Hervé Bredin, or @hbredin on Github) are lawyers, but we both agreed that putting this license file in this directory is enough to comply with the license. See https://github.com/pyannote/pyannote-audio/issues/1537#issuecomment-1808029836. If you know better about this potential MIT/Apache 2.0 compatibility issue, please let us know. diff --git a/pyannote/audio/models/embedding/wespeaker/__init__.py b/pyannote/audio/models/embedding/wespeaker/__init__.py new file mode 100644 index 000000000..603a88c64 --- /dev/null +++ b/pyannote/audio/models/embedding/wespeaker/__init__.py @@ -0,0 +1,236 @@ +# MIT License +# +# Copyright (c) 2023 CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +from functools import partial +from typing import Optional + +import torch +import torchaudio.compliance.kaldi as kaldi + +from pyannote.audio.core.model import Model +from pyannote.audio.core.task import Task + +from .resnet import ResNet34, ResNet152, ResNet221, ResNet293 + + +class BaseWeSpeakerResNet(Model): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__(sample_rate=sample_rate, num_channels=num_channels, task=task) + + self.save_hyperparameters( + "sample_rate", + "num_channels", + "num_mel_bins", + "frame_length", + "frame_shift", + "dither", + "window_type", + "use_energy", + ) + + self._fbank = partial( + kaldi.fbank, + num_mel_bins=self.hparams.num_mel_bins, + frame_length=self.hparams.frame_length, + frame_shift=self.hparams.frame_shift, + dither=self.hparams.dither, + sample_frequency=self.hparams.sample_rate, + window_type=self.hparams.window_type, + use_energy=self.hparams.use_energy, + ) + + def compute_fbank(self, waveforms: torch.Tensor) -> torch.Tensor: + """Extract fbank features + + Parameters + ---------- + waveforms : (batch_size, num_channels, num_samples) + + Returns + ------- + fbank : (batch_size, num_frames, num_mel_bins) + + Source: https://github.com/wenet-e2e/wespeaker/blob/45941e7cba2c3ea99e232d02bedf617fc71b0dad/wespeaker/bin/infer_onnx.py#L30C1-L50 + """ + + waveforms = waveforms * (1 << 15) + + # fall back to CPU for FFT computation when using MPS + # until FFT is fixed in MPS + device = waveforms.device + fft_device = torch.device("cpu") if device.type == "mps" else device + + features = torch.vmap(self._fbank)(waveforms.to(fft_device)).to(device) + + return features - torch.mean(features, dim=1, keepdim=True) + + def forward( + self, waveforms: torch.Tensor, weights: torch.Tensor = None + ) -> torch.Tensor: + """ + + Parameters + ---------- + waveforms : torch.Tensor + Batch of waveforms with shape (batch, channel, sample) + weights : torch.Tensor, optional + Batch of weights with shape (batch, frame). + """ + + fbank = self.compute_fbank(waveforms) + return self.resnet(fbank, weights=weights)[1] + + +class WeSpeakerResNet34(BaseWeSpeakerResNet): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__( + sample_rate=sample_rate, + num_channels=num_channels, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + window_type=window_type, + use_energy=use_energy, + task=task, + ) + self.resnet = ResNet34( + num_mel_bins, 256, pooling_func="TSTP", two_emb_layer=False + ) + + +class WeSpeakerResNet152(BaseWeSpeakerResNet): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__( + sample_rate=sample_rate, + num_channels=num_channels, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + window_type=window_type, + use_energy=use_energy, + task=task, + ) + self.resnet = ResNet152( + num_mel_bins, 256, pooling_func="TSTP", two_emb_layer=False + ) + + +class WeSpeakerResNet221(BaseWeSpeakerResNet): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__( + sample_rate=sample_rate, + num_channels=num_channels, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + window_type=window_type, + use_energy=use_energy, + task=task, + ) + self.resnet = ResNet221( + num_mel_bins, 256, pooling_func="TSTP", two_emb_layer=False + ) + + +class WeSpeakerResNet293(BaseWeSpeakerResNet): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__( + sample_rate=sample_rate, + num_channels=num_channels, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + window_type=window_type, + use_energy=use_energy, + task=task, + ) + self.resnet = ResNet293( + num_mel_bins, 256, pooling_func="TSTP", two_emb_layer=False + ) + + +__all__ = [ + "WeSpeakerResNet34", + "WeSpeakerResNet152", + "WeSpeakerResNet221", + "WeSpeakerResNet293", +] diff --git a/pyannote/audio/models/embedding/wespeaker/convert.py b/pyannote/audio/models/embedding/wespeaker/convert.py new file mode 100644 index 000000000..34aec6092 --- /dev/null +++ b/pyannote/audio/models/embedding/wespeaker/convert.py @@ -0,0 +1,62 @@ +# MIT License +# +# Copyright (c) 2023 CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# Script used to convert from WeSpeaker to pyannote.audio + +import sys +from pathlib import Path + +import pytorch_lightning as pl +import torch + +import pyannote.audio.models.embedding.wespeaker as wespeaker +from pyannote.audio import Model +from pyannote.audio.core.task import Problem, Resolution, Specifications + +wespeaker_checkpoint_dir = sys.argv[1] # /path/to/wespeaker_cnceleb-resnet34-LM + +wespeaker_checkpoint = Path(wespeaker_checkpoint_dir) / "wespeaker.pt" + +depth = Path(wespeaker_checkpoint_dir).parts[-1].split("-")[-2][6:] # '34' +Klass = getattr(wespeaker, f"WeSpeakerResNet{depth}") # WeSpeakerResNet34 + +duration = 5.0 # whatever +specifications = Specifications( + problem=Problem.REPRESENTATION, resolution=Resolution.CHUNK, duration=duration +) + +state_dict = torch.load(wespeaker_checkpoint, map_location=torch.device("cpu")) +state_dict.pop("projection.weight") + +model = Klass() +model.resnet.load_state_dict(state_dict, strict=True) +model.specifications = specifications + +checkpoint = {"state_dict": model.state_dict()} +model.on_save_checkpoint(checkpoint) +checkpoint["pytorch-lightning_version"] = pl.__version__ + +pyannote_checkpoint = Path(wespeaker_checkpoint_dir) / "pytorch_model.bin" +torch.save(checkpoint, pyannote_checkpoint) + +model = Model.from_pretrained(pyannote_checkpoint) +print(model) diff --git a/pyannote/audio/models/embedding/wespeaker/resnet.py b/pyannote/audio/models/embedding/wespeaker/resnet.py new file mode 100644 index 000000000..54f95fa8b --- /dev/null +++ b/pyannote/audio/models/embedding/wespeaker/resnet.py @@ -0,0 +1,302 @@ +# Copyright (c) 2021 Shuai Wang (wsstriving@gmail.com) +# 2022 Zhengyang Chen (chenzhengyang117@gmail.com) +# 2023 Bing Han (hanbing97@sjtu.edu.cn) +# 2023 CNRS +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from einops import rearrange + +from pyannote.audio.models.blocks.pooling import StatsPool + + +class TSTP(nn.Module): + """ + Temporal statistics pooling, concatenate mean and std, which is used in + x-vector + Comment: simple concatenation can not make full use of both statistics + """ + + def __init__(self, in_dim=0, **kwargs): + super(TSTP, self).__init__() + self.in_dim = in_dim + self.stats_pool = StatsPool() + + def forward(self, features, weights: torch.Tensor = None): + """ + + Parameters + ---------- + features : (batch, dimension, channel, frames) torch.Tensor + Batch of features + weights: (batch, frames) torch.Tensor, optional + Batch of weights + + """ + + features = rearrange( + features, + "batch dimension channel frames -> batch (dimension channel) frames", + ) + + return self.stats_pool(features, weights=weights) + + # # The last dimension is the temporal axis + # pooling_mean = features.mean(dim=-1) + # pooling_std = torch.sqrt(torch.var(features, dim=-1) + 1e-7) + # pooling_mean = pooling_mean.flatten(start_dim=1) + # pooling_std = pooling_std.flatten(start_dim=1) + # stats = torch.cat((pooling_mean, pooling_std), 1) + # return stats + + def get_out_dim(self): + self.out_dim = self.in_dim * 2 + return self.out_dim + + +POOLING_LAYERS = {"TSTP": TSTP} + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, in_planes, planes, stride=1): + super(BasicBlock, self).__init__() + self.conv1 = nn.Conv2d( + in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False + ) + self.bn1 = nn.BatchNorm2d(planes) + self.conv2 = nn.Conv2d( + planes, planes, kernel_size=3, stride=1, padding=1, bias=False + ) + self.bn2 = nn.BatchNorm2d(planes) + + self.shortcut = nn.Sequential() + if stride != 1 or in_planes != self.expansion * planes: + self.shortcut = nn.Sequential( + nn.Conv2d( + in_planes, + self.expansion * planes, + kernel_size=1, + stride=stride, + bias=False, + ), + nn.BatchNorm2d(self.expansion * planes), + ) + + def forward(self, x): + out = F.relu(self.bn1(self.conv1(x))) + out = self.bn2(self.conv2(out)) + out += self.shortcut(x) + out = F.relu(out) + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, in_planes, planes, stride=1): + super(Bottleneck, self).__init__() + self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.conv2 = nn.Conv2d( + planes, planes, kernel_size=3, stride=stride, padding=1, bias=False + ) + self.bn2 = nn.BatchNorm2d(planes) + self.conv3 = nn.Conv2d( + planes, self.expansion * planes, kernel_size=1, bias=False + ) + self.bn3 = nn.BatchNorm2d(self.expansion * planes) + + self.shortcut = nn.Sequential() + if stride != 1 or in_planes != self.expansion * planes: + self.shortcut = nn.Sequential( + nn.Conv2d( + in_planes, + self.expansion * planes, + kernel_size=1, + stride=stride, + bias=False, + ), + nn.BatchNorm2d(self.expansion * planes), + ) + + def forward(self, x): + out = F.relu(self.bn1(self.conv1(x))) + out = F.relu(self.bn2(self.conv2(out))) + out = self.bn3(self.conv3(out)) + out += self.shortcut(x) + out = F.relu(out) + return out + + +class ResNet(nn.Module): + def __init__( + self, + block, + num_blocks, + m_channels=32, + feat_dim=40, + embed_dim=128, + pooling_func="TSTP", + two_emb_layer=True, + ): + super(ResNet, self).__init__() + self.in_planes = m_channels + self.feat_dim = feat_dim + self.embed_dim = embed_dim + self.stats_dim = int(feat_dim / 8) * m_channels * 8 + self.two_emb_layer = two_emb_layer + + self.conv1 = nn.Conv2d( + 1, m_channels, kernel_size=3, stride=1, padding=1, bias=False + ) + self.bn1 = nn.BatchNorm2d(m_channels) + self.layer1 = self._make_layer(block, m_channels, num_blocks[0], stride=1) + self.layer2 = self._make_layer(block, m_channels * 2, num_blocks[1], stride=2) + self.layer3 = self._make_layer(block, m_channels * 4, num_blocks[2], stride=2) + self.layer4 = self._make_layer(block, m_channels * 8, num_blocks[3], stride=2) + + self.pool = POOLING_LAYERS[pooling_func]( + in_dim=self.stats_dim * block.expansion + ) + self.pool_out_dim = self.pool.get_out_dim() + self.seg_1 = nn.Linear(self.pool_out_dim, embed_dim) + if self.two_emb_layer: + self.seg_bn_1 = nn.BatchNorm1d(embed_dim, affine=False) + self.seg_2 = nn.Linear(embed_dim, embed_dim) + else: + self.seg_bn_1 = nn.Identity() + self.seg_2 = nn.Identity() + + def _make_layer(self, block, planes, num_blocks, stride): + strides = [stride] + [1] * (num_blocks - 1) + layers = [] + for stride in strides: + layers.append(block(self.in_planes, planes, stride)) + self.in_planes = planes * block.expansion + return nn.Sequential(*layers) + + def forward(self, x: torch.Tensor, weights: torch.Tensor = None): + """ + + Parameters + ---------- + x : (batch, frames, features) torch.Tensor + Batch of features + weights : (batch, frames) torch.Tensor, optional + Batch of weights + + Returns + ------- + embedding : (batch, embedding_dim) torch.Tensor + """ + x = x.permute(0, 2, 1) # (B,T,F) => (B,F,T) + + x = x.unsqueeze_(1) + out = F.relu(self.bn1(self.conv1(x))) + out = self.layer1(out) + out = self.layer2(out) + out = self.layer3(out) + out = self.layer4(out) + + stats = self.pool(out, weights=weights) + + embed_a = self.seg_1(stats) + if self.two_emb_layer: + out = F.relu(embed_a) + out = self.seg_bn_1(out) + embed_b = self.seg_2(out) + return embed_a, embed_b + else: + return torch.tensor(0.0), embed_a + + +def ResNet18(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + BasicBlock, + [2, 2, 2, 2], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet34(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + BasicBlock, + [3, 4, 6, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet50(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [3, 4, 6, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet101(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [3, 4, 23, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet152(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [3, 8, 36, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet221(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [6, 16, 48, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet293(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [10, 20, 64, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 9f10f6e51..c870ea622 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -687,7 +687,7 @@ def min_num_samples(self) -> int: try: _ = self.model_(torch.randn(1, 1, middle).to(self.device)) upper = middle - except RuntimeError: + except Exception: lower = middle middle = (lower + upper) // 2 From 6ad2f87015d6cfe660a098233ff2f72bbdc5cd84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 09:37:10 +0100 Subject: [PATCH 14/19] doc: update changelog (#1549) --- CHANGELOG.md | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2dff9c969..e506c0413 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,19 +2,30 @@ ## `develop` branch -- feat(pipeline): add WeSpeaker embedding wrapper +### New features + +- feat(model): add WeSpeaker embedding wrapper based on PyTorch +- feat(model): add support for multi-speaker statistics pooling - feat(pipeline): add `TimingHook` for profiling processing time - feat(pipeline): add `ArtifactHook` for saving internal steps - feat(pipeline): add support for list of hooks with `Hooks` -- BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) -- fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - feat(utils): add `"soft"` option to `Powerset.to_multilabel` -- improve(pipeline): compute `fbank` on GPU when requested + +### Fixes + +- fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided + +## Improvements + +- improve(pipeline): compute `fbank` on GPU when requested + +### Breaking changes + - BREAKING(pipeline): rename `WeSpeakerPretrainedSpeakerEmbedding` to `ONNXWeSpeakerPretrainedSpeakerEmbedding` - BREAKING(setup): remove `onnxruntime` dependency. You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. -- feat(model): add support for multi-speaker statistics pooling +- BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) ## Version 3.0.1 (2023-09-28) From 23001a75cf6b465d1d824b5a0bd96ffe32ba5bbc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 10:22:43 +0100 Subject: [PATCH 15/19] doc: fix typo in changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e506c0413..6feac98ae 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,7 +16,7 @@ - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided -## Improvements +### Improvements - improve(pipeline): compute `fbank` on GPU when requested From bbc804401ead3fe4819ccb1ee820fabbbd35404c Mon Sep 17 00:00:00 2001 From: Dmitrii Mukhutdinov Date: Thu, 16 Nov 2023 18:29:41 +0800 Subject: [PATCH 16/19] fix(pipeline): fix frame-wise speaker count exceeding max_speakers * fix(pipeline): fix frame-wise speaker count exceeding max_speakers or detected num_speakers in SpeakerDiarization pipeline * BREAKING(pipeline): remove onset and offset parameter in SpeakerDiarizationMixin.speaker_count --- CHANGELOG.md | 3 + pyannote/audio/pipelines/clustering.py | 1 - pyannote/audio/pipelines/resegmentation.py | 11 +++- .../audio/pipelines/speaker_diarization.py | 65 +++++++++++++------ pyannote/audio/pipelines/utils/diarization.py | 18 ++--- 5 files changed, 62 insertions(+), 36 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6feac98ae..19e25f36e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,7 @@ - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided +- fix(pipeline): fix frame-wise speaker count exceeding `max_speakers` or detected `num_speakers` in `SpeakerDiarization` pipeline ### Improvements @@ -26,6 +27,8 @@ - BREAKING(setup): remove `onnxruntime` dependency. You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. - BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) +- BREAKING(pipeline): remove `onset` and `offset` parameter in `SpeakerDiarizationMixin.speaker_count` + You should now binarize segmentations before passing them to `speaker_count` ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index c51cdcc50..b63ab214f 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -253,7 +253,6 @@ def __call__( hard_clusters = np.zeros((num_chunks, num_speakers), dtype=np.int8) soft_clusters = np.ones((num_chunks, num_speakers, 1)) centroids = np.mean(train_embeddings, axis=0, keepdims=True) - return hard_clusters, soft_clusters, centroids train_clusters = self.cluster( diff --git a/pyannote/audio/pipelines/resegmentation.py b/pyannote/audio/pipelines/resegmentation.py index bb71abf22..d01e5d65f 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -39,6 +39,7 @@ get_model, ) from pyannote.audio.utils.permutation import mae_cost_func, permutate +from pyannote.audio.utils.signal import binarize class Resegmentation(SpeakerDiarizationMixin, Pipeline): @@ -181,11 +182,17 @@ def apply( hook("segmentation", segmentations) - # estimate frame-level number of instantaneous speakers - count = self.speaker_count( + # binarize segmentations before speaker counting + binarized_segmentations: SlidingWindowFeature = binarize( segmentations, onset=self.onset, offset=self.offset, + initial_state=False, + ) + + # estimate frame-level number of instantaneous speakers + count = self.speaker_count( + binarized_segmentations, warm_up=(self.warm_up, self.warm_up), frames=self._frames, ) diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index d5cf04e05..354f6be7e 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -25,6 +25,8 @@ import functools import itertools import math +import textwrap +import warnings from typing import Callable, Optional, Text, Union import numpy as np @@ -478,12 +480,19 @@ def apply( hook("segmentation", segmentations) # shape: (num_chunks, num_frames, local_num_speakers) + # binarize segmentation + if self._segmentation.model.specifications.powerset: + binarized_segmentations = segmentations + else: + binarized_segmentations: SlidingWindowFeature = binarize( + segmentations, + onset=self.segmentation.threshold, + initial_state=False, + ) + # estimate frame-level number of instantaneous speakers count = self.speaker_count( - segmentations, - onset=0.5 - if self._segmentation.model.specifications.powerset - else self.segmentation.threshold, + binarized_segmentations, frames=self._frames, warm_up=(0.0, 0.0), ) @@ -499,16 +508,6 @@ def apply( return diarization - # binarize segmentation - if self._segmentation.model.specifications.powerset: - binarized_segmentations = segmentations - else: - binarized_segmentations: SlidingWindowFeature = binarize( - segmentations, - onset=self.segmentation.threshold, - initial_state=False, - ) - if self.klustering == "OracleClustering" and not return_embeddings: embeddings = None else: @@ -533,6 +532,27 @@ def apply( # hard_clusters: (num_chunks, num_speakers) # centroids: (num_speakers, dimension) + # number of detected clusters is the number of different speakers + num_different_speakers = np.max(hard_clusters) + 1 + + # detected number of speakers can still be out of bounds + # (specifically, lower than `min_speakers`), since there could be too few embeddings + # to make enough clusters with a given minimum cluster size. + if num_different_speakers < min_speakers or num_different_speakers > max_speakers: + warnings.warn(textwrap.dedent( + f""" + The detected number of speakers ({num_different_speakers}) is outside + the given bounds [{min_speakers}, {max_speakers}]. This can happen if the + given audio file is too short to contain {min_speakers} or more speakers. + Try to lower the desired minimal number of speakers. + """ + )) + + # during counting, we could possibly overcount the number of instantaneous + # speakers due to segmentation errors, so we cap the maximum instantaneous number + # of speakers by the `max_speakers` value + count.data = np.minimum(count.data, max_speakers).astype(np.int8) + # reconstruct discrete diarization from raw hard clusters # keep track of inactive speakers @@ -588,6 +608,18 @@ def apply( if not return_embeddings: return diarization + # this can happen when we use OracleClustering + if centroids is None: + return diarization, None + + # The number of centroids may be smaller than the number of speakers + # in the annotation. This can happen if the number of active speakers + # obtained from `speaker_count` for some frames is larger than the number + # of clusters obtained from `clustering`. In this case, we append zero embeddings + # for extra speakers + if len(diarization.labels()) > centroids.shape[0]: + centroids = np.pad(centroids, ((0, len(diarization.labels()) - centroids.shape[0]), (0, 0))) + # re-order centroids so that they match # the order given by diarization.labels() inverse_mapping = {label: index for index, label in mapping.items()} @@ -595,11 +627,6 @@ def apply( [inverse_mapping[label] for label in diarization.labels()] ] - # FIXME: the number of centroids may be smaller than the number of speakers - # in the annotation. This can happen if the number of active speakers - # obtained from `speaker_count` for some frames is larger than the number - # of clusters obtained from `clustering`. Will be fixed in the future - return diarization, centroids def get_metric(self) -> GreedyDiarizationErrorRate: diff --git a/pyannote/audio/pipelines/utils/diarization.py b/pyannote/audio/pipelines/utils/diarization.py index 91413350b..4a35f7049 100644 --- a/pyannote/audio/pipelines/utils/diarization.py +++ b/pyannote/audio/pipelines/utils/diarization.py @@ -117,13 +117,10 @@ def optimal_mapping( else: return mapped_hypothesis - # TODO: get rid of onset/offset (binarization should be applied before calling speaker_count) # TODO: get rid of warm-up parameter (trimming should be applied before calling speaker_count) @staticmethod def speaker_count( - segmentations: SlidingWindowFeature, - onset: float = 0.5, - offset: float = None, + binarized_segmentations: SlidingWindowFeature, warm_up: Tuple[float, float] = (0.1, 0.1), frames: SlidingWindow = None, ) -> SlidingWindowFeature: @@ -131,12 +128,8 @@ def speaker_count( Parameters ---------- - segmentations : SlidingWindowFeature - (num_chunks, num_frames, num_classes)-shaped scores. - onset : float, optional - Onset threshold. Defaults to 0.5 - offset : float, optional - Offset threshold. Defaults to `onset`. + binarized_segmentations : SlidingWindowFeature + (num_chunks, num_frames, num_classes)-shaped binarized scores. warm_up : (float, float) tuple, optional Left/right warm up ratio of chunk duration. Defaults to (0.1, 0.1), i.e. 10% on both sides. @@ -151,10 +144,7 @@ def speaker_count( (num_frames, 1)-shaped instantaneous speaker count """ - binarized: SlidingWindowFeature = binarize( - segmentations, onset=onset, offset=offset, initial_state=False - ) - trimmed = Inference.trim(binarized, warm_up=warm_up) + trimmed = Inference.trim(binarized_segmentations, warm_up=warm_up) count = Inference.aggregate( np.sum(trimmed, axis=-1, keepdims=True), frames=frames, From 3403b7a9a36fef836e3fa0fc934590a9ea4a1570 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 12:57:12 +0100 Subject: [PATCH 17/19] improve(cli): store top 10 checkpoints rather than top 1 --- pyannote/audio/cli/train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index 9ab8b1658..74041554b 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -115,7 +115,7 @@ def configure_optimizers(self): checkpoint = ModelCheckpoint( monitor=monitor, mode=direction, - save_top_k=None if monitor is None else 1, + save_top_k=None if monitor is None else 10, every_n_epochs=1, save_last=True, save_weights_only=False, From ffd5b816caf272b7fce599f1b59ca09762b70b20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 13:24:08 +0100 Subject: [PATCH 18/19] doc: update changelog --- CHANGELOG.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 19e25f36e..346d8ad26 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ ## `develop` branch +## Version 3.1.0 (2023-11-16) + +### TL;DR + +[`pyannote/speaker-diarization-3.1`](https://hf.co/pyannote/speaker-diarization-3.1) no longer requires [unpopular](https://github.com/pyannote/pyannote-audio/issues/1537) ONNX runtime + ### New features - feat(model): add WeSpeaker embedding wrapper based on PyTorch @@ -27,7 +33,7 @@ - BREAKING(setup): remove `onnxruntime` dependency. You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. - BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) -- BREAKING(pipeline): remove `onset` and `offset` parameter in `SpeakerDiarizationMixin.speaker_count` +- BREAKING(pipeline): remove `onset` and `offset` parameter in `SpeakerDiarizationMixin.speaker_count` You should now binarize segmentations before passing them to `speaker_count` ## Version 3.0.1 (2023-09-28) From eecc634df83c5c273b4aa0723e8e467efa1e7765 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 13:24:41 +0100 Subject: [PATCH 19/19] setup: bump version --- version.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.txt b/version.txt index cb2b00e4f..fd2a01863 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -3.0.1 +3.1.0