{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "sb_auto_header", "tags": [ "sb_auto_header" ] }, "source": [ "\n", "\n", "\n", "[\"Open](https://colab.research.google.com/github/speechbrain/speechbrain/blob/develop/docs/tutorials/tasks/speech-classification-from-scratch.ipynb)\n", "to execute or view/download this notebook on\n", "[GitHub](https://github.com/speechbrain/speechbrain/tree/develop/docs/tutorials/tasks/speech-classification-from-scratch.ipynb)" ] }, { "cell_type": "markdown", "metadata": { "id": "uo0JP7a5uFp7" }, "source": [ "# Speech Classification From Scratch\n", "\n", "Do you want to figure out how to implement a **classification** system with SpeechBrain? Look no further, you're in the right place. This tutorial will walk you through all the steps needed to implement an **utterance-level classifier** in SpeechBrain. \n", "The tutorial will initially focus on **speaker identification** and will describe, along the way, how to extend it to many other classification tasks such as **language-id**, **emotion recognition**, **sound classification**, **keyword spotting**, and many others.\n", "\n", "\n", "## Models\n", "Many neural models can be used to approach this kind of task. In this tutorial, we will focus on a **TDNN** classifier (*xvector*) and a very recent model called [**ECAPA-TDNN**](https://arxiv.org/abs/2005.07143) that showed impressive performance in speaker verification and diarization.\n", "\n", "## Data\n", "Training will be done with a small open-source dataset called [mini-librispeech](https://www.openslr.org/31/), which only contains few hours of training data. In a real case, you need a much larger dataset.\n", "For some examples on a real task, please [take a look into our Voxceleb recipes](https://github.com/speechbrain/speechbrain/tree/develop/recipes/VoxCeleb/SpeakerRec).\n", "\n", "## Code\n", "In this tutorial, we will refer to the code in [```speechbrain/templates/speaker_id```](https://github.com/speechbrain/speechbrain/tree/develop/templates/speaker_id).\n", "\n", "## Installation\n", "Before starting, let's install speechbrain:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "id": "beagAGw5t5bK" }, "outputs": [], "source": [ "%%capture\n", "\n", "# Installing SpeechBrain via pip\n", "BRANCH = 'develop'\n", "!python -m pip install git+https://github.com/speechbrain/speechbrain.git@$BRANCH\n", "\n", "# Clone SpeechBrain repository (development branch)\n", "!git clone https://github.com/speechbrain/speechbrain/\n", "%cd /content/speechbrain/" ] }, { "cell_type": "markdown", "metadata": { "id": "eWpl9xgAIXKE" }, "source": [ "## Which steps are needed?\n", "Training an utterance-level classifier is relatively easy in SpeechBrain. The steps to follows are:\n", "\n", "1. **Prepare your data**.\n", "The goal of this step is to create the data manifest files (in CSV or JSON format). The data manifest files tell SpeechBrain where to find the speech data and their corresponding utterance-level classification (e.g., speaker id). In this tutorial, the data manifest files are created by [mini_librispeech_prepare.py](https://github.com/speechbrain/speechbrain/blob/develop/templates/speaker_id/mini_librispeech_prepare.py). \n", "\n", "2. **Train the classifier**.\n", "At this point, we are ready to train our classifier.\n", "To train a speaker-id classifier based on TDNN + statistical pooling (xvectors), run the following command:\n", "```\n", "cd speechbrain/templates/speaker_id/\n", "python train.py train.yaml\n", "```\n", "Later, we will describe how to plug another model called Emphasized Channel Attention, Propagation, and Aggregation model (ECAPA) that turned out to provide impressive performance in speaker recognition tasks.\n", "\n", "3. **Use the classifier (inference)**:\n", "After training, we can use the classifier for inference. A class called `EncoderClassifier` is designed to make inference easier. We also designed a class called `SpeakerRecognition` to make inference on a speaker verification task easier.\n", "\n", "\n", "\n", "We will now provide a detailed description of all these steps." ] }, { "cell_type": "markdown", "metadata": { "id": "rDgNu_b8k6qD" }, "source": [ "## Step 1: Prepare your data\n", "The goal of data preparation is to create the data manifest files.\n", "These files tell SpeechBrain where to find the audio data and their corresponding utterance-level classification. They are text files written in the popular CSV and JSON formats.\n", "\n", "### Data manifest files\n", "Let's take a look into how a data manifest file in JSON format looks like:\n", "\n", "\n", "```json\n", "{\n", " \"163-122947-0045\": {\n", " \"wav\": \"{data_root}/LibriSpeech/train-clean-5/163/122947/163-122947-0045.flac\",\n", " \"length\": 14.335,\n", " \"spk_id\": \"163\"\n", " },\n", " \"7312-92432-0025\": {\n", " \"wav\": \"{data_root}/LibriSpeech/train-clean-5/7312/92432/7312-92432-0025.flac\",\n", " \"length\": 12.01,\n", " \"spk_id\": \"7312\"\n", " },\n", " \"7859-102519-0036\": {\n", " \"wav\": \"{data_root}/LibriSpeech/train-clean-5/7859/102519/7859-102519-0036.flac\",\n", " \"length\": 11.965,\n", " \"spk_id\": \"7859\"\n", " },\n", "}\n", "```\n", "As you can see, we have a hierarchical structure in which the first key is a **unique identifier** of the spoken sentence.\n", "Then, we specify all the fields that are needed for the task addressed. For instance, we report the **path of the speech recording**, its **length** in seconds (needed if we wanna sort the sentences before creating the mini-batches), and the **speaker identity** of the speaker in the given recording.\n", "\n", "\n", "Actually, you can specify here all entries that you need (language-id, emotion annotation, etc). However, there must be a matching between the name of these entries and what the experiment script (e.g, train.py) expects. We will elaborate more on this later.\n", "\n", "You might have noticed that we define a special variable called `data_root`. This allows users to dynamically change the data folder from the command line (or from the yaml hyperparameter file).\n", "\n", "\n", "### Preparation Script\n", "**Every dataset is formatted in a different way**. The script that parses your own dataset and creates the JSON or the CSV files is something that you are supposed to write. Most of the time, this is very straightforward.\n", "\n", "For the mini-librispeech dataset, for instance, we wrote this simple data preparation script called [mini_librispeech_prepare.py](https://github.com/speechbrain/speechbrain/blob/develop/templates/speaker_id/mini_librispeech_prepare.py).\n", "\n", "This function automatically downloads the data (that in this case are publicly available). We search for all the audio files and while reading them we create the JSON file with the speaker-id annotation.\n", "\n", "You can use this script as a good base for your **custom preparation** on your target dataset. As you can see, we create three separate data manifest files to manage training, validation, and test phases.\n", "\n", "\n", "### Copy your data locally\n", "When using speechbrain (or any other toolkit) within an HPC cluster, a good practice is to compress your dataset in a single file and **copy (and uncompress) the data in the local folder of the computing node**. This would make the code much **much faster** because the data aren't fetched from the shared filesystem but from the local one. Moreover, you don't harm the performance of the shared filesystem with tons of reading operations. We **strongly suggest users follow this approach** (not possible here in Google Colab)." ] }, { "cell_type": "markdown", "metadata": { "id": "nkYENC7BJ4K9" }, "source": [ "## Step 2: Train the classifier\n", "We show now how we can train an **utterance-level classifier** with SpeechBrain.\n", "The proposed recipe performs a feature computation/normalization, processes the features with an encoder, and applies a classifier on top of that. Data augmentation is also employed to improve system performance.\n", "\n", "### Train a speaker-id model\n", "\n", "We are going to train the TDNN-based model used for x-vectors. Statistical pooling is used on the top of the convolutional layers to convert a variable-length sentence into a **fixed-length embeddings**.\n", "\n", "On the top of the embeddings, a simple fully-connected classifier is employed to predict which of the N speakers is active in the given sentence.\n", "\n", "\n", "To train this model, run the following code:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AtMw7x0ybFlI", "outputId": "7e016a65-0dd8-4607-b6cd-42c7f426ed07" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "/content/speechbrain/templates/speaker_id\n", "/usr/local/lib/python3.11/dist-packages/speechbrain/utils/autocast.py:188: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", " wrapped_fwd = torch.cuda.amp.custom_fwd(fwd, cast_inputs=cast_inputs)\n", "speechbrain.utils.quirks - Applied quirks (see `speechbrain.utils.quirks`): [allow_tf32, disable_jit_profiling]\n", "speechbrain.utils.quirks - Excluded quirks specified by the `SB_DISABLE_QUIRKS` environment (comma-separated list): []\n", "speechbrain.core - Beginning experiment!\n", "speechbrain.core - Experiment folder: ./results/speaker_id/1986\n", "Downloading http://www.openslr.org/resources/31/train-clean-5.tar.gz to ./data/train-clean-5.tar.gz\n", "train-clean-5.tar.gz: 333MB [00:18, 18.2MB/s] \n", "mini_librispeech_prepare - Creating train.json, valid.json, and test.json\n", "mini_librispeech_prepare - train.json successfully created!\n", "mini_librispeech_prepare - valid.json successfully created!\n", "mini_librispeech_prepare - test.json successfully created!\n", "Downloading https://www.dropbox.com/scl/fi/a09pj97s5ifan81dqhi4n/noises.zip?rlkey=j8b0n9kdjdr32o1f06t0cw5b7&dl=1 to ./data/noise/data.zip\n", "noises.zip?rlkey=j8b0n9kdjdr32o1f06t0cw5b7&dl=1: 569MB [00:42, 13.5MB/s] \n", "Extracting ./data/noise/data.zip to ./data/noise\n", "speechbrain.dataio.encoder - Load called, but CategoricalEncoder is not empty. Loaded data will overwrite everything. This is normal if there is e.g. an unk label defined at init.\n", "speechbrain.core - Info: ckpt_interval_minutes arg from hparam file is used\n", "speechbrain.core - Gradscaler enabled: `False`\n", "speechbrain.core - Using training precision: `--precision=fp32`\n", "speechbrain.core - Using evaluation precision: `--eval_precision=fp32`\n", "speechbrain.core - SpkIdBrain Model Statistics:\n", "* Total Number of Trainable Parameters: 4.5M\n", "* Total Number of Parameters: 4.5M\n", "* Trainable Parameters represent 100.0000% of the total size.\n", "/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py:624: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", " warnings.warn(\n", "speechbrain.utils.checkpoints - Would load a checkpoint here, but none found yet.\n", "speechbrain.utils.epoch_loop - Going into epoch 1\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:13<00:00, 1.04it/s, train_loss=1.73]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 5.62it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.001 to 0.00094\n", "speechbrain.utils.train_logger - Epoch: 1, lr: 1.00e-03 - train loss: 1.73 - valid loss: 1.01, valid error: 3.11e-01\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-52-54+00\n", "speechbrain.utils.epoch_loop - Going into epoch 2\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:11<00:00, 1.07it/s, train_loss=0.819]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.39it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00094 to 0.00087\n", "speechbrain.utils.train_logger - Epoch: 2, lr: 9.36e-04 - train loss: 8.19e-01 - valid loss: 2.71e-01, valid error: 8.61e-02\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-54-06+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-52-54+00\n", "speechbrain.utils.epoch_loop - Going into epoch 3\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:14<00:00, 1.02it/s, train_loss=0.64]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.59it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00087 to 0.00081\n", "speechbrain.utils.train_logger - Epoch: 3, lr: 8.71e-04 - train loss: 6.40e-01 - valid loss: 2.64e-01, valid error: 7.28e-02\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-55-22+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-54-06+00\n", "speechbrain.utils.epoch_loop - Going into epoch 4\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:13<00:00, 1.04it/s, train_loss=0.468]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.27it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00081 to 0.00074\n", "speechbrain.utils.train_logger - Epoch: 4, lr: 8.07e-04 - train loss: 4.68e-01 - valid loss: 1.03e-01, valid error: 3.31e-02\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-56-37+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-55-22+00\n", "speechbrain.utils.epoch_loop - Going into epoch 5\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:15<00:00, 1.00it/s, train_loss=0.414]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.15it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00074 to 0.00068\n", "speechbrain.utils.train_logger - Epoch: 5, lr: 7.43e-04 - train loss: 4.14e-01 - valid loss: 4.59e-02, valid error: 6.62e-03\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-57-54+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-56-37+00\n", "speechbrain.utils.epoch_loop - Going into epoch 6\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:12<00:00, 1.05it/s, train_loss=0.34]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 6.66it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00068 to 0.00061\n", "speechbrain.utils.train_logger - Epoch: 6, lr: 6.79e-04 - train loss: 3.40e-01 - valid loss: 1.59e-01, valid error: 5.96e-02\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-59-08+00\n", "speechbrain.utils.epoch_loop - Going into epoch 7\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:14<00:00, 1.02it/s, train_loss=0.304]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.06it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00061 to 0.00055\n", "speechbrain.utils.train_logger - Epoch: 7, lr: 6.14e-04 - train loss: 3.04e-01 - valid loss: 5.94e-02, valid error: 0.00e+00\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-00-24+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-59-08+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+14-57-54+00\n", "speechbrain.utils.epoch_loop - Going into epoch 8\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:12<00:00, 1.05it/s, train_loss=0.262]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 5.63it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00055 to 0.00049\n", "speechbrain.utils.train_logger - Epoch: 8, lr: 5.50e-04 - train loss: 2.62e-01 - valid loss: 3.93e-02, valid error: 6.62e-03\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-01-38+00\n", "speechbrain.utils.epoch_loop - Going into epoch 9\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:13<00:00, 1.03it/s, train_loss=0.24]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 5.04it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00049 to 0.00042\n", "speechbrain.utils.train_logger - Epoch: 9, lr: 4.86e-04 - train loss: 2.40e-01 - valid loss: 6.98e-02, valid error: 1.32e-02\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-02-54+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-01-38+00\n", "speechbrain.utils.epoch_loop - Going into epoch 10\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:12<00:00, 1.05it/s, train_loss=0.182]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.09it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00042 to 0.00036\n", "speechbrain.utils.train_logger - Epoch: 10, lr: 4.21e-04 - train loss: 1.82e-01 - valid loss: 2.60e-02, valid error: 6.62e-03\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-04-08+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-02-54+00\n", "speechbrain.utils.epoch_loop - Going into epoch 11\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:15<00:00, 1.01it/s, train_loss=0.17]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:02<00:00, 4.70it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00036 to 0.00029\n", "speechbrain.utils.train_logger - Epoch: 11, lr: 3.57e-04 - train loss: 1.70e-01 - valid loss: 1.19e-02, valid error: 0.00e+00\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-05-26+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-04-08+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-00-24+00\n", "speechbrain.utils.epoch_loop - Going into epoch 12\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:11<00:00, 1.06it/s, train_loss=0.138]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.18it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00029 to 0.00023\n", "speechbrain.utils.train_logger - Epoch: 12, lr: 2.93e-04 - train loss: 1.38e-01 - valid loss: 1.29e-02, valid error: 0.00e+00\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-06-39+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-05-26+00\n", "speechbrain.utils.epoch_loop - Going into epoch 13\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:12<00:00, 1.05it/s, train_loss=0.131]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.18it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00023 to 0.00016\n", "speechbrain.utils.train_logger - Epoch: 13, lr: 2.29e-04 - train loss: 1.31e-01 - valid loss: 7.04e-03, valid error: 0.00e+00\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-07-53+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-06-39+00\n", "speechbrain.utils.epoch_loop - Going into epoch 14\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:16<00:00, 1.00s/it, train_loss=0.106]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.57it/s]\n", "speechbrain.nnet.schedulers - Changing lr from 0.00016 to 0.0001\n", "speechbrain.utils.train_logger - Epoch: 14, lr: 1.64e-04 - train loss: 1.06e-01 - valid loss: 4.53e-03, valid error: 0.00e+00\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-09-11+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-07-53+00\n", "speechbrain.utils.epoch_loop - Going into epoch 15\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 76/76 [01:12<00:00, 1.05it/s, train_loss=0.0986]\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 6.86it/s]\n", "speechbrain.utils.train_logger - Epoch: 15, lr: 1.00e-04 - train loss: 9.86e-02 - valid loss: 3.67e-03, valid error: 0.00e+00\n", "speechbrain.utils.checkpoints - Saved an end-of-epoch checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-10-24+00\n", "speechbrain.utils.checkpoints - Deleted checkpoint in results/speaker_id/1986/save/CKPT+2025-05-22+15-09-11+00\n", "speechbrain.utils.checkpoints - Loading a checkpoint from results/speaker_id/1986/save/CKPT+2025-05-22+15-10-24+00\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "speechbrain.dataio.encoder - CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n", "100% 10/10 [00:01<00:00, 7.00it/s]\n", "speechbrain.utils.train_logger - Epoch loaded: 15 - test loss: 7.36e-03, test error: 0.00e+00\n" ] } ], "source": [ "%cd /content/speechbrain/templates/speaker_id\n", "!python train.py train.yaml --number_of_epochs=15 #--device='cpu'" ] }, { "cell_type": "markdown", "metadata": { "id": "b3tnXnrWc2My" }, "source": [ "As you can see from the prints, both the validation and training **losses are decreasing** very fast in the first epochs. Then, we basically see some minor improvements and performance oscillations.\n", "\n", "At the end of the training, the **validation error should go to zero** (or very close to zero).\n", "\n", "The task proposed in this tutorial is very easy because we only have to classify the 28 speakers of the mini-librispeech dataset. Take this tutorial just as an example that explains how to set up all the needed components to develop a speech classifier. [Please, refer to our voxceleb recipes if you would like to see an example on a popular speaker recognition dataset](https://github.com/speechbrain/speechbrain/tree/develop/recipes/VoxCeleb)\n", "\n", "\n", "\n", "Before diving into the code, let's see which files/folders are generated in the specified `output_folder`:\n", "\n", "* `train_log.txt`: contains the statistics (e.g, train_loss, valid_loss) computed at each epoch.\n", "* `log.txt`: is a more detailed logger containing the timestamps for each basic operation.\n", "* `env.log`: shows all the dependencies used with their corresponding version (useful for replicability).\n", "\n", "* `train.py`, `hyperparams.yaml`: are a copy of the experiment file along with the corresponding hyperparameters (for replicability).\n", "\n", "* `save`: is the place where we store the learned model.\n", "\n", "In the `save` folder, you find subfolders containing the checkpoints saved during training (in the format `CKPT+data+time`). Typically, you find here two checkpoints: the **best** (i.e, the oldest one) and the **latest** (i.e, the most recent one). If you find only a single checkpoint it means that the last epoch is also the best.\n", "\n", "Inside each checkpoint, we store all the information needed to **resume training** (e.g, models, optimizers, schedulers, epoch counter, etc.). The parameters of the embedding models are reported in `embedding_model.ckpt` file,\n", "while the ones of the classifier are in `classifier.ckpt`. This is just a binary format readable with `torch.load`.\n", "\n", "The save folder contains the **label encoder** (`label_encoder.txt`) as well, which maps each speaker-id entry to their corresponding indexes.\n", "\n", "```\n", "'163' => 0\n", "'7312' => 1\n", "'7859' => 2\n", "'19' => 3\n", "'1737' => 4\n", "'6272' => 5\n", "'1970' => 6\n", "'2416' => 7\n", "'118' => 8\n", "'6848' => 9\n", "'4680' => 10\n", "'460' => 11\n", "'3664' => 12\n", "'3242' => 13\n", "'1898' => 14\n", "'7367' => 15\n", "'1088' => 16\n", "'3947' => 17\n", "'3526' => 18\n", "'1867' => 19\n", "'8629' => 20\n", "'332' => 21\n", "'4640' => 22\n", "'2136' => 23\n", "'669' => 24\n", "'5789' => 25\n", "'32' => 26\n", "'226' => 27\n", "================\n", "'starting_index' => 0\n", "```\n", "\n", "\n", "As usual, we implement the system with an experiment file `train.py` and a hyperparameter file called `train.yaml`.\n", "\n", "### Hyperparameters\n", "The yaml file contains all the modules and hyperparameters need to implement the desired classifier.\n", "[You can take a look into the full train.yaml file here](https://github.com/speechbrain/speechbrain/blob/develop/templates/speaker_id/train.yaml).\n", "\n", "In the first part, we specify some basic settings, such as the seed and the path of the output folder:\n", "\n", "```yaml\n", "# Seed needs to be set at top of yaml, before objects with parameters are made\n", "seed: 1986\n", "__set_seed: !!python/object/apply:torch.manual_seed [!ref ]\n", "\n", "# If you plan to train a system on an HPC cluster with a big dataset,\n", "# we strongly suggest doing the following:\n", "# 1- Compress the dataset in a single tar or zip file.\n", "# 2- Copy your dataset locally (i.e., the local disk of the computing node).\n", "# 3- Uncompress the dataset in the local folder.\n", "# 4- Set data_folder with the local path.\n", "# Reading data from the local disk of the compute node (e.g. $SLURM_TMPDIR with SLURM-based clusters) is very important.\n", "# It allows you to read the data much faster without slowing down the shared filesystem.\n", "data_folder: ./data\n", "output_folder: !ref ./results/speaker_id/\n", "save_folder: !ref /save\n", "train_log: !ref /train_log.txt\n", "```\n", "\n", "We then specify the path of the data manifest files for training, validation, and test:\n", "\n", "```yaml\n", "# Path where data manifest files will be stored\n", "# The data manifest files are created by the data preparation script.\n", "train_annotation: train.json\n", "valid_annotation: valid.json\n", "test_annotation: test.json\n", "```\n", "\n", "These files will be automatically created when calling the data preparation script ([mini_librispeech_prepare.py](https://github.com/speechbrain/speechbrain/blob/develop/templates/speaker_id/mini_librispeech_prepare.py)) from the experiment file (`train.py`).\n", "\n", "\n", "Next, we set up the `train_logger` and declare the `error_stats` objects that will gather statistics on the classification error rate:\n", "\n", "\n", "```yaml\n", "# The train logger writes training statistics to a file, as well as stdout.\n", "train_logger: !new:speechbrain.utils.train_logger.FileTrainLogger\n", " save_file: !ref \n", "\n", "error_stats: !name:speechbrain.utils.metric_stats.MetricStats\n", " metric: !name:speechbrain.nnet.losses.classification_error\n", " reduction: batch\n", "```\n", "\n", "\n", "We can now specify some training hyperparameters such as the number of epochs, the batch size, the learning rate, the number of epochs, and the embedding dimensionality.\n", "\n", "\n", "```yaml\n", "ckpt_interval_minutes: 15 # save checkpoint every N min\n", "\n", "# Feature parameters\n", "n_mels: 23\n", "\n", "# Training Parameters\n", "sample_rate: 16000\n", "number_of_epochs: 35\n", "batch_size: 16\n", "lr_start: 0.001\n", "lr_final: 0.0001\n", "n_classes: 28 # In this case, we have 28 speakers\n", "emb_dim: 512 # dimensionality of the embeddings\n", "dataloader_options:\n", " batch_size: !ref \n", "```\n", "\n", "The variable `ckpt_interval_minutes` can be used to save checkpoints every N minutes within a training epoch. In some cases, one epoch might take several hours, and saving the checkpoint periodically is a good and safe practice. This feature is not really needed for this simple tutorial based on a tiny dataset.\n", "\n", "We can now define the most important modules that are needed to train our model:\n", "\n", "```yaml\n", "# Added noise and reverb come from OpenRIR dataset, automatically\n", "# downloaded and prepared with this Environmental Corruption class.\n", "env_corrupt: !new:speechbrain.lobes.augment.EnvCorrupt\n", " openrir_folder: !ref \n", " babble_prob: 0.0\n", " reverb_prob: 0.0\n", " noise_prob: 1.0\n", " noise_snr_low: 0\n", " noise_snr_high: 15\n", "\n", "# Adds speech change + time and frequency dropouts (time-domain implementation)\n", "# # A small speed change help to improve the performance of speaker-id as well.\n", "augmentation: !new:speechbrain.lobes.augment.TimeDomainSpecAugment\n", " sample_rate: !ref \n", " speeds: [95, 100, 105]\n", "\n", "# Feature extraction\n", "compute_features: !new:speechbrain.lobes.features.Fbank\n", " n_mels: !ref \n", "\n", "# Mean and std normalization of the input features\n", "mean_var_norm: !new:speechbrain.processing.features.InputNormalization\n", " norm_type: sentence\n", " std_norm: False\n", "\n", "# To design a custom model, either just edit the simple CustomModel\n", "# class that's listed here, or replace this `!new` call with a line\n", "# pointing to a different file you've defined.\n", "embedding_model: !new:custom_model.Xvector\n", " in_channels: !ref \n", " activation: !name:torch.nn.LeakyReLU\n", " tdnn_blocks: 5\n", " tdnn_channels: [512, 512, 512, 512, 1500]\n", " tdnn_kernel_sizes: [5, 3, 3, 1, 1]\n", " tdnn_dilations: [1, 2, 3, 1, 1]\n", " lin_neurons: !ref \n", "\n", "classifier: !new:custom_model.Classifier\n", " input_shape: [null, null, !ref ]\n", " activation: !name:torch.nn.LeakyReLU\n", " lin_blocks: 1\n", " lin_neurons: !ref \n", " out_neurons: !ref \n", "\n", "# The first object passed to the Brain class is this \"Epoch Counter\"\n", "# which is saved by the Checkpointer so that training can be resumed\n", "# if it gets interrupted at any point.\n", "epoch_counter: !new:speechbrain.utils.epoch_loop.EpochCounter\n", " limit: !ref \n", "\n", "# Objects in \"modules\" dict will have their parameters moved to the correct\n", "# device, as well as having train()/eval() called on them by the Brain class.\n", "modules:\n", " compute_features: !ref \n", " env_corrupt: !ref \n", " augmentation: !ref \n", " embedding_model: !ref \n", " classifier: !ref \n", " mean_var_norm: !ref \n", "```\n", "The augmentation part is based on both `env_corrupt` (that adds noise and reverberation) and `augmentation`(that adds time/frequency dropouts and speed change).\n", "For more information on these modules, please take a look at the tutorials on [enviromental corruption](https://speechbrain.readthedocs.io/en/latest/tutorials/preprocessing/environmental-corruption.html) and the one on [speech augmentation](https://speechbrain.readthedocs.io/en/latest/tutorials/preprocessing/speech-augmentation.html).\n", "\n", "\n", "\n", "We conclude the hyperparameter specification with the declaration of the optimizer, learning rate scheduler, and the checkpointer:\n", "\n", "\n", "```yaml\n", "# This optimizer will be constructed by the Brain class after all parameters\n", "# are moved to the correct device. Then it will be added to the checkpointer.\n", "opt_class: !name:torch.optim.Adam\n", " lr: !ref \n", "\n", "# This function manages learning rate annealing over the epochs.\n", "# We here use the simple lr annealing method that linearly decreases\n", "# the lr from the initial value to the final one.\n", "lr_annealing: !new:speechbrain.nnet.schedulers.LinearScheduler\n", " initial_value: !ref \n", " final_value: !ref \n", " epoch_count: !ref \n", "\n", "# This object is used for saving the state of training both so that it\n", "# can be resumed if it gets interrupted, and also so that the best checkpoint\n", "# can be later loaded for evaluation or inference.\n", "checkpointer: !new:speechbrain.utils.checkpoints.Checkpointer\n", " checkpoints_dir: !ref \n", " recoverables:\n", " embedding_model: !ref \n", " classifier: !ref \n", " normalizer: !ref \n", " counter: !ref \n", "```\n", "\n", "In this case, we use Adam as an optimizer and a linear learning rate decay over the 15 epochs.\n", "\n", "Let's now save the best model into a separate folder (useful for the inference part explained later):" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "jwoN5Vq0dFYe" }, "outputs": [], "source": [ "# Create folder for best model\n", "!mkdir /content/best_model/\n", "\n", "# Copy label encoder\n", "!cp results/speaker_id/1986/save/label_encoder.txt /content/best_model/\n", "\n", "# Copy best model\n", "!cp \"`ls -td results/speaker_id/1986/save/CKPT* | tail -1`\"/* /content/best_model/" ] }, { "cell_type": "markdown", "metadata": { "id": "mnCM5xuy85P4" }, "source": [ "### Experiment file\n", "Let's now take a look into how the objects, functions, and hyperparameters declared in the yaml file are used in `train.py` to implement the classifier.\n", "\n", "Let's start from the main of the `train.py`:\n", "\n", "\n", "```python\n", "# Recipe begins!\n", "if __name__ == \"__main__\":\n", "\n", " # Reading command line arguments.\n", " hparams_file, run_opts, overrides = sb.parse_arguments(sys.argv[1:])\n", "\n", " # Initialize ddp (useful only for multi-GPU DDP training).\n", " sb.utils.distributed.ddp_init_group(run_opts)\n", "\n", " # Load hyperparameters file with command-line overrides.\n", " with open(hparams_file) as fin:\n", " hparams = load_hyperpyyaml(fin, overrides)\n", "\n", " # Create experiment directory\n", " sb.create_experiment_directory(\n", " experiment_directory=hparams[\"output_folder\"],\n", " hyperparams_to_save=hparams_file,\n", " overrides=overrides,\n", " )\n", "\n", " # Data preparation, to be run on only one process.\n", " sb.utils.distributed.run_on_main(\n", " prepare_mini_librispeech,\n", " kwargs={\n", " \"data_folder\": hparams[\"data_folder\"],\n", " \"save_json_train\": hparams[\"train_annotation\"],\n", " \"save_json_valid\": hparams[\"valid_annotation\"],\n", " \"save_json_test\": hparams[\"test_annotation\"],\n", " \"split_ratio\": [80, 10, 10],\n", " },\n", " )\n", "```\n", "\n", "We here do some preliminary operations such as parsing the command line, initializing the distributed data-parallel (needed if multiple GPUs are used), creating the output folder, and reading the yaml file.\n", "\n", "After reading the yaml file with `load_hyperpyyaml`, all the objects declared in the hyperparameter files are initialized and available in a dictionary form (along with the other functions and parameters reported in the yaml file).\n", "For instance, we will have `hparams['embedding_model']`, `hparams['classifier']`, `hparams['batch_size']`, etc.\n", "\n", "We also run the data preparation script `prepare_mini_librispeech` that creates the data manifest files. It is wrapped with `sb.utils.distributed.run_on_main` because this operation writes the manifest files on disk and this must be done on a single process even in a multi-GPU DDP scenario. For more information on how to use multiple GPUs, [please take a look into this tutorial](https://speechbrain.readthedocs.io/en/latest/multigpu.html).\n", "\n", "\n", "#### Data-IO Pipeline\n", "We then call a special function that creates the dataset objects for training, validation, and test.\n", "\n", "```python\n", " # Create dataset objects \"train\", \"valid\", and \"test\".\n", " datasets = dataio_prep(hparams)\n", "```\n", "\n", "Let's take a closer look into that.\n", "\n", "\n", "```python\n", "def dataio_prep(hparams):\n", " \"\"\"This function prepares the datasets to be used in the brain class.\n", " It also defines the data processing pipeline through user-defined functions.\n", " We expect `prepare_mini_librispeech` to have been called before this,\n", " so that the `train.json`, `valid.json`, and `valid.json` manifest files\n", " are available.\n", " Arguments\n", " ---------\n", " hparams : dict\n", " This dictionary is loaded from the `train.yaml` file, and it includes\n", " all the hyperparameters needed for dataset construction and loading.\n", " Returns\n", " -------\n", " datasets : dict\n", " Contains two keys, \"train\" and \"valid\" that correspond\n", " to the appropriate DynamicItemDataset object.\n", " \"\"\"\n", "\n", " # Initialization of the label encoder. The label encoder assignes to each\n", " # of the observed label a unique index (e.g, 'spk01': 0, 'spk02': 1, ..)\n", " label_encoder = sb.dataio.encoder.CategoricalEncoder()\n", "\n", " # Define audio pipeline\n", " @sb.utils.data_pipeline.takes(\"wav\")\n", " @sb.utils.data_pipeline.provides(\"sig\")\n", " def audio_pipeline(wav):\n", " \"\"\"Load the signal, and pass it and its length to the corruption class.\n", " This is done on the CPU in the `collate_fn`.\"\"\"\n", " sig = sb.dataio.dataio.read_audio(wav)\n", " return sig\n", "\n", " # Define label pipeline:\n", " @sb.utils.data_pipeline.takes(\"spk_id\")\n", " @sb.utils.data_pipeline.provides(\"spk_id\", \"spk_id_encoded\")\n", " def label_pipeline(spk_id):\n", " yield spk_id\n", " spk_id_encoded = label_encoder.encode_label_torch(spk_id)\n", " yield spk_id_encoded\n", "\n", " # Define datasets. We also connect the dataset with the data processing\n", " # functions defined above.\n", " datasets = {}\n", " hparams[\"dataloader_options\"][\"shuffle\"] = False\n", " for dataset in [\"train\", \"valid\", \"test\"]:\n", " datasets[dataset] = sb.dataio.dataset.DynamicItemDataset.from_json(\n", " json_path=hparams[f\"{dataset}_annotation\"],\n", " replacements={\"data_root\": hparams[\"data_folder\"]},\n", " dynamic_items=[audio_pipeline, label_pipeline],\n", " output_keys=[\"id\", \"sig\", \"spk_id_encoded\"],\n", " )\n", "\n", " # Load or compute the label encoder (with multi-GPU DDP support)\n", " # Please, take a look into the lab_enc_file to see the label to index\n", " # mappinng.\n", " lab_enc_file = os.path.join(hparams[\"save_folder\"], \"label_encoder.txt\")\n", " label_encoder.load_or_create(\n", " path=lab_enc_file,\n", " from_didatasets=[datasets[\"train\"]],\n", " output_key=\"spk_id\",\n", " )\n", "\n", " return datasets\n", "```\n", "\n", "The first part is just a declaration of the `CategoricalEncoder` that will be used to convert categorical labels into their corresponding indexes.\n", "\n", "\n", "You can then notice that we expose the audio and label processing functions.\n", "\n", "The `audio_pipeline` takes the path of the audio signal (`wav`) and reads it. It returns a tensor containing the read speech sentence. The entry in input to this function (i.e, `wav`) must have the same name of the corresponding key in the data manifest file:\n", "\n", "```json\n", "{\n", " \"163-122947-0045\": {\n", " \"wav\": \"{data_root}/LibriSpeech/train-clean-5/163/122947/163-122947-0045.flac\",\n", " \"length\": 14.335,\n", " \"spk_id\": \"163\"\n", " },\n", "}\n", "```\n", "\n", "Similarly, we define another function called `label_pipeline` for processing the utterance-level labels and put them in a format usable by the defined model. The function reads the string `spk_id` defined in the JSON file and encodes it with the categorical encoder.\n", "\n", "We then create the `DynamicItemDataset` and connect it with the processing functions defined above. We define the **desired output keys** to expose. These keys will be available in the brain class within the batch variable as:\n", "- batch.id\n", "- batch.sig\n", "- batch.spk_id_encoded\n", "\n", "The last part of the function is dedicated to the initialization of the label encoder. The label encoder takes in input the training dataset and assigns a different index to all the `spk_id` entries founded. These indexes will correspond to the output indexes of the classifier.\n", "\n", "[For more information on the data loader, please take a look into this tutorial](https://speechbrain.readthedocs.io/en/latest/tutorials/basics/data-loading-pipeline.html)\n", "\n", "\n", "\n", "\n", "After the definition of the datasets, the main function can go ahead with the initialization and use of the brain class:\n", "\n", "```python\n", " # Initialize the Brain object to prepare for mask training.\n", " spk_id_brain = SpkIdBrain(\n", " modules=hparams[\"modules\"],\n", " opt_class=hparams[\"opt_class\"],\n", " hparams=hparams,\n", " run_opts=run_opts,\n", " checkpointer=hparams[\"checkpointer\"],\n", " )\n", "\n", " # The `fit()` method iterates the training loop, calling the methods\n", " # necessary to update the parameters of the model. Since all objects\n", " # with changing state are managed by the Checkpointer, training can be\n", " # stopped at any point, and will be resumed on next call.\n", " spk_id_brain.fit(\n", " epoch_counter=spk_id_brain.hparams.epoch_counter,\n", " train_set=datasets[\"train\"],\n", " valid_set=datasets[\"valid\"],\n", " train_loader_kwargs=hparams[\"dataloader_options\"],\n", " valid_loader_kwargs=hparams[\"dataloader_options\"],\n", " )\n", "\n", " # Load the best checkpoint for evaluation\n", " test_stats = spk_id_brain.evaluate(\n", " test_set=datasets[\"test\"],\n", " min_key=\"error\",\n", " test_loader_kwargs=hparams[\"dataloader_options\"],\n", " )\n", "```\n", "The `fit` method performs training, while the test is performed with the `evaluate` one. The training and validation data loaders are given in input to the fit method, while the test dataset is fed into the evaluate method.\n", "\n", "Let's now take a look into the most important methods defined in the brain class.\n", "\n", "\n", "\n", "#### Forward Computations\n", "\n", "Let's start with the `forward` function, which defines all the computations needed to transform the input audio into the output predictions.\n", "\n", "\n", "```python\n", " def compute_forward(self, batch, stage):\n", " \"\"\"Runs all the computation of that transforms the input into the\n", " output probabilities over the N classes.\n", " Arguments\n", " ---------\n", " batch : PaddedBatch\n", " This batch object contains all the relevant tensors for computation.\n", " stage : sb.Stage\n", " One of sb.Stage.TRAIN, sb.Stage.VALID, or sb.Stage.TEST.\n", " Returns\n", " -------\n", " predictions : Tensor\n", " Tensor that contains the posterior probabilities over the N classes.\n", " \"\"\"\n", "\n", " # We first move the batch to the appropriate device.\n", " batch = batch.to(self.device)\n", "\n", " # Compute features, embeddings, and predictions\n", " feats, lens = self.prepare_features(batch.sig, stage)\n", " embeddings = self.modules.embedding_model(feats, lens)\n", " predictions = self.modules.classifier(embeddings)\n", "\n", " return predictions\n", "```\n", "\n", "In this case, the chain of computation is very simple. We just put the batch on the right device and compute the acoustic features. We then process the features with the TDNN encoder that outputs a fixed-size tensor. The latter feeds a classifier that outputs the posterior probabilities over the N classes (in this case the 28 speakers). Data augmentation is added in the prepare_features method:\n", "\n", "```python\n", " def prepare_features(self, wavs, stage):\n", " \"\"\"Prepare the features for computation, including augmentation.\n", " Arguments\n", " ---------\n", " wavs : tuple\n", " Input signals (tensor) and their relative lengths (tensor).\n", " stage : sb.Stage\n", " The current stage of training.\n", " \"\"\"\n", " wavs, lens = wavs\n", "\n", " # Add augmentation if specified. In this version of augmentation, we\n", " # concatenate the original and the augment batches in a single bigger\n", " # batch. This is more memory-demanding, but helps to improve the\n", " # performance. Change it if you run OOM.\n", " if stage == sb.Stage.TRAIN:\n", " if hasattr(self.modules, \"env_corrupt\"):\n", " wavs_noise = self.modules.env_corrupt(wavs, lens)\n", " wavs = torch.cat([wavs, wavs_noise], dim=0)\n", " lens = torch.cat([lens, lens])\n", "\n", " if hasattr(self.hparams, \"augmentation\"):\n", " wavs = self.hparams.augmentation(wavs, lens)\n", "\n", " # Feature extraction and normalization\n", " feats = self.modules.compute_features(wavs)\n", " feats = self.modules.mean_var_norm(feats, lens)\n", "\n", " return feats, lens\n", "```\n", "In particular, when the environmental corruption is declared in the yaml file, we concatenate in the same batch both the clean and the augmented version of the signals.\n", "\n", "This approach doubles the batch size (and this the needed GPU memory), but it implements a very **powerful regularizer**. Having both the clean and the noisy version of the signal within the same batch forces the gradient to point into a direction of the parameter space that is **robust against signal distortions**.\n", "\n", "#### Compute Objectives\n", "\n", "Let's take a look now into the `compute_objectives` method that takes in input the targets, the predictions, and estimates a loss function:\n", "\n", "```python\n", " def compute_objectives(self, predictions, batch, stage):\n", " \"\"\"Computes the loss given the predicted and targeted outputs.\n", " Arguments\n", " ---------\n", " predictions : tensor\n", " The output tensor from `compute_forward`.\n", " batch : PaddedBatch\n", " This batch object contains all the relevant tensors for computation.\n", " stage : sb.Stage\n", " One of sb.Stage.TRAIN, sb.Stage.VALID, or sb.Stage.TEST.\n", " Returns\n", " -------\n", " loss : torch.Tensor\n", " A one-element tensor used for backpropagating the gradient.\n", " \"\"\"\n", "\n", " _, lens = batch.sig\n", " spkid, _ = batch.spk_id_encoded\n", "\n", " # Concatenate labels (due to data augmentation)\n", " if stage == sb.Stage.TRAIN and hasattr(self.modules, \"env_corrupt\"):\n", " spkid = torch.cat([spkid, spkid], dim=0)\n", " lens = torch.cat([lens, lens])\n", "\n", " # Compute the cost function\n", " loss = sb.nnet.losses.nll_loss(predictions, spkid, lens)\n", "\n", " # Append this batch of losses to the loss metric for easy\n", " self.loss_metric.append(\n", " batch.id, predictions, spkid, lens, reduction=\"batch\"\n", " )\n", "\n", " # Compute classification error at test time\n", " if stage != sb.Stage.TRAIN:\n", " self.error_metrics.append(batch.id, predictions, spkid, lens)\n", "\n", " return loss\n", "```\n", "The predictions in input are those computed in the forward method. The cost function is evaluated by comparing these predictions with the target labels. This is done with the Negative Log-Likelihood (NLL) loss.\n", "\n", "####**Other methods**\n", "Beyond these two important functions, we have some other methods that are used by the brain class. The `on_state_starts` gets called at the beginning of each epoch and it is used to set up statistics trackers. The `on_stage_end` one is called at the end of each stage (e.g, at the end of each training epoch) and mainly takes care of statistic management, learning rate annealing, and checkpointing. [For a more detailed description of the brain class, please take a look into this tutorial](https://speechbrain.readthedocs.io/en/latest/tutorials/basics/brain-class.html). For more information on checkpointing, [take a look here](https://speechbrain.readthedocs.io/en/latest/tutorials/basics/checkpointing.html)\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "4LnRq1_cpPXZ" }, "source": [ "## Step 3: Inference\n", "\n", "At this point, we can use the trained classifier to perform **predictions on new data**. Speechbrain made available some classes ([take a look here](https://github.com/speechbrain/speechbrain/blob/develop/speechbrain/inference/classifiers.py)) such as the `EncoderClassifier` one that can make inference easier. The class can also be used to extract some embeddings at the output of the encoder.\n", "\n", "Let's see first how can we used it to load our best xvector model (trained on Voxceleb and stored on HuggingFace) to compute some embeddings and perform a speaker classification:\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 804, "referenced_widgets": [ "a436cb5baef1422191c0d92caf127d14", "b2bcdd7e4676441dae05e6212ad51ee8", "6f562c8c50f24f3ebfe4c272ba508548", "c7ced7c215c146e5a2ba24145e9f5cce", "cbdd872bcc8a44219f7d3f735c7fc876", "a1b6aa1ae6824d1f934bfa2ddf617458", "cc735b2cdc4c45e4aa6a19d0be73be09", "675ec179af9f4fc28ea8b0b210cf5ebc", "b3eefd8092b74602aa973fdf33a80d6f", "65ae5e70856b4b0f9bea99714d07dda1", "bc4ffd0ca5f84af7acbdcb7de6702c47", "3a616257760e48b7bfe3c38980a36271", "ab693b816cfd4a67b13f301e9d186591", "6b9c3fff80094b83bac66d8c16411e97", "86bd02d6360f4b7abd3b07c7a7fb175d", "d8553b03699c447faa81e9b1068bf0c1", "99d171a1b5c34e5ca4698b02f7cfead8", "10a308d891da4d698e4d289c9bb29c06", "9886897b6131489d923fea2c39244e37", "5d59d9d95d3040c188811a9f755bccbf", "6e4671f3a74f4a1aa0dae77e1ac06eab", "529072e308c64811a3dc95bffe31ffe7", "78e0ca220ca04a8abd2e36fbb33e9479", "c056f40907b944e39f2131ef47755b15", "2f36faad96f9425d9e8f67be958b3f28", "02a1d8037c634363b0311bf0196db47c", "5c658cb3bff347bfa1fb55f213f82fd8", "7e495ee42bdc4520b2d69153bebe5838", "3371fb507d664eb087cc342c6a3ccb22", "d4d34a424da446dd8e3448d9cd982f11", "f16e3cb770dd43abb0c3fc7ba10e7858", "7086d0fcc3fe44039f05cc3c2b4a610b", "e75ca534b9e14ab9b17b043360266723", "cca22d03bd7c4a88a8cd27036da23c43", "8bf0008bf92c4e63b51d82075a133677", "bc7ffe052ca94b4988f35bd687406e0f", "26a70f330bad4d448f059b401f4b2816", "8e7b32b29dc844cda2637a028dbb0ef1", "af87a4ef6c3b4eaf8ee7cf506e7a295f", "eb99c6f60bd94c48b32ac6af6d31464a", "956a72f93c814392905fb07ed76a40b3", "c53bb16394a144bd8021ca8f52d9a8ce", "6ff2e8cbb30e4d1bb5691d985e0a9764", "f5cd21c666064b89949771ef49616910", "632f56cbf7e8434a8530b1d8cbb31efb", "507f59cb3c004e199013cc0f9bc77d08", "9b0d060f2ddb4455a3ef77818d56b33b", "25040fe4255a4a759d4207889bcb2eaa", "6c03d580bf50439e8a7ca3580ca5aea3", "f7a4481dcbeb41a7bb7c5f7c879f31c9", "e529d5f8145f496db1bb29872a22b124", "74d37a4cc3da4596b246fdf457dc4b05", "1e885488457649c2a7807dd90d7e2d0b", "a66dc32b31504316885e8ac74d1085a9", "22bbfdfca73b448593226042f616c30c" ] }, "id": "uvvY0dCbx5Sv", "outputId": "3235185a-0654-44b9-d6c4-c7c2cf479e47" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "DEBUG:speechbrain.utils.checkpoints:Registered checkpoint save hook for _speechbrain_save\n", "DEBUG:speechbrain.utils.checkpoints:Registered checkpoint load hook for _speechbrain_load\n", "DEBUG:speechbrain.utils.checkpoints:Registered checkpoint save hook for save\n", "DEBUG:speechbrain.utils.checkpoints:Registered checkpoint load hook for load\n", "DEBUG:speechbrain.utils.checkpoints:Registered checkpoint save hook for _save\n", "DEBUG:speechbrain.utils.checkpoints:Registered checkpoint load hook for _recover\n", "INFO:speechbrain.utils.fetching:Fetch hyperparams.yaml: Fetching from HuggingFace Hub 'speechbrain/spkrec-xvect-voxceleb' if not cached\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "hyperparams.yaml: 0%| | 0.00/2.04k [00:00 /root/.cache/huggingface/hub/models--speechbrain--spkrec-xvect-voxceleb/snapshots/56895a2df401be4150a159f3a1c653f00051d477/embedding_model.ckpt\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): mean_var_norm_emb -> /root/.cache/huggingface/hub/models--speechbrain--spkrec-xvect-voxceleb/snapshots/56895a2df401be4150a159f3a1c653f00051d477/mean_var_norm_emb.ckpt\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): classifier -> /root/.cache/huggingface/hub/models--speechbrain--spkrec-xvect-voxceleb/snapshots/56895a2df401be4150a159f3a1c653f00051d477/classifier.ckpt\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): label_encoder -> /root/.cache/huggingface/hub/models--speechbrain--spkrec-xvect-voxceleb/snapshots/56895a2df401be4150a159f3a1c653f00051d477/label_encoder.txt\n", "DEBUG:speechbrain.dataio.encoder:Loaded categorical encoding from /root/.cache/huggingface/hub/models--speechbrain--spkrec-xvect-voxceleb/snapshots/56895a2df401be4150a159f3a1c653f00051d477/label_encoder.txt\n", "WARNING:speechbrain.dataio.encoder:CategoricalEncoder.expect_len was never called: assuming category count of 7205 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "tensor([[-31.8672, -35.2025, -25.7931, ..., -21.0044, -12.4278, -21.5265]])\n", "tensor([-1.1279])\n", "tensor([2710])\n", "['id10892']\n" ] } ], "source": [ "import torchaudio\n", "from speechbrain.inference.classifiers import EncoderClassifier\n", "classifier = EncoderClassifier.from_hparams(source=\"speechbrain/spkrec-xvect-voxceleb\")\n", "signal, fs =torchaudio.load('/content/speechbrain/tests/samples/single-mic/example1.wav')\n", "\n", "# Compute speaker embeddings\n", "embeddings = classifier.encode_batch(signal)\n", "\n", "# Perform classification\n", "output_probs, score, index, text_lab = classifier.classify_batch(signal)\n", "\n", "# Posterior log probabilities\n", "print(output_probs)\n", "\n", "# Score (i.e, max log posteriors)\n", "print(score)\n", "\n", "# Index of the predicted speaker\n", "print(index)\n", "\n", "# Text label of the predicted speaker\n", "print(text_lab)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "LAZci6oSzdh_" }, "source": [ "For those of you interested in speaker verification, we also created an inference interface called `SpeakerRecognition`:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 613, "referenced_widgets": [ "887bb807621b4a52bafa603b423818d7", "862eb525376c4e9ebb2132e16b3a8dfc", "dbad817dc3af4e8c82451e5096058c95", "e47ca1f17a2e4fe9a7df688c20979c01", "9a3ff2ca0bd447f5abb5041b11196fdd", "24a7b20b24974d87a4a2e526ad88e3e9", "ed0b2233f75d4fc4a4ed87e6f93c038a", "c3f0c1d5be76417087c7e4e43783e426", "7851faaab81e413e9cebfeabd49735e3", "113d1a2b848f4c8e852ec8857ef2f3a1", "f57c32394adc43c0ac6a978bdfb7d61e", "faa9d965b36f4283bf35e640c2649577", "23d9fac6961243b58fd15b167d514021", "e8306633dec4482888a2c93dab1d69e6", "9a76581a68c14cbe9ef90f19f61cbf79", "22055e255223496fab6c96b23803406b", "0a86749f2a8140cca4f167ccde8d5dc9", "6145a9f19faa40168cf1054e3d5d5861", "8500f64b6b534eb689d6f8a9d536cd0c", "21a6c936feec4a878d26d171ad3897f9", "a0b9d575dab04492bfb401997257fcc2", "5252430fbff94d51aaf17e50367e42af", "c2289505161d4d47916376a84f63d153", "5210f390c42347499c89da7c2f8f333f", "cc457b0647f544e2a76d5345ef28f3a7", "6cc81cbfc6ab418e885c84ac2028d55d", "51a28ff42db34514bbdb9ceda0bc57ef", "b1ebfe23106a4cecbfa2496a1883fc16", "08f227fe1888468682630133dba8a389", "5d03389878fe40179850c0279d3afd9c", "71b55971c0e9446a978c2014f2f24d2d", "d20ce2bd6b1040a8b700e0b3249089ba", "b0564fc611df4282ba0a3730e6c5d2c7", "5ff5a61c0a954485866a7a92b8186cff", "5fd6afffa3c64d4fbf81623e9f02de0e", "86756fff0f424fdbbaae947b78c770e2", "9c10c16ecffc4f53969230b4994804fe", "984afd65bbb04202a09060500bd23b0f", "f0dd418cea0f486080356da09a1310bc", "109cb7412ed6490698aca150e1ecf86c", "1f7f9b00af8c46aea9cc7b943246d0fc", "fb8c1d51942a4fd78357cec0c0530808", "6808a5f59fb34e37be4d2aee4bbd7eeb", "9165a52e0949480aa936ae42040bd3cc", "9b437811fa164e5ca2b8eb9131338f89", "61f6950cb76643bc860e7a43e7e7bb58", "842094e522cc42a58dc9d1785bd9314e", "59bb0e1afd4247d78f254ff09ff354ca", "bd327f7a96ea484bb4913d9f64cc31eb", "260f1edf6acb478599fdc410072517b9", "033c839455d8408fb85e4272f744fb69", "9178f1efb3f640d5a08280e17c384b9a", "dcb14ddca33545139272eea73ca14248", "481e5a2f44db4757972410ae6f4baddd", "b978f40aa89d4cdfba13d7731dbee766" ] }, "id": "l-enSWy_z8CF", "outputId": "e45ec7c0-6129-467f-936c-4b0ea00efde2" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "INFO:speechbrain.utils.fetching:Fetch hyperparams.yaml: Fetching from HuggingFace Hub 'speechbrain/spkrec-ecapa-voxceleb' if not cached\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "hyperparams.yaml: 0%| | 0.00/1.92k [00:00 '/content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/hyperparams.yaml'\n", "INFO:speechbrain.utils.fetching:Fetch custom.py: Fetching from HuggingFace Hub 'speechbrain/spkrec-ecapa-voxceleb' if not cached\n", "DEBUG:speechbrain.utils.parameter_transfer:Collecting files (or symlinks) for pretraining in pretrained_models/spkrec-ecapa-voxceleb.\n", "INFO:speechbrain.utils.fetching:Fetch embedding_model.ckpt: Fetching from HuggingFace Hub 'speechbrain/spkrec-ecapa-voxceleb' if not cached\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "embedding_model.ckpt: 0%| | 0.00/83.3M [00:00 '/content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/embedding_model.ckpt'\n", "DEBUG:speechbrain.utils.parameter_transfer:Set local path in self.paths[\"embedding_model\"] = /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/embedding_model.ckpt\n", "INFO:speechbrain.utils.fetching:Fetch mean_var_norm_emb.ckpt: Fetching from HuggingFace Hub 'speechbrain/spkrec-ecapa-voxceleb' if not cached\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "mean_var_norm_emb.ckpt: 0%| | 0.00/1.92k [00:00 '/content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/mean_var_norm_emb.ckpt'\n", "DEBUG:speechbrain.utils.parameter_transfer:Set local path in self.paths[\"mean_var_norm_emb\"] = /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/mean_var_norm_emb.ckpt\n", "INFO:speechbrain.utils.fetching:Fetch classifier.ckpt: Fetching from HuggingFace Hub 'speechbrain/spkrec-ecapa-voxceleb' if not cached\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "classifier.ckpt: 0%| | 0.00/5.53M [00:00 '/content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/classifier.ckpt'\n", "DEBUG:speechbrain.utils.parameter_transfer:Set local path in self.paths[\"classifier\"] = /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/classifier.ckpt\n", "INFO:speechbrain.utils.fetching:Fetch label_encoder.txt: Fetching from HuggingFace Hub 'speechbrain/spkrec-ecapa-voxceleb' if not cached\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "label_encoder.txt: 0%| | 0.00/129k [00:00 '/content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/label_encoder.ckpt'\n", "DEBUG:speechbrain.utils.parameter_transfer:Set local path in self.paths[\"label_encoder\"] = /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/label_encoder.ckpt\n", "INFO:speechbrain.utils.parameter_transfer:Loading pretrained files for: embedding_model, mean_var_norm_emb, classifier, label_encoder\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): embedding_model -> /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/embedding_model.ckpt\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): mean_var_norm_emb -> /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/mean_var_norm_emb.ckpt\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): classifier -> /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/classifier.ckpt\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): label_encoder -> /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/label_encoder.ckpt\n", "DEBUG:speechbrain.dataio.encoder:Loaded categorical encoding from /content/speechbrain/templates/speaker_id/pretrained_models/spkrec-ecapa-voxceleb/label_encoder.ckpt\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "tensor([0.1799])\n", "tensor([False])\n" ] } ], "source": [ "from speechbrain.inference.speaker import SpeakerRecognition\n", "verification = SpeakerRecognition.from_hparams(source=\"speechbrain/spkrec-ecapa-voxceleb\", savedir=\"pretrained_models/spkrec-ecapa-voxceleb\")\n", "\n", "file1 = '/content/speechbrain/tests/samples/single-mic/example1.wav'\n", "file2 = '/content/speechbrain/tests/samples/single-mic/example2.flac'\n", "\n", "score, prediction = verification.verify_files(file1, file2)\n", "\n", "print(score)\n", "print(prediction) # True = same speaker, False=Different speakers" ] }, { "cell_type": "markdown", "metadata": { "id": "SbS7ZncE3IfM" }, "source": [ "But, *how does this work with our custom classifier that we trained before*?\n", "\n", "At this point, some options are available to you. For a full overview of all of them, [please take a look into this tutorial](https://speechbrain.readthedocs.io/en/latest/tutorials/tasks/speech-recognition-from-scratch.html).\n", "\n", "We here only show how you can use the existing `EncoderClassifier` on the model that we just trained.\n", "\n", "\n", "### Use the EncoderClassifier interface on your model\n", "\n", "The [EncoderClassifier class](https://github.com/speechbrain/speechbrain/blob/develop/speechbrain/inference/classifiers.py) takes a pre-trained model and performs inference on it with the following methods:\n", "\n", "- **encode_batch**: applies the encoder to an input batch and returns some encoded embeddings.\n", "- **classify_batch**: performs a full classification step and returns the output probabilities of the classifier, the best score, the index of the best class, and its label in text format (see example above).\n", "\n", "To use this interface with the model trained before, we have to create an **inference yaml** file which is a bit different from that use for training. The main differences are the following:\n", "\n", "1. You can remove all the hyperparameters and objects needed for training only. You can just keep the part related to the model definition.\n", "2. You have to allocate a `Categorical encoder` object that allows you to transform indexes into text labels.\n", "3. You have to use the pre-trainer to link your model with their corresponding files.\n", "\n", "The inference yaml file looks like that:\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ys41HanSaCys", "outputId": "2638b156-67d2-433e-d010-86247acab980" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Writing /content/best_model/hparams_inference.yaml\n" ] } ], "source": [ "%%writefile /content/best_model/hparams_inference.yaml\n", "\n", "# #################################\n", "# Basic inference parameters for speaker-id. We have first a network that\n", "# computes some embeddings. On the top of that, we employ a classifier.\n", "#\n", "# Author:\n", "# * Mirco Ravanelli 2021\n", "# #################################\n", "\n", "# pretrain folders:\n", "pretrained_path: /content/best_model/\n", "\n", "\n", "# Model parameters\n", "n_mels: 23\n", "sample_rate: 16000\n", "n_classes: 28 # In this case, we have 28 speakers\n", "emb_dim: 512 # dimensionality of the embeddings\n", "\n", "# Feature extraction\n", "compute_features: !new:speechbrain.lobes.features.Fbank\n", " n_mels: !ref \n", "\n", "# Mean and std normalization of the input features\n", "mean_var_norm: !new:speechbrain.processing.features.InputNormalization\n", " norm_type: sentence\n", " std_norm: False\n", "\n", "# To design a custom model, either just edit the simple CustomModel\n", "# class that's listed here, or replace this `!new` call with a line\n", "# pointing to a different file you've defined.\n", "embedding_model: !new:custom_model.Xvector\n", " in_channels: !ref \n", " activation: !name:torch.nn.LeakyReLU\n", " tdnn_blocks: 5\n", " tdnn_channels: [512, 512, 512, 512, 1500]\n", " tdnn_kernel_sizes: [5, 3, 3, 1, 1]\n", " tdnn_dilations: [1, 2, 3, 1, 1]\n", " lin_neurons: !ref \n", "\n", "classifier: !new:custom_model.Classifier\n", " input_shape: [null, null, !ref ]\n", " activation: !name:torch.nn.LeakyReLU\n", " lin_blocks: 1\n", " lin_neurons: !ref \n", " out_neurons: !ref \n", "\n", "label_encoder: !new:speechbrain.dataio.encoder.CategoricalEncoder\n", "\n", "# Objects in \"modules\" dict will have their parameters moved to the correct\n", "# device, as well as having train()/eval() called on them by the Brain class.\n", "modules:\n", " compute_features: !ref \n", " embedding_model: !ref \n", " classifier: !ref \n", " mean_var_norm: !ref \n", "\n", "pretrainer: !new:speechbrain.utils.parameter_transfer.Pretrainer\n", " loadables:\n", " embedding_model: !ref \n", " classifier: !ref \n", " label_encoder: !ref \n", " paths:\n", " embedding_model: !ref /embedding_model.ckpt\n", " classifier: !ref /classifier.ckpt\n", " label_encoder: !ref /label_encoder.txt\n" ] }, { "cell_type": "markdown", "metadata": { "id": "sDsp3atIiKSq" }, "source": [ "As you can see, we only have the model definition here (not optimizers, checkpoiter, etc). The last part of the yaml file manages pretraining, where we bind model objects with their pre-training files created at training time.\n", "\n", "Let's now perform inference with the `EncoderClassifier` class:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "2fT8ON1iiuQY", "outputId": "b7e6988f-dc35-426c-dd95-5665b78967f2" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "INFO:speechbrain.utils.fetching:Fetch hparams_inference.yaml: Using file found at '/content/best_model/hparams_inference.yaml'\n", "DEBUG:speechbrain.utils.fetching:Fetch: Source and destination '/content/best_model/custom.py' are identical, returning assuming this is intended\n", "DEBUG:speechbrain.utils.parameter_transfer:Collecting files (or symlinks) for pretraining in /content/best_model.\n", "INFO:speechbrain.utils.fetching:Fetch embedding_model.ckpt: Using file found at '/content/best_model/embedding_model.ckpt'\n", "DEBUG:speechbrain.utils.parameter_transfer:Set local path in self.paths[\"embedding_model\"] = /content/best_model/embedding_model.ckpt\n", "INFO:speechbrain.utils.fetching:Fetch classifier.ckpt: Using file found at '/content/best_model/classifier.ckpt'\n", "DEBUG:speechbrain.utils.parameter_transfer:Set local path in self.paths[\"classifier\"] = /content/best_model/classifier.ckpt\n", "DEBUG:speechbrain.utils.fetching:Fetch: Local file found, creating symlink '/content/best_model/label_encoder.txt' -> '/content/best_model/label_encoder.ckpt'\n", "DEBUG:speechbrain.utils.parameter_transfer:Set local path in self.paths[\"label_encoder\"] = /content/best_model/label_encoder.ckpt\n", "INFO:speechbrain.utils.parameter_transfer:Loading pretrained files for: embedding_model, classifier, label_encoder\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): embedding_model -> /content/best_model/embedding_model.ckpt\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): classifier -> /content/best_model/classifier.ckpt\n", "DEBUG:speechbrain.utils.parameter_transfer:Redirecting (loading from local path): label_encoder -> /content/best_model/label_encoder.ckpt\n", "DEBUG:speechbrain.dataio.encoder:Loaded categorical encoding from /content/best_model/label_encoder.ckpt\n", "WARNING:speechbrain.dataio.encoder:CategoricalEncoder.expect_len was never called: assuming category count of 28 to be correct! Sanity check your encoder using `.expect_len`. Ensure that downstream code also uses the correct size. If you are sure this does not apply to you, use `.ignore_len`.\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Target: 5789, Predicted: 5789\n", "Target: 460, Predicted: 460\n" ] } ], "source": [ "from speechbrain.inference.classifiers import EncoderClassifier\n", "\n", "classifier = EncoderClassifier.from_hparams(source=\"/content/best_model/\", hparams_file='hparams_inference.yaml', savedir=\"/content/best_model/\")\n", "\n", "# Perform classification\n", "audio_file = 'data/LibriSpeech/train-clean-5/5789/70653/5789-70653-0036.flac'\n", "signal, fs = torchaudio.load(audio_file) # test_speaker: 5789\n", "output_probs, score, index, text_lab = classifier.classify_batch(signal)\n", "print('Target: 5789, Predicted: ' + text_lab[0])\n", "\n", "# Another speaker\n", "audio_file = 'data/LibriSpeech/train-clean-5/460/172359/460-172359-0012.flac'\n", "signal, fs =torchaudio.load(audio_file) # test_speaker: 460\n", "output_probs, score, index, text_lab = classifier.classify_batch(signal)\n", "print('Target: 460, Predicted: ' + text_lab[0])\n", "\n", "# And if you want to extract embeddings...\n", "embeddings = classifier.encode_batch(signal)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "SSxRDjEnB0FA" }, "source": [ "The `EncoderClassifier` interface assumes that your model has the following modules specified in the yaml file:\n", "\n", "- *compute_features*: that manages feature extraction from the raw audio signal\n", "- *mean_var_norm*: that performs feature normalization\n", "- *embedding_model*: that converts features into fix-size embeddings.\n", "- *classifier*: that performs a final classification over N classes on the top o the embeddings.\n", "\n", "If your model cannot be structured in this way, you can always customize the `EncoderClassifier` interface to fulfill your needs.\n", "[Please, take a look into this tutorial for more information](https://speechbrain.readthedocs.io/en/latest/tutorials/tasks/speech-recognition-from-scratch.html).\n", " " ] }, { "cell_type": "markdown", "metadata": { "id": "z3pu0M42Pqju" }, "source": [ "## Extension to different tasks\n", "In a general case, you might have your own data and classification task and you would like to use your own model. Let's comment a bit more on how you can customize your recipe.\n", "\n", "**Suggestion**: start from a recipe that is working (like the one used for this template) and only do the minimal modifications needed to customize it. Test your model step by step. Make sure your model can overfit on a tiny dataset composed of few sentences. If it doesn't overfit there is likely a bug in your model." ] }, { "cell_type": "markdown", "metadata": { "id": "tImuOg5XP3CY" }, "source": [ "### Train with your data on your task\n", "What about if I have to solve another utterance-level classification task such as **language-id**, **emotion recognition**, **sound classification**, **keyword spotting** on my data?\n", "\n", "All you have to do is:\n", "1. Change the JSON with the annotations needed for your task.\n", "2. Change the data pipeline in `train.py` to be compliant with the new annotations.\n", "\n", "#### Change the JSON\n", "This tutorial expects JSON files like this:\n", "\n", "```json\n", "{\n", " \"163-122947-0045\": {\n", " \"wav\": \"{data_root}/LibriSpeech/train-clean-5/163/122947/163-122947-0045.flac\",\n", " \"length\": 14.335,\n", " \"spk_id\": \"163\"\n", " },\n", " \"7312-92432-0025\": {\n", " \"wav\": \"{data_root}/LibriSpeech/train-clean-5/7312/92432/7312-92432-0025.flac\",\n", " \"length\": 12.01,\n", " \"spk_id\": \"7312\"\n", " },\n", " \"7859-102519-0036\": {\n", " \"wav\": \"{data_root}/LibriSpeech/train-clean-5/7859/102519/7859-102519-0036.flac\",\n", " \"length\": 11.965,\n", " \"spk_id\": \"7859\"\n", " },\n", "}\n", "```\n", "\n", "However, you can add here all the entries that you want. For instance, if you would like to solve a language-id task, the JSON file should look like this:\n", "\n", "```json\n", "{\n", " \"sentence001\": {\n", " \"wav\": \"{data_root}/your_path/your_file1.wav\",\n", " \"length\": 10.335,\n", " \"lang_id\": \"Italian\"\n", " },\n", "{\n", " \"sentence002\": {\n", " \"wav\": \"{data_root}/your_path/your_file2.wav\",\n", " \"length\": 12.335,\n", " \"lang_id\": \"French\"\n", " },\n", "}\n", "```\n", "\n", "If you would like to solve an emotion recognition task, it will look like that:\n", "\n", "\n", "```json\n", "{\n", " \"sentence001\": {\n", " \"wav\": \"{data_root}/your_path/your_file1.wav\",\n", " \"length\": 10.335,\n", " \"emotion\": \"Happy\"\n", " },\n", "{\n", " \"sentence002\": {\n", " \"wav\": \"{data_root}/your_path/your_file2.wav\",\n", " \"length\": 12.335,\n", " \"emotion\": \"Sad\"\n", " },\n", "}\n", "```\n", "To create the data manifest files, you have to **parse your dataset and create JSON files** with a unique ID for each sentence, the path of the audio signal (wav), the length of the speech sentence in seconds (length), and the annotations that you want.\n", "\n", "#### Change train.py\n", "The only thing to remember is that the name entries in the JSON file must match with what the dataloader expectes in `train.py`. For instance, if you defined an emotion key in JSON, you should have it in the dataio pipeline of `train.py` something like this:\n", "\n", "```python\n", " # Define label pipeline:\n", " @sb.utils.data_pipeline.takes(\"emotion\")\n", " @sb.utils.data_pipeline.provides(\"emotion\", \"emotion_encoded\")\n", " def label_pipeline(emotion):\n", " yield emotion\n", " emotion_encoded = label_encoder.encode_label_torch(emotion)\n", " yield emotion_encoded\n", "```\n", "\n", "Basically, you have to replace the `spk_id` entry with the `emotion` one everywhere in the code. That's all!\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "IVCCe6cXPzJ0" }, "source": [ "### Train with your own model\n", "At some point, you might have your own model and you would like to plug it into the speech recognition pipeline.\n", "For instance, you might wanna replace our xvector encoder with something different.\n", "\n", "To do that, you have to create your own class and specify there the list of computations for your neural network. You can take a look into the models already existing in [speechbrain.lobes.models](https://github.com/speechbrain/speechbrain/tree/develop/speechbrain/lobes/models). If your model is a plain pipeline of computations, you can use the [sequential container](https://github.com/speechbrain/speechbrain/blob/develop/speechbrain/lobes/models/CRDNN.py#L14). If the model is a more complex chain of computations, you can create it as an instance of `torch.nn.Module` and define there the `__init__` and `forward` methods like [here](https://github.com/speechbrain/speechbrain/blob/develop/speechbrain/lobes/models/Xvector.py#L18).\n", "\n", "Once you defined your model, you only have to declare it in the yaml file and use it in `train.py`\n", "\n", "**Important:** \n", "When plugging a new model, you have to tune again the most important hyperparameters of the system (e.g, learning rate, batch size, and the architectural parameters) to make it working well.\n", "\n", "\n", "#### ECAPA-TDNN model\n", "One model that we find particularly effective for speaker recognition is the ECAPA-TDNN one [implemented here](https://github.com/speechbrain/speechbrain/blob/develop/speechbrain/lobes/models/ECAPA_TDNN.py).\n", "\n", "The ECAPA-TDNN architecture is based on the popular x-vector topology and it introduces **several enhancements** to create more robust speaker embeddings.\n", "\n", "The pooling layer uses a **channel- and context-dependent attention** mechanism, which allows the network to attend different frames per channel.\n", "1-dimensional **SqueezeExcitation** (SE) blocks rescale the channels of the intermediate frame-level feature maps to insert **global context** information in the locally operating convolutional blocks.\n", "Next, the integration of 1-dimensional **Res2-blocks** improves performance while simultaneously reducing the total parameter count\n", "by using grouped convolutions in a hierarchical way.\n", "\n", "Finally, **Multi-layer Feature Aggregation (MFA)** merges complementary information before the statistics pooling by concatenating the final frame-level feature map with an intermediate feature\n", "maps of preceding layers.\n", "\n", "The network is trained by optimizing the **AAMsoftmax** loss on the speaker identities in the training corpus. The AAM-softmax is a powerful enhancement compared to the regular softmax loss in the context of fine-grained classification and verification problems. It directly optimizes the\n", "cosine distance between the speaker embeddings.\n", "\n", "\n", "The model turned out to work amazingly well for [speaker verification](https://arxiv.org/abs/2005.07143) and [speaker diarization](https://arxiv.org/abs/2104.01466). We found it very effective in other utterance-level classification tasks such as language-id, emotion recognition, and keyword spotting.\n", "\n", "[Please take a look into the original paper for more info](https://arxiv.org/abs/2005.07143)\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "W4pPJ0k3lJZj" }, "source": [ "\n", "\n", "## Conclusion\n", "\n", "In this tutorial, we showed how to create an utterance-level classifier from scratch using SpeechBrain. The proposed system contains all the basic ingredients to develop a state-of-the-art system (i.e., data augmentation, feature extraction, encoding, statistical pooling, classifier, etc)\n", "\n", "We described all the steps using a small dataset only. In a real case you have to train with much more data (see for instance our [Voxceleb recipe](https://github.com/speechbrain/speechbrain/tree/develop/recipes/VoxCeleb))." ] }, { "cell_type": "markdown", "metadata": { "id": "P-Trg_abjUTd" }, "source": [ "## Related Tutorials\n", "1. [YAML hyperparameter specification](https://speechbrain.readthedocs.io/en/latest/tutorials/basics/hyperpyyaml.html)\n", "2. [Brain Class](https://speechbrain.readthedocs.io/en/latest/tutorials/basics/brain-class.html)\n", "3. [Checkpointing](https://speechbrain.readthedocs.io/en/latest/tutorials/basics/checkpointing.html)\n", "4. [Data-io](https://speechbrain.readthedocs.io/en/latest/tutorials/basics/data-loading-pipeline.html)\n", "5. [ASR from Scratch](https://speechbrain.readthedocs.io/en/latest/tutorials/tasks/speech-recognition-from-scratch.html)\n", "6. [Speech Features](https://speechbrain.readthedocs.io/en/latest/tutorials/preprocessing/speech-features.html)\n", "7. [Speech Augmentation](https://speechbrain.readthedocs.io/en/latest/tutorials/preprocessing/speech-augmentation.html)\n", "8. [Environmental Corruption](https://speechbrain.readthedocs.io/en/latest/tutorials/preprocessing/environmental-corruption.html)\n", "9. [MultiGPU Training](https://speechbrain.readthedocs.io/en/latest/multigpu.html)\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "sb_auto_footer", "tags": [ "sb_auto_footer" ] }, "source": [ "## Citing SpeechBrain\n", "\n", "If you use SpeechBrain in your research or business, please cite it using the following BibTeX entry:\n", "\n", "```bibtex\n", "@misc{speechbrainV1,\n", " title={Open-Source Conversational AI with {SpeechBrain} 1.0},\n", " author={Mirco Ravanelli and Titouan Parcollet and Adel Moumen and Sylvain de Langen and Cem Subakan and Peter Plantinga and Yingzhi Wang and Pooneh Mousavi and Luca Della Libera and Artem Ploujnikov and Francesco Paissan and Davide Borra and Salah Zaiem and Zeyu Zhao and Shucong Zhang and Georgios Karakasidis and Sung-Lin Yeh and Pierre Champion and Aku Rouhe and Rudolf Braun and Florian Mai and Juan Zuluaga-Gomez and Seyed Mahed Mousavi and Andreas Nautsch and Xuechen Liu and Sangeet Sagar and Jarod Duret and Salima Mdhaffar and Gaelle Laperriere and Mickael Rouvier and Renato De Mori and Yannick Esteve},\n", " year={2024},\n", " eprint={2407.00463},\n", " archivePrefix={arXiv},\n", " primaryClass={cs.LG},\n", " url={https://arxiv.org/abs/2407.00463},\n", "}\n", "@misc{speechbrain,\n", " title={{SpeechBrain}: A General-Purpose Speech Toolkit},\n", " author={Mirco Ravanelli and Titouan Parcollet and Peter Plantinga and Aku Rouhe and Samuele Cornell and Loren Lugosch and Cem Subakan and Nauman Dawalatabad and Abdelwahab Heba and Jianyuan Zhong and Ju-Chieh Chou and Sung-Lin Yeh and Szu-Wei Fu and Chien-Feng Liao and Elena Rastorgueva and François Grondin and William Aris and Hwidong Na and Yan Gao and Renato De Mori and Yoshua Bengio},\n", " year={2021},\n", " eprint={2106.04624},\n", " archivePrefix={arXiv},\n", " primaryClass={eess.AS},\n", " note={arXiv:2106.04624}\n", "}\n", "```" ] } ], "metadata": { "accelerator": "GPU", "colab": { "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.12.6" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "a436cb5baef1422191c0d92caf127d14": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_b2bcdd7e4676441dae05e6212ad51ee8", "IPY_MODEL_6f562c8c50f24f3ebfe4c272ba508548", "IPY_MODEL_c7ced7c215c146e5a2ba24145e9f5cce" ], "layout": "IPY_MODEL_cbdd872bcc8a44219f7d3f735c7fc876" } }, "b2bcdd7e4676441dae05e6212ad51ee8": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_a1b6aa1ae6824d1f934bfa2ddf617458", "placeholder": "​", "style": "IPY_MODEL_cc735b2cdc4c45e4aa6a19d0be73be09", "value": "hyperparams.yaml: 100%" } }, "6f562c8c50f24f3ebfe4c272ba508548": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_675ec179af9f4fc28ea8b0b210cf5ebc", "max": 2041, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_b3eefd8092b74602aa973fdf33a80d6f", "value": 2041 } }, "c7ced7c215c146e5a2ba24145e9f5cce": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_65ae5e70856b4b0f9bea99714d07dda1", "placeholder": "​", "style": "IPY_MODEL_bc4ffd0ca5f84af7acbdcb7de6702c47", "value": " 2.04k/2.04k [00:00<00:00, 209kB/s]" } }, "cbdd872bcc8a44219f7d3f735c7fc876": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "a1b6aa1ae6824d1f934bfa2ddf617458": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "cc735b2cdc4c45e4aa6a19d0be73be09": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "675ec179af9f4fc28ea8b0b210cf5ebc": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "b3eefd8092b74602aa973fdf33a80d6f": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "65ae5e70856b4b0f9bea99714d07dda1": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "bc4ffd0ca5f84af7acbdcb7de6702c47": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "3a616257760e48b7bfe3c38980a36271": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_ab693b816cfd4a67b13f301e9d186591", "IPY_MODEL_6b9c3fff80094b83bac66d8c16411e97", "IPY_MODEL_86bd02d6360f4b7abd3b07c7a7fb175d" ], "layout": "IPY_MODEL_d8553b03699c447faa81e9b1068bf0c1" } }, "ab693b816cfd4a67b13f301e9d186591": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_99d171a1b5c34e5ca4698b02f7cfead8", "placeholder": "​", "style": "IPY_MODEL_10a308d891da4d698e4d289c9bb29c06", "value": "embedding_model.ckpt: 100%" } }, "6b9c3fff80094b83bac66d8c16411e97": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_9886897b6131489d923fea2c39244e37", "max": 16887676, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_5d59d9d95d3040c188811a9f755bccbf", "value": 16887676 } }, "86bd02d6360f4b7abd3b07c7a7fb175d": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_6e4671f3a74f4a1aa0dae77e1ac06eab", "placeholder": "​", "style": "IPY_MODEL_529072e308c64811a3dc95bffe31ffe7", "value": " 16.9M/16.9M [00:00<00:00, 67.2MB/s]" } }, "d8553b03699c447faa81e9b1068bf0c1": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "99d171a1b5c34e5ca4698b02f7cfead8": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "10a308d891da4d698e4d289c9bb29c06": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "9886897b6131489d923fea2c39244e37": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "5d59d9d95d3040c188811a9f755bccbf": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "6e4671f3a74f4a1aa0dae77e1ac06eab": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "529072e308c64811a3dc95bffe31ffe7": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "78e0ca220ca04a8abd2e36fbb33e9479": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_c056f40907b944e39f2131ef47755b15", "IPY_MODEL_2f36faad96f9425d9e8f67be958b3f28", "IPY_MODEL_02a1d8037c634363b0311bf0196db47c" ], "layout": "IPY_MODEL_5c658cb3bff347bfa1fb55f213f82fd8" } }, "c056f40907b944e39f2131ef47755b15": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_7e495ee42bdc4520b2d69153bebe5838", "placeholder": "​", "style": "IPY_MODEL_3371fb507d664eb087cc342c6a3ccb22", "value": "mean_var_norm_emb.ckpt: 100%" } }, "2f36faad96f9425d9e8f67be958b3f28": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_d4d34a424da446dd8e3448d9cd982f11", "max": 3201, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_f16e3cb770dd43abb0c3fc7ba10e7858", "value": 3201 } }, "02a1d8037c634363b0311bf0196db47c": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_7086d0fcc3fe44039f05cc3c2b4a610b", "placeholder": "​", "style": "IPY_MODEL_e75ca534b9e14ab9b17b043360266723", "value": " 3.20k/3.20k [00:00<00:00, 369kB/s]" } }, "5c658cb3bff347bfa1fb55f213f82fd8": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "7e495ee42bdc4520b2d69153bebe5838": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "3371fb507d664eb087cc342c6a3ccb22": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "d4d34a424da446dd8e3448d9cd982f11": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "f16e3cb770dd43abb0c3fc7ba10e7858": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "7086d0fcc3fe44039f05cc3c2b4a610b": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "e75ca534b9e14ab9b17b043360266723": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "cca22d03bd7c4a88a8cd27036da23c43": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_8bf0008bf92c4e63b51d82075a133677", "IPY_MODEL_bc7ffe052ca94b4988f35bd687406e0f", "IPY_MODEL_26a70f330bad4d448f059b401f4b2816" ], "layout": "IPY_MODEL_8e7b32b29dc844cda2637a028dbb0ef1" } }, "8bf0008bf92c4e63b51d82075a133677": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_af87a4ef6c3b4eaf8ee7cf506e7a295f", "placeholder": "​", "style": "IPY_MODEL_eb99c6f60bd94c48b32ac6af6d31464a", "value": "classifier.ckpt: 100%" } }, "bc7ffe052ca94b4988f35bd687406e0f": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_956a72f93c814392905fb07ed76a40b3", "max": 15856877, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_c53bb16394a144bd8021ca8f52d9a8ce", "value": 15856877 } }, "26a70f330bad4d448f059b401f4b2816": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_6ff2e8cbb30e4d1bb5691d985e0a9764", "placeholder": "​", "style": "IPY_MODEL_f5cd21c666064b89949771ef49616910", "value": " 15.9M/15.9M [00:00<00:00, 165MB/s]" } }, "8e7b32b29dc844cda2637a028dbb0ef1": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "af87a4ef6c3b4eaf8ee7cf506e7a295f": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "eb99c6f60bd94c48b32ac6af6d31464a": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "956a72f93c814392905fb07ed76a40b3": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "c53bb16394a144bd8021ca8f52d9a8ce": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "6ff2e8cbb30e4d1bb5691d985e0a9764": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "f5cd21c666064b89949771ef49616910": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "632f56cbf7e8434a8530b1d8cbb31efb": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_507f59cb3c004e199013cc0f9bc77d08", "IPY_MODEL_9b0d060f2ddb4455a3ef77818d56b33b", "IPY_MODEL_25040fe4255a4a759d4207889bcb2eaa" ], "layout": "IPY_MODEL_6c03d580bf50439e8a7ca3580ca5aea3" } }, "507f59cb3c004e199013cc0f9bc77d08": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_f7a4481dcbeb41a7bb7c5f7c879f31c9", "placeholder": "​", "style": "IPY_MODEL_e529d5f8145f496db1bb29872a22b124", "value": "label_encoder.txt: 100%" } }, "9b0d060f2ddb4455a3ef77818d56b33b": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_74d37a4cc3da4596b246fdf457dc4b05", "max": 128619, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_1e885488457649c2a7807dd90d7e2d0b", "value": 128619 } }, "25040fe4255a4a759d4207889bcb2eaa": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_a66dc32b31504316885e8ac74d1085a9", "placeholder": "​", "style": "IPY_MODEL_22bbfdfca73b448593226042f616c30c", "value": " 129k/129k [00:00<00:00, 1.80MB/s]" } }, "6c03d580bf50439e8a7ca3580ca5aea3": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "f7a4481dcbeb41a7bb7c5f7c879f31c9": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "e529d5f8145f496db1bb29872a22b124": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "74d37a4cc3da4596b246fdf457dc4b05": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "1e885488457649c2a7807dd90d7e2d0b": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "a66dc32b31504316885e8ac74d1085a9": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "22bbfdfca73b448593226042f616c30c": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "887bb807621b4a52bafa603b423818d7": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_862eb525376c4e9ebb2132e16b3a8dfc", "IPY_MODEL_dbad817dc3af4e8c82451e5096058c95", "IPY_MODEL_e47ca1f17a2e4fe9a7df688c20979c01" ], "layout": "IPY_MODEL_9a3ff2ca0bd447f5abb5041b11196fdd" } }, "862eb525376c4e9ebb2132e16b3a8dfc": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_24a7b20b24974d87a4a2e526ad88e3e9", "placeholder": "​", "style": "IPY_MODEL_ed0b2233f75d4fc4a4ed87e6f93c038a", "value": "hyperparams.yaml: 100%" } }, "dbad817dc3af4e8c82451e5096058c95": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_c3f0c1d5be76417087c7e4e43783e426", "max": 1919, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_7851faaab81e413e9cebfeabd49735e3", "value": 1919 } }, "e47ca1f17a2e4fe9a7df688c20979c01": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_113d1a2b848f4c8e852ec8857ef2f3a1", "placeholder": "​", "style": "IPY_MODEL_f57c32394adc43c0ac6a978bdfb7d61e", "value": " 1.92k/1.92k [00:00<00:00, 140kB/s]" } }, "9a3ff2ca0bd447f5abb5041b11196fdd": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "24a7b20b24974d87a4a2e526ad88e3e9": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "ed0b2233f75d4fc4a4ed87e6f93c038a": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "c3f0c1d5be76417087c7e4e43783e426": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "7851faaab81e413e9cebfeabd49735e3": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "113d1a2b848f4c8e852ec8857ef2f3a1": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "f57c32394adc43c0ac6a978bdfb7d61e": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "faa9d965b36f4283bf35e640c2649577": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_23d9fac6961243b58fd15b167d514021", "IPY_MODEL_e8306633dec4482888a2c93dab1d69e6", "IPY_MODEL_9a76581a68c14cbe9ef90f19f61cbf79" ], "layout": "IPY_MODEL_22055e255223496fab6c96b23803406b" } }, "23d9fac6961243b58fd15b167d514021": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_0a86749f2a8140cca4f167ccde8d5dc9", "placeholder": "​", "style": "IPY_MODEL_6145a9f19faa40168cf1054e3d5d5861", "value": "embedding_model.ckpt: 100%" } }, "e8306633dec4482888a2c93dab1d69e6": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_8500f64b6b534eb689d6f8a9d536cd0c", "max": 83316686, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_21a6c936feec4a878d26d171ad3897f9", "value": 83316686 } }, "9a76581a68c14cbe9ef90f19f61cbf79": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_a0b9d575dab04492bfb401997257fcc2", "placeholder": "​", "style": "IPY_MODEL_5252430fbff94d51aaf17e50367e42af", "value": " 83.3M/83.3M [00:00<00:00, 211MB/s]" } }, "22055e255223496fab6c96b23803406b": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "0a86749f2a8140cca4f167ccde8d5dc9": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "6145a9f19faa40168cf1054e3d5d5861": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "8500f64b6b534eb689d6f8a9d536cd0c": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "21a6c936feec4a878d26d171ad3897f9": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "a0b9d575dab04492bfb401997257fcc2": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "5252430fbff94d51aaf17e50367e42af": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "c2289505161d4d47916376a84f63d153": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_5210f390c42347499c89da7c2f8f333f", "IPY_MODEL_cc457b0647f544e2a76d5345ef28f3a7", "IPY_MODEL_6cc81cbfc6ab418e885c84ac2028d55d" ], "layout": "IPY_MODEL_51a28ff42db34514bbdb9ceda0bc57ef" } }, "5210f390c42347499c89da7c2f8f333f": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_b1ebfe23106a4cecbfa2496a1883fc16", "placeholder": "​", "style": "IPY_MODEL_08f227fe1888468682630133dba8a389", "value": "mean_var_norm_emb.ckpt: 100%" } }, "cc457b0647f544e2a76d5345ef28f3a7": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_5d03389878fe40179850c0279d3afd9c", "max": 1921, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_71b55971c0e9446a978c2014f2f24d2d", "value": 1921 } }, "6cc81cbfc6ab418e885c84ac2028d55d": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_d20ce2bd6b1040a8b700e0b3249089ba", "placeholder": "​", "style": "IPY_MODEL_b0564fc611df4282ba0a3730e6c5d2c7", "value": " 1.92k/1.92k [00:00<00:00, 204kB/s]" } }, "51a28ff42db34514bbdb9ceda0bc57ef": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "b1ebfe23106a4cecbfa2496a1883fc16": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "08f227fe1888468682630133dba8a389": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "5d03389878fe40179850c0279d3afd9c": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "71b55971c0e9446a978c2014f2f24d2d": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "d20ce2bd6b1040a8b700e0b3249089ba": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "b0564fc611df4282ba0a3730e6c5d2c7": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "5ff5a61c0a954485866a7a92b8186cff": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_5fd6afffa3c64d4fbf81623e9f02de0e", "IPY_MODEL_86756fff0f424fdbbaae947b78c770e2", "IPY_MODEL_9c10c16ecffc4f53969230b4994804fe" ], "layout": "IPY_MODEL_984afd65bbb04202a09060500bd23b0f" } }, "5fd6afffa3c64d4fbf81623e9f02de0e": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_f0dd418cea0f486080356da09a1310bc", "placeholder": "​", "style": "IPY_MODEL_109cb7412ed6490698aca150e1ecf86c", "value": "classifier.ckpt: 100%" } }, "86756fff0f424fdbbaae947b78c770e2": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_1f7f9b00af8c46aea9cc7b943246d0fc", "max": 5534328, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_fb8c1d51942a4fd78357cec0c0530808", "value": 5534328 } }, "9c10c16ecffc4f53969230b4994804fe": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_6808a5f59fb34e37be4d2aee4bbd7eeb", "placeholder": "​", "style": "IPY_MODEL_9165a52e0949480aa936ae42040bd3cc", "value": " 5.53M/5.53M [00:00<00:00, 143MB/s]" } }, "984afd65bbb04202a09060500bd23b0f": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "f0dd418cea0f486080356da09a1310bc": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "109cb7412ed6490698aca150e1ecf86c": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "1f7f9b00af8c46aea9cc7b943246d0fc": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "fb8c1d51942a4fd78357cec0c0530808": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "6808a5f59fb34e37be4d2aee4bbd7eeb": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "9165a52e0949480aa936ae42040bd3cc": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "9b437811fa164e5ca2b8eb9131338f89": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "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_61f6950cb76643bc860e7a43e7e7bb58", "IPY_MODEL_842094e522cc42a58dc9d1785bd9314e", "IPY_MODEL_59bb0e1afd4247d78f254ff09ff354ca" ], "layout": "IPY_MODEL_bd327f7a96ea484bb4913d9f64cc31eb" } }, "61f6950cb76643bc860e7a43e7e7bb58": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_260f1edf6acb478599fdc410072517b9", "placeholder": "​", "style": "IPY_MODEL_033c839455d8408fb85e4272f744fb69", "value": "label_encoder.txt: 100%" } }, "842094e522cc42a58dc9d1785bd9314e": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "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_9178f1efb3f640d5a08280e17c384b9a", "max": 128619, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_dcb14ddca33545139272eea73ca14248", "value": 128619 } }, "59bb0e1afd4247d78f254ff09ff354ca": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "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_481e5a2f44db4757972410ae6f4baddd", "placeholder": "​", "style": "IPY_MODEL_b978f40aa89d4cdfba13d7731dbee766", "value": " 129k/129k [00:00<00:00, 13.4MB/s]" } }, "bd327f7a96ea484bb4913d9f64cc31eb": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "260f1edf6acb478599fdc410072517b9": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "033c839455d8408fb85e4272f744fb69": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } }, "9178f1efb3f640d5a08280e17c384b9a": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "dcb14ddca33545139272eea73ca14248": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "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": "" } }, "481e5a2f44db4757972410ae6f4baddd": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "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 } }, "b978f40aa89d4cdfba13d7731dbee766": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "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": "" } } } } }, "nbformat": 4, "nbformat_minor": 0 }