From f03f03f42681093f72af195a41d20815c8b388ce Mon Sep 17 00:00:00 2001 From: ModelHub XC Date: Sat, 17 Oct 2026 18:54:19 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=9D=E5=A7=8B=E5=8C=96=E9=A1=B9=E7=9B=AE?= =?UTF-8?q?=EF=BC=8C=E7=94=B1ModelHub=20XC=E7=A4=BE=E5=8C=BA=E6=8F=90?= =?UTF-8?q?=E4=BE=9B=E6=A8=A1=E5=9E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Model: infinitejoy/wav2vec2-large-xls-r-300m-welsh Source: Original Platform --- .gitattributes | 27 + .gitignore | 1 + README.md | 88 + added_tokens.json | 1 + all_results.json | 14 + config.json | 107 + eval.py | 137 + eval_results.json | 9 + preprocessor_config.json | 9 + pytorch_model.bin | 3 + run.sh | 34 + run_speech_recognition_ctc.py | 737 +++ special_tokens_map.json | 1 + tokenizer_config.json | 1 + train_results.json | 8 + trainer_state.json | 1177 ++++ training_args.bin | 3 + vocab.json | 1 + welsh_training_script.ipynb | 9832 +++++++++++++++++++++++++++++++++ 19 files changed, 12190 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 README.md create mode 100644 added_tokens.json create mode 100644 all_results.json create mode 100644 config.json create mode 100644 eval.py create mode 100644 eval_results.json create mode 100644 preprocessor_config.json create mode 100644 pytorch_model.bin create mode 100644 run.sh create mode 100644 run_speech_recognition_ctc.py create mode 100644 special_tokens_map.json create mode 100644 tokenizer_config.json create mode 100644 train_results.json create mode 100644 trainer_state.json create mode 100644 training_args.bin create mode 100644 vocab.json create mode 100644 welsh_training_script.ipynb diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..6d34772 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,27 @@ +*.7z filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.bin.* filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.parquet filter=lfs diff=lfs merge=lfs -text +*.pb filter=lfs diff=lfs merge=lfs -text +*.pt filter=lfs diff=lfs merge=lfs -text +*.pth filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zstandard filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0348ea9 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +checkpoint-*/ \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..ccb237f --- /dev/null +++ b/README.md @@ -0,0 +1,88 @@ +--- +language: +- cy +license: apache-2.0 +tags: +- automatic-speech-recognition +- cy +- generated_from_trainer +- hf-asr-leaderboard +- model_for_talk +- mozilla-foundation/common_voice_7_0 +- robust-speech-event +datasets: +- mozilla-foundation/common_voice_7_0 +model-index: +- name: XLS-R-300M - Welsh + results: + - task: + name: Automatic Speech Recognition + type: automatic-speech-recognition + dataset: + name: Common Voice 7 + type: mozilla-foundation/common_voice_7_0 + args: cy + metrics: + - name: Test WER + type: wer + value: 31.003 + - name: Test CER + type: cer + value: 7.775 +--- + + + +# wav2vec2-large-xls-r-300m-welsh + +This model is a fine-tuned version of [facebook/wav2vec2-xls-r-300m](https://huggingface.co/facebook/wav2vec2-xls-r-300m) on the MOZILLA-FOUNDATION/COMMON_VOICE_7_0 - CY dataset. +It achieves the following results on the evaluation set: +- Loss: 0.2650 +- Wer: 0.2702 + +## Model description + +More information needed + +## Intended uses & limitations + +More information needed + +## Training and evaluation data + +More information needed + +## Training procedure + +### Training hyperparameters + +The following hyperparameters were used during training: +- learning_rate: 7e-05 +- train_batch_size: 32 +- eval_batch_size: 16 +- seed: 42 +- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 +- lr_scheduler_type: linear +- lr_scheduler_warmup_steps: 3000 +- num_epochs: 50.0 +- mixed_precision_training: Native AMP + +### Training results + +| Training Loss | Epoch | Step | Validation Loss | Wer | +|:-------------:|:-----:|:-----:|:---------------:|:------:| +| 1.3454 | 8.2 | 3000 | 0.4926 | 0.5703 | +| 1.1202 | 16.39 | 6000 | 0.3529 | 0.3944 | +| 1.0058 | 24.59 | 9000 | 0.3143 | 0.3341 | +| 0.9287 | 32.79 | 12000 | 0.2896 | 0.2980 | +| 0.8849 | 40.98 | 15000 | 0.2727 | 0.2798 | +| 0.8665 | 49.18 | 18000 | 0.2662 | 0.2696 | + + +### Framework versions + +- Transformers 4.16.0.dev0 +- Pytorch 1.10.1+cu102 +- Datasets 1.18.3 +- Tokenizers 0.11.0 diff --git a/added_tokens.json b/added_tokens.json new file mode 100644 index 0000000..6273cd4 --- /dev/null +++ b/added_tokens.json @@ -0,0 +1 @@ +{"": 47, "": 48} \ No newline at end of file diff --git a/all_results.json b/all_results.json new file mode 100644 index 0000000..01e7ef0 --- /dev/null +++ b/all_results.json @@ -0,0 +1,14 @@ +{ + "epoch": 50.0, + "eval_loss": 0.2650411128997803, + "eval_runtime": 208.9946, + "eval_samples": 4850, + "eval_samples_per_second": 23.206, + "eval_steps_per_second": 1.455, + "eval_wer": 0.27019870599341483, + "train_loss": 1.3658743798928183, + "train_runtime": 33116.2978, + "train_samples": 11695, + "train_samples_per_second": 17.657, + "train_steps_per_second": 0.553 +} \ No newline at end of file diff --git a/config.json b/config.json new file mode 100644 index 0000000..9ef606d --- /dev/null +++ b/config.json @@ -0,0 +1,107 @@ +{ + "_name_or_path": "facebook/wav2vec2-xls-r-300m", + "activation_dropout": 0.1, + "adapter_kernel_size": 3, + "adapter_stride": 2, + "add_adapter": false, + "apply_spec_augment": true, + "architectures": [ + "Wav2Vec2ForCTC" + ], + "attention_dropout": 0.0, + "bos_token_id": 1, + "classifier_proj_size": 256, + "codevector_dim": 768, + "contrastive_logits_temperature": 0.1, + "conv_bias": true, + "conv_dim": [ + 512, + 512, + 512, + 512, + 512, + 512, + 512 + ], + "conv_kernel": [ + 10, + 3, + 3, + 3, + 3, + 2, + 2 + ], + "conv_stride": [ + 5, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "ctc_loss_reduction": "mean", + "ctc_zero_infinity": false, + "diversity_loss_weight": 0.1, + "do_stable_layer_norm": true, + "eos_token_id": 2, + "feat_extract_activation": "gelu", + "feat_extract_dropout": 0.0, + "feat_extract_norm": "layer", + "feat_proj_dropout": 0.0, + "feat_quantizer_dropout": 0.0, + "final_dropout": 0.0, + "hidden_act": "gelu", + "hidden_dropout": 0.0, + "hidden_size": 1024, + "initializer_range": 0.02, + "intermediate_size": 4096, + "layer_norm_eps": 1e-05, + "layerdrop": 0.0, + "mask_feature_length": 64, + "mask_feature_min_masks": 0, + "mask_feature_prob": 0.25, + "mask_time_length": 10, + "mask_time_min_masks": 2, + "mask_time_prob": 0.75, + "model_type": "wav2vec2", + "num_adapter_layers": 3, + "num_attention_heads": 16, + "num_codevector_groups": 2, + "num_codevectors_per_group": 320, + "num_conv_pos_embedding_groups": 16, + "num_conv_pos_embeddings": 128, + "num_feat_extract_layers": 7, + "num_hidden_layers": 24, + "num_negatives": 100, + "output_hidden_size": 1024, + "pad_token_id": 46, + "proj_codevector_dim": 768, + "tdnn_dilation": [ + 1, + 2, + 3, + 1, + 1 + ], + "tdnn_dim": [ + 512, + 512, + 512, + 512, + 1500 + ], + "tdnn_kernel": [ + 5, + 3, + 3, + 1, + 1 + ], + "torch_dtype": "float32", + "transformers_version": "4.16.0.dev0", + "use_weighted_layer_sum": false, + "vocab_size": 49, + "xvector_output_dim": 512 +} diff --git a/eval.py b/eval.py new file mode 100644 index 0000000..53cd244 --- /dev/null +++ b/eval.py @@ -0,0 +1,137 @@ +#!/usr/bin/env python3 +import argparse +import re +from typing import Dict + +import torch +from datasets import Audio, Dataset, load_dataset, load_metric + +from transformers import AutoFeatureExtractor, pipeline + + +def log_results(result: Dataset, args: Dict[str, str]): + """DO NOT CHANGE. This function computes and logs the result metrics.""" + + log_outputs = args.log_outputs + dataset_id = "_".join(args.dataset.split("/") + [args.config, args.split]) + + # load metric + wer = load_metric("wer") + cer = load_metric("cer") + + # compute metrics + wer_result = wer.compute(references=result["target"], predictions=result["prediction"]) + cer_result = cer.compute(references=result["target"], predictions=result["prediction"]) + + # print & log results + result_str = f"WER: {wer_result}\n" f"CER: {cer_result}" + print(result_str) + + with open(f"{dataset_id}_eval_results.txt", "w") as f: + f.write(result_str) + + # log all results in text file. Possibly interesting for analysis + if log_outputs is not None: + pred_file = f"log_{dataset_id}_predictions.txt" + target_file = f"log_{dataset_id}_targets.txt" + + with open(pred_file, "w") as p, open(target_file, "w") as t: + + # mapping function to write output + def write_to_file(batch, i): + p.write(f"{i}" + "\n") + p.write(batch["prediction"] + "\n") + t.write(f"{i}" + "\n") + t.write(batch["target"] + "\n") + + result.map(write_to_file, with_indices=True) + + +def normalize_text(text: str) -> str: + """DO ADAPT FOR YOUR USE CASE. this function normalizes the target text.""" + + chars_to_ignore_regex = '[,?.!\-\;\:"“%‘”�—’…–]' # noqa: W605 IMPORTANT: this should correspond to the chars that were ignored during training + + text = re.sub(chars_to_ignore_regex, "", text.lower()) + + # In addition, we can normalize the target text, e.g. removing new lines characters etc... + # note that order is important here! + token_sequences_to_ignore = ["\n\n", "\n", " ", " "] + + for t in token_sequences_to_ignore: + text = " ".join(text.split(t)) + + return text + + +def main(args): + # load dataset + dataset = load_dataset(args.dataset, args.config, split=args.split, use_auth_token=True) + + # for testing: only process the first two examples as a test + # dataset = dataset.select(range(10)) + + # load processor + feature_extractor = AutoFeatureExtractor.from_pretrained(args.model_id) + sampling_rate = feature_extractor.sampling_rate + + # resample audio + dataset = dataset.cast_column("audio", Audio(sampling_rate=sampling_rate)) + + # load eval pipeline + if args.device is None: + args.device = 0 if torch.cuda.is_available() else -1 + asr = pipeline("automatic-speech-recognition", model=args.model_id, device=args.device) + + # map function to decode audio + def map_to_pred(batch): + prediction = asr( + batch["audio"]["array"], chunk_length_s=args.chunk_length_s, stride_length_s=args.stride_length_s + ) + + batch["prediction"] = prediction["text"] + batch["target"] = normalize_text(batch["sentence"]) + return batch + + # run inference on all examples + result = dataset.map(map_to_pred, remove_columns=dataset.column_names) + + # compute and log_results + # do not change function below + log_results(result, args) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument( + "--model_id", type=str, required=True, help="Model identifier. Should be loadable with 🤗 Transformers" + ) + parser.add_argument( + "--dataset", + type=str, + required=True, + help="Dataset name to evaluate the `model_id`. Should be loadable with 🤗 Datasets", + ) + parser.add_argument( + "--config", type=str, required=True, help="Config of the dataset. *E.g.* `'en'` for Common Voice" + ) + parser.add_argument("--split", type=str, required=True, help="Split of the dataset. *E.g.* `'test'`") + parser.add_argument( + "--chunk_length_s", type=float, default=None, help="Chunk length in seconds. Defaults to 5 seconds." + ) + parser.add_argument( + "--stride_length_s", type=float, default=None, help="Stride of the audio chunks. Defaults to 1 second." + ) + parser.add_argument( + "--log_outputs", action="store_true", help="If defined, write outputs to log file for analysis." + ) + parser.add_argument( + "--device", + type=int, + default=None, + help="The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.", + ) + args = parser.parse_args() + + main(args) diff --git a/eval_results.json b/eval_results.json new file mode 100644 index 0000000..7b6e295 --- /dev/null +++ b/eval_results.json @@ -0,0 +1,9 @@ +{ + "epoch": 50.0, + "eval_loss": 0.2650411128997803, + "eval_runtime": 208.9946, + "eval_samples": 4850, + "eval_samples_per_second": 23.206, + "eval_steps_per_second": 1.455, + "eval_wer": 0.27019870599341483 +} \ No newline at end of file diff --git a/preprocessor_config.json b/preprocessor_config.json new file mode 100644 index 0000000..36ebe8b --- /dev/null +++ b/preprocessor_config.json @@ -0,0 +1,9 @@ +{ + "do_normalize": true, + "feature_extractor_type": "Wav2Vec2FeatureExtractor", + "feature_size": 1, + "padding_side": "right", + "padding_value": 0, + "return_attention_mask": true, + "sampling_rate": 16000 +} diff --git a/pytorch_model.bin b/pytorch_model.bin new file mode 100644 index 0000000..f3f67a6 --- /dev/null +++ b/pytorch_model.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:68c5c29efd8691197c1a6fedd29288acdbcd390bdcf91bc2bc706194e6965e76 +size 1262124593 diff --git a/run.sh b/run.sh new file mode 100644 index 0000000..de5f6ac --- /dev/null +++ b/run.sh @@ -0,0 +1,34 @@ +python run_speech_recognition_ctc.py \ + --dataset_name="mozilla-foundation/common_voice_7_0" \ + --model_name_or_path="facebook/wav2vec2-xls-r-300m" \ + --dataset_config_name="cy" \ + --output_dir="./wav2vec2-large-xls-r-300m-welsh" \ + --overwrite_output_dir \ + --num_train_epochs="50" \ + --per_device_train_batch_size="32" \ + --per_device_eval_batch_size="16" \ + --gradient_accumulation_steps="1" \ + --learning_rate="7e-5" \ + --warmup_steps="3000" \ + --length_column_name="input_length" \ + --evaluation_strategy="steps" \ + --text_column_name="sentence" \ + --chars_to_ignore , ? . ! \- \; \: \" “ % ‘ ” � — ’ … – \' \ + --save_steps="3000" \ + --eval_steps="3000" \ + --logging_steps="100" \ + --layerdrop="0.0" \ + --activation_dropout="0.1" \ + --save_total_limit="2" \ + --freeze_feature_encoder \ + --feat_proj_dropout="0.0" \ + --mask_time_prob="0.75" \ + --mask_time_length="10" \ + --mask_feature_prob="0.25" \ + --mask_feature_length="64" \ + --gradient_checkpointing \ + --use_auth_token \ + --fp16 \ + --group_by_length \ + --do_train --do_eval \ + --push_to_hub diff --git a/run_speech_recognition_ctc.py b/run_speech_recognition_ctc.py new file mode 100644 index 0000000..0c460c3 --- /dev/null +++ b/run_speech_recognition_ctc.py @@ -0,0 +1,737 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2021 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and + +""" Fine-tuning a 🤗 Transformers CTC model for automatic speech recognition""" + +import functools +import json +import logging +import os +import re +import sys +import warnings +from dataclasses import dataclass, field +from typing import Dict, List, Optional, Union + +import datasets +import numpy as np +import torch +from datasets import DatasetDict, load_dataset, load_metric + +import transformers +from transformers import ( + AutoConfig, + AutoFeatureExtractor, + AutoModelForCTC, + AutoProcessor, + AutoTokenizer, + HfArgumentParser, + Trainer, + TrainingArguments, + Wav2Vec2Processor, + set_seed, +) +from transformers.trainer_utils import get_last_checkpoint, is_main_process +from transformers.utils import check_min_version +from transformers.utils.versions import require_version + + +# Will error if the minimal version of Transformers is not installed. Remove at your own risks. +check_min_version("4.16.0.dev0") + +require_version("datasets>=1.13.3", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt") + + +logger = logging.getLogger(__name__) + + +def list_field(default=None, metadata=None): + return field(default_factory=lambda: default, metadata=metadata) + + +@dataclass +class ModelArguments: + """ + Arguments pertaining to which model/config/tokenizer we are going to fine-tune from. + """ + + model_name_or_path: str = field( + metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} + ) + tokenizer_name_or_path: Optional[str] = field( + default=None, + metadata={"help": "Path to pretrained tokenizer or tokenizer identifier from huggingface.co/models"}, + ) + cache_dir: Optional[str] = field( + default=None, + metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}, + ) + freeze_feature_encoder: bool = field( + default=True, metadata={"help": "Whether to freeze the feature encoder layers of the model."} + ) + attention_dropout: float = field( + default=0.0, metadata={"help": "The dropout ratio for the attention probabilities."} + ) + activation_dropout: float = field( + default=0.0, metadata={"help": "The dropout ratio for activations inside the fully connected layer."} + ) + feat_proj_dropout: float = field(default=0.0, metadata={"help": "The dropout ratio for the projected features."}) + hidden_dropout: float = field( + default=0.0, + metadata={ + "help": "The dropout probability for all fully connected layers in the embeddings, encoder, and pooler." + }, + ) + final_dropout: float = field( + default=0.0, + metadata={"help": "The dropout probability for the final projection layer."}, + ) + mask_time_prob: float = field( + default=0.05, + metadata={ + "help": "Probability of each feature vector along the time axis to be chosen as the start of the vector" + "span to be masked. Approximately ``mask_time_prob * sequence_length // mask_time_length`` feature" + "vectors will be masked along the time axis." + }, + ) + mask_time_length: int = field( + default=10, + metadata={"help": "Length of vector span to mask along the time axis."}, + ) + mask_feature_prob: float = field( + default=0.0, + metadata={ + "help": "Probability of each feature vector along the feature axis to be chosen as the start of the vector" + "span to be masked. Approximately ``mask_feature_prob * sequence_length // mask_feature_length`` feature bins will be masked along the time axis." + }, + ) + mask_feature_length: int = field( + default=10, + metadata={"help": "Length of vector span to mask along the feature axis."}, + ) + layerdrop: float = field(default=0.0, metadata={"help": "The LayerDrop probability."}) + ctc_loss_reduction: Optional[str] = field( + default="mean", metadata={"help": "The way the ctc loss should be reduced. Should be one of 'mean' or 'sum'."} + ) + + +@dataclass +class DataTrainingArguments: + """ + Arguments pertaining to what data we are going to input our model for training and eval. + + Using `HfArgumentParser` we can turn this class + into argparse arguments to be able to specify them on + the command line. + """ + + dataset_name: str = field( + metadata={"help": "The configuration name of the dataset to use (via the datasets library)."} + ) + dataset_config_name: str = field( + default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."} + ) + train_split_name: str = field( + default="train+validation", + metadata={ + "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'" + }, + ) + eval_split_name: str = field( + default="test", + metadata={ + "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'" + }, + ) + audio_column_name: str = field( + default="audio", + metadata={"help": "The name of the dataset column containing the audio data. Defaults to 'audio'"}, + ) + text_column_name: str = field( + default="text", + metadata={"help": "The name of the dataset column containing the text data. Defaults to 'text'"}, + ) + overwrite_cache: bool = field( + default=False, metadata={"help": "Overwrite the cached preprocessed datasets or not."} + ) + preprocessing_num_workers: Optional[int] = field( + default=None, + metadata={"help": "The number of processes to use for the preprocessing."}, + ) + max_train_samples: Optional[int] = field( + default=None, + metadata={ + "help": "For debugging purposes or quicker training, truncate the number of training examples to this " + "value if set." + }, + ) + max_eval_samples: Optional[int] = field( + default=None, + metadata={ + "help": "For debugging purposes or quicker training, truncate the number of validation examples to this " + "value if set." + }, + ) + chars_to_ignore: Optional[List[str]] = list_field( + default=None, + metadata={"help": "A list of characters to remove from the transcripts."}, + ) + eval_metrics: List[str] = list_field( + default=["wer"], + metadata={"help": "A list of metrics the model should be evaluated on. E.g. `'wer cer'`"}, + ) + max_duration_in_seconds: float = field( + default=20.0, + metadata={ + "help": "Filter audio files that are longer than `max_duration_in_seconds` seconds to 'max_duration_in_seconds`" + }, + ) + min_duration_in_seconds: float = field( + default=0.0, metadata={"help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"} + ) + preprocessing_only: bool = field( + default=False, + metadata={ + "help": "Whether to only do data preprocessing and skip training. " + "This is especially useful when data preprocessing errors out in distributed training due to timeout. " + "In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` " + "so that the cached datasets can consequently be loaded in distributed training" + }, + ) + use_auth_token: bool = field( + default=False, + metadata={ + "help": "If :obj:`True`, will use the token generated when running" + ":obj:`transformers-cli login` as HTTP bearer authorization for remote files." + }, + ) + unk_token: str = field( + default="[UNK]", + metadata={"help": "The unk token for the tokenizer"}, + ) + pad_token: str = field( + default="[PAD]", + metadata={"help": "The padding token for the tokenizer"}, + ) + word_delimiter_token: str = field( + default="|", + metadata={"help": "The word delimiter token for the tokenizer"}, + ) + phoneme_language: Optional[str] = field( + default=None, + metadata={ + "help": "The target language that should be used be" + " passed to the tokenizer for tokenization. Note that" + " this is only relevant if the model classifies the" + " input audio to a sequence of phoneme sequences." + }, + ) + + +@dataclass +class DataCollatorCTCWithPadding: + """ + Data collator that will dynamically pad the inputs received. + Args: + processor (:class:`~transformers.AutoProcessor`) + The processor used for proccessing the data. + padding (:obj:`bool`, :obj:`str` or :class:`~transformers.tokenization_utils_base.PaddingStrategy`, `optional`, defaults to :obj:`True`): + Select a strategy to pad the returned sequences (according to the model's padding side and padding index) + among: + * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single + sequence if provided). + * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the + maximum acceptable input length for the model if that argument is not provided. + * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of + different lengths). + max_length (:obj:`int`, `optional`): + Maximum length of the ``input_values`` of the returned list and optionally padding length (see above). + max_length_labels (:obj:`int`, `optional`): + Maximum length of the ``labels`` returned list and optionally padding length (see above). + pad_to_multiple_of (:obj:`int`, `optional`): + If set will pad the sequence to a multiple of the provided value. + This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >= + 7.5 (Volta). + """ + + processor: AutoProcessor + padding: Union[bool, str] = "longest" + pad_to_multiple_of: Optional[int] = None + pad_to_multiple_of_labels: Optional[int] = None + + def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]: + # split inputs and labels since they have to be of different lenghts and need + # different padding methods + input_features = [{"input_values": feature["input_values"]} for feature in features] + label_features = [{"input_ids": feature["labels"]} for feature in features] + + batch = self.processor.pad( + input_features, + padding=self.padding, + pad_to_multiple_of=self.pad_to_multiple_of, + return_tensors="pt", + ) + + with self.processor.as_target_processor(): + labels_batch = self.processor.pad( + label_features, + padding=self.padding, + pad_to_multiple_of=self.pad_to_multiple_of_labels, + return_tensors="pt", + ) + + # replace padding with -100 to ignore loss correctly + labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100) + + batch["labels"] = labels + + return batch + + +def create_vocabulary_from_data( + datasets: DatasetDict, + word_delimiter_token: Optional[str] = None, + unk_token: Optional[str] = None, + pad_token: Optional[str] = None, +): + # Given training and test labels create vocabulary + def extract_all_chars(batch): + all_text = " ".join(batch["target_text"]) + vocab = list(set(all_text)) + return {"vocab": [vocab], "all_text": [all_text]} + + vocabs = datasets.map( + extract_all_chars, + batched=True, + batch_size=-1, + keep_in_memory=True, + remove_columns=datasets["train"].column_names, + ) + + # take union of all unique characters in each dataset + vocab_set = functools.reduce( + lambda vocab_1, vocab_2: set(vocab_1["vocab"][0]) | set(vocab_2["vocab"][0]), vocabs.values() + ) + + vocab_dict = {v: k for k, v in enumerate(sorted(list(vocab_set)))} + + # replace white space with delimiter token + if word_delimiter_token is not None: + vocab_dict[word_delimiter_token] = vocab_dict[" "] + del vocab_dict[" "] + + # add unk and pad token + if unk_token is not None: + vocab_dict[unk_token] = len(vocab_dict) + + if pad_token is not None: + vocab_dict[pad_token] = len(vocab_dict) + + return vocab_dict + + +def main(): + # See all possible arguments in src/transformers/training_args.py + # or by passing the --help flag to this script. + # We now keep distinct sets of args, for a cleaner separation of concerns. + + parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)) + if len(sys.argv) == 2 and sys.argv[1].endswith(".json"): + # If we pass only one argument to the script and it's the path to a json file, + # let's parse it to get our arguments. + model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1])) + else: + model_args, data_args, training_args = parser.parse_args_into_dataclasses() + + # Detecting last checkpoint. + last_checkpoint = None + if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir: + last_checkpoint = get_last_checkpoint(training_args.output_dir) + if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0: + raise ValueError( + f"Output directory ({training_args.output_dir}) already exists and is not empty. " + "Use --overwrite_output_dir to overcome." + ) + elif last_checkpoint is not None: + logger.info( + f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change " + "the `--output_dir` or add `--overwrite_output_dir` to train from scratch." + ) + + # Setup logging + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + handlers=[logging.StreamHandler(sys.stdout)], + ) + logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN) + + # Log on each process the small summary: + logger.warning( + f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}" + f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}" + ) + # Set the verbosity to info of the Transformers logger (on main process only): + if is_main_process(training_args.local_rank): + transformers.utils.logging.set_verbosity_info() + logger.info("Training/evaluation parameters %s", training_args) + + # Set seed before initializing model. + set_seed(training_args.seed) + + # 1. First, let's load the dataset + raw_datasets = DatasetDict() + + if training_args.do_train: + raw_datasets["train"] = load_dataset( + data_args.dataset_name, + data_args.dataset_config_name, + split=data_args.train_split_name, + use_auth_token=data_args.use_auth_token, + ) + + if data_args.audio_column_name not in raw_datasets["train"].column_names: + raise ValueError( + f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. " + "Make sure to set `--audio_column_name` to the correct audio column - one of " + f"{', '.join(raw_datasets['train'].column_names)}." + ) + + if data_args.text_column_name not in raw_datasets["train"].column_names: + raise ValueError( + f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. " + "Make sure to set `--text_column_name` to the correct text column - one of " + f"{', '.join(raw_datasets['train'].column_names)}." + ) + + if data_args.max_train_samples is not None: + raw_datasets["train"] = raw_datasets["train"].select(range(data_args.max_train_samples)) + + if training_args.do_eval: + raw_datasets["eval"] = load_dataset( + data_args.dataset_name, + data_args.dataset_config_name, + split=data_args.eval_split_name, + use_auth_token=data_args.use_auth_token, + ) + + if data_args.max_eval_samples is not None: + raw_datasets["eval"] = raw_datasets["eval"].select(range(data_args.max_eval_samples)) + + # 2. We remove some special characters from the datasets + # that make training complicated and do not help in transcribing the speech + # E.g. characters, such as `,` and `.` do not really have an acoustic characteristic + # that could be easily picked up by the model + chars_to_ignore_regex = ( + f'[{"".join(data_args.chars_to_ignore)}]' if data_args.chars_to_ignore is not None else None + ) + text_column_name = data_args.text_column_name + + def remove_special_characters(batch): + if chars_to_ignore_regex is not None: + batch["target_text"] = re.sub(chars_to_ignore_regex, "", batch[text_column_name]).lower() + " " + else: + batch["target_text"] = batch[text_column_name].lower() + " " + return batch + + with training_args.main_process_first(desc="dataset map special characters removal"): + raw_datasets = raw_datasets.map( + remove_special_characters, + remove_columns=[text_column_name], + desc="remove special characters from datasets", + ) + + # save special tokens for tokenizer + word_delimiter_token = data_args.word_delimiter_token + unk_token = data_args.unk_token + pad_token = data_args.pad_token + + # 3. Next, let's load the config as we might need it to create + # the tokenizer + # load config + config = AutoConfig.from_pretrained( + model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_auth_token=data_args.use_auth_token + ) + + # 4. Next, if no tokenizer file is defined, + # we create the vocabulary of the model by extracting all unique characters from + # the training and evaluation datasets + # We need to make sure that only first rank saves vocabulary + # make sure all processes wait until vocab is created + tokenizer_name_or_path = model_args.tokenizer_name_or_path + tokenizer_kwargs = {} + if tokenizer_name_or_path is None: + # save vocab in training output dir + tokenizer_name_or_path = training_args.output_dir + + vocab_file = os.path.join(tokenizer_name_or_path, "vocab.json") + + with training_args.main_process_first(): + if training_args.overwrite_output_dir and os.path.isfile(vocab_file): + os.remove(vocab_file) + + with training_args.main_process_first(desc="dataset map vocabulary creation"): + if not os.path.isfile(vocab_file): + os.makedirs(tokenizer_name_or_path, exist_ok=True) + vocab_dict = create_vocabulary_from_data( + raw_datasets, + word_delimiter_token=word_delimiter_token, + unk_token=unk_token, + pad_token=pad_token, + ) + + # save vocab dict to be loaded into tokenizer + with open(vocab_file, "w") as file: + json.dump(vocab_dict, file) + + # if tokenizer has just been created + # it is defined by `tokenizer_class` if present in config else by `model_type` + tokenizer_kwargs = { + "config": config if config.tokenizer_class is not None else None, + "tokenizer_type": config.model_type if config.tokenizer_class is None else None, + "unk_token": unk_token, + "pad_token": pad_token, + "word_delimiter_token": word_delimiter_token, + } + + # 5. Now we can instantiate the feature extractor, tokenizer and model + # Note for distributed training, the .from_pretrained methods guarantee that only + # one local process can concurrently download model & vocab. + + # load feature_extractor and tokenizer + tokenizer = AutoTokenizer.from_pretrained( + tokenizer_name_or_path, + use_auth_token=data_args.use_auth_token, + **tokenizer_kwargs, + ) + feature_extractor = AutoFeatureExtractor.from_pretrained( + model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_auth_token=data_args.use_auth_token + ) + + # adapt config + config.update( + { + "feat_proj_dropout": model_args.feat_proj_dropout, + "attention_dropout": model_args.attention_dropout, + "hidden_dropout": model_args.hidden_dropout, + "final_dropout": model_args.final_dropout, + "mask_time_prob": model_args.mask_time_prob, + "mask_time_length": model_args.mask_time_length, + "mask_feature_prob": model_args.mask_feature_prob, + "mask_feature_length": model_args.mask_feature_length, + "gradient_checkpointing": training_args.gradient_checkpointing, + "layerdrop": model_args.layerdrop, + "ctc_loss_reduction": model_args.ctc_loss_reduction, + "pad_token_id": tokenizer.pad_token_id, + "vocab_size": len(tokenizer), + "activation_dropout": model_args.activation_dropout, + } + ) + + # create model + model = AutoModelForCTC.from_pretrained( + model_args.model_name_or_path, + cache_dir=model_args.cache_dir, + config=config, + use_auth_token=data_args.use_auth_token, + ) + + # freeze encoder + if model_args.freeze_feature_encoder: + model.freeze_feature_encoder() + + # 6. Now we preprocess the datasets including loading the audio, resampling and normalization + # Thankfully, `datasets` takes care of automatically loading and resampling the audio, + # so that we just need to set the correct target sampling rate and normalize the input + # via the `feature_extractor` + + # make sure that dataset decodes audio with correct sampling rate + dataset_sampling_rate = next(iter(raw_datasets.values())).features[data_args.audio_column_name].sampling_rate + if dataset_sampling_rate != feature_extractor.sampling_rate: + raw_datasets = raw_datasets.cast_column( + data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate) + ) + + # derive max & min input length for sample rate & max duration + max_input_length = data_args.max_duration_in_seconds * feature_extractor.sampling_rate + min_input_length = data_args.min_duration_in_seconds * feature_extractor.sampling_rate + audio_column_name = data_args.audio_column_name + num_workers = data_args.preprocessing_num_workers + + # `phoneme_language` is only relevant if the model is fine-tuned on phoneme classification + phoneme_language = data_args.phoneme_language + + # Preprocessing the datasets. + # We need to read the audio files as arrays and tokenize the targets. + def prepare_dataset(batch): + # load audio + sample = batch[audio_column_name] + + inputs = feature_extractor(sample["array"], sampling_rate=sample["sampling_rate"]) + batch["input_values"] = inputs.input_values[0] + batch["input_length"] = len(batch["input_values"]) + + # encode targets + additional_kwargs = {} + if phoneme_language is not None: + additional_kwargs["phonemizer_lang"] = phoneme_language + + batch["labels"] = tokenizer(batch["target_text"], **additional_kwargs).input_ids + return batch + + with training_args.main_process_first(desc="dataset map preprocessing"): + vectorized_datasets = raw_datasets.map( + prepare_dataset, + remove_columns=next(iter(raw_datasets.values())).column_names, + num_proc=num_workers, + desc="preprocess datasets", + ) + + def is_audio_in_length_range(length): + return length > min_input_length and length < max_input_length + + # filter data that is shorter than min_input_length + vectorized_datasets = vectorized_datasets.filter( + is_audio_in_length_range, + num_proc=num_workers, + input_columns=["input_length"], + ) + + # 7. Next, we can prepare the training. + # Let's use word error rate (WER) as our evaluation metric, + # instantiate a data collator and the trainer + + # Define evaluation metrics during training, *i.e.* word error rate, character error rate + eval_metrics = {metric: load_metric(metric) for metric in data_args.eval_metrics} + + # for large datasets it is advised to run the preprocessing on a + # single machine first with ``args.preprocessing_only`` since there will mostly likely + # be a timeout when running the script in distributed mode. + # In a second step ``args.preprocessing_only`` can then be set to `False` to load the + # cached dataset + if data_args.preprocessing_only: + logger.info(f"Data preprocessing finished. Files cached at {vectorized_datasets.cache_files}") + return + + def compute_metrics(pred): + pred_logits = pred.predictions + pred_ids = np.argmax(pred_logits, axis=-1) + + pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id + + pred_str = tokenizer.batch_decode(pred_ids) + # we do not want to group tokens when computing the metrics + label_str = tokenizer.batch_decode(pred.label_ids, group_tokens=False) + + metrics = {k: v.compute(predictions=pred_str, references=label_str) for k, v in eval_metrics.items()} + + return metrics + + # Now save everything to be able to create a single processor later + if is_main_process(training_args.local_rank): + # save feature extractor, tokenizer and config + feature_extractor.save_pretrained(training_args.output_dir) + tokenizer.save_pretrained(training_args.output_dir) + config.save_pretrained(training_args.output_dir) + + try: + processor = AutoProcessor.from_pretrained(training_args.output_dir) + except (OSError, KeyError): + warnings.warn( + "Loading a processor from a feature extractor config that does not" + " include a `processor_class` attribute is deprecated and will be removed in v5. Please add the following " + " attribute to your `preprocessor_config.json` file to suppress this warning: " + " `'processor_class': 'Wav2Vec2Processor'`", + FutureWarning, + ) + processor = Wav2Vec2Processor.from_pretrained(training_args.output_dir) + + # Instantiate custom data collator + data_collator = DataCollatorCTCWithPadding(processor=processor) + + # Initialize Trainer + trainer = Trainer( + model=model, + data_collator=data_collator, + args=training_args, + compute_metrics=compute_metrics, + train_dataset=vectorized_datasets["train"] if training_args.do_train else None, + eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None, + tokenizer=feature_extractor, + ) + + # 8. Finally, we can start training + + # Training + if training_args.do_train: + + # use last checkpoint if exist + if last_checkpoint is not None: + checkpoint = last_checkpoint + elif os.path.isdir(model_args.model_name_or_path): + checkpoint = model_args.model_name_or_path + else: + checkpoint = None + + train_result = trainer.train(resume_from_checkpoint=checkpoint) + trainer.save_model() + + metrics = train_result.metrics + max_train_samples = ( + data_args.max_train_samples + if data_args.max_train_samples is not None + else len(vectorized_datasets["train"]) + ) + metrics["train_samples"] = min(max_train_samples, len(vectorized_datasets["train"])) + + trainer.log_metrics("train", metrics) + trainer.save_metrics("train", metrics) + trainer.save_state() + + # Evaluation + results = {} + if training_args.do_eval: + logger.info("*** Evaluate ***") + metrics = trainer.evaluate() + max_eval_samples = ( + data_args.max_eval_samples if data_args.max_eval_samples is not None else len(vectorized_datasets["eval"]) + ) + metrics["eval_samples"] = min(max_eval_samples, len(vectorized_datasets["eval"])) + + trainer.log_metrics("eval", metrics) + trainer.save_metrics("eval", metrics) + + # Write model card and (optionally) push to hub + config_name = data_args.dataset_config_name if data_args.dataset_config_name is not None else "na" + kwargs = { + "finetuned_from": model_args.model_name_or_path, + "tasks": "speech-recognition", + "tags": ["automatic-speech-recognition", data_args.dataset_name], + "dataset_args": f"Config: {config_name}, Training split: {data_args.train_split_name}, Eval split: {data_args.eval_split_name}", + "dataset": f"{data_args.dataset_name.upper()} - {config_name.upper()}", + } + if "common_voice" in data_args.dataset_name: + kwargs["language"] = config_name + + if training_args.push_to_hub: + trainer.push_to_hub(**kwargs) + else: + trainer.create_model_card(**kwargs) + + return results + + +if __name__ == "__main__": + main() diff --git a/special_tokens_map.json b/special_tokens_map.json new file mode 100644 index 0000000..9f67b88 --- /dev/null +++ b/special_tokens_map.json @@ -0,0 +1 @@ +{"bos_token": "", "eos_token": "", "unk_token": "[UNK]", "pad_token": "[PAD]", "additional_special_tokens": [{"content": "", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}, {"content": "", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}, {"content": "", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}, {"content": "", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}]} \ No newline at end of file diff --git a/tokenizer_config.json b/tokenizer_config.json new file mode 100644 index 0000000..eb18ebd --- /dev/null +++ b/tokenizer_config.json @@ -0,0 +1 @@ +{"unk_token": "[UNK]", "bos_token": "", "eos_token": "", "pad_token": "[PAD]", "do_lower_case": false, "word_delimiter_token": "|", "special_tokens_map_file": null, "tokenizer_file": null, "name_or_path": "./wav2vec2-large-xls-r-300m-welsh", "tokenizer_class": "Wav2Vec2CTCTokenizer"} \ No newline at end of file diff --git a/train_results.json b/train_results.json new file mode 100644 index 0000000..c1c2150 --- /dev/null +++ b/train_results.json @@ -0,0 +1,8 @@ +{ + "epoch": 50.0, + "train_loss": 1.3658743798928183, + "train_runtime": 33116.2978, + "train_samples": 11695, + "train_samples_per_second": 17.657, + "train_steps_per_second": 0.553 +} \ No newline at end of file diff --git a/trainer_state.json b/trainer_state.json new file mode 100644 index 0000000..075b2a1 --- /dev/null +++ b/trainer_state.json @@ -0,0 +1,1177 @@ +{ + "best_metric": null, + "best_model_checkpoint": null, + "epoch": 50.0, + "global_step": 18300, + "is_hyper_param_search": false, + "is_local_process_zero": true, + "is_world_process_zero": true, + "log_history": [ + { + "epoch": 0.27, + "learning_rate": 2.2866666666666662e-06, + "loss": 16.3914, + "step": 100 + }, + { + "epoch": 0.55, + "learning_rate": 4.596666666666666e-06, + "loss": 10.3351, + "step": 200 + }, + { + "epoch": 0.82, + "learning_rate": 6.93e-06, + "loss": 5.7909, + "step": 300 + }, + { + "epoch": 1.09, + "learning_rate": 9.263333333333332e-06, + "loss": 4.7705, + "step": 400 + }, + { + "epoch": 1.37, + "learning_rate": 1.1596666666666665e-05, + "loss": 4.1586, + "step": 500 + }, + { + "epoch": 1.64, + "learning_rate": 1.3929999999999999e-05, + "loss": 3.7094, + "step": 600 + }, + { + "epoch": 1.91, + "learning_rate": 1.626333333333333e-05, + "loss": 3.3499, + "step": 700 + }, + { + "epoch": 2.19, + "learning_rate": 1.8596666666666664e-05, + "loss": 3.1161, + "step": 800 + }, + { + "epoch": 2.46, + "learning_rate": 2.0929999999999998e-05, + "loss": 2.9926, + "step": 900 + }, + { + "epoch": 2.73, + "learning_rate": 2.326333333333333e-05, + "loss": 2.9385, + "step": 1000 + }, + { + "epoch": 3.01, + "learning_rate": 2.559666666666666e-05, + "loss": 2.889, + "step": 1100 + }, + { + "epoch": 3.28, + "learning_rate": 2.793e-05, + "loss": 2.8583, + "step": 1200 + }, + { + "epoch": 3.55, + "learning_rate": 3.0263333333333332e-05, + "loss": 2.8445, + "step": 1300 + }, + { + "epoch": 3.83, + "learning_rate": 3.2596666666666666e-05, + "loss": 2.8281, + "step": 1400 + }, + { + "epoch": 4.1, + "learning_rate": 3.493e-05, + "loss": 2.8191, + "step": 1500 + }, + { + "epoch": 4.37, + "learning_rate": 3.7263333333333326e-05, + "loss": 2.7995, + "step": 1600 + }, + { + "epoch": 4.64, + "learning_rate": 3.959666666666666e-05, + "loss": 2.6081, + "step": 1700 + }, + { + "epoch": 4.92, + "learning_rate": 4.192999999999999e-05, + "loss": 2.0775, + "step": 1800 + }, + { + "epoch": 5.19, + "learning_rate": 4.426333333333333e-05, + "loss": 1.763, + "step": 1900 + }, + { + "epoch": 5.46, + "learning_rate": 4.659666666666666e-05, + "loss": 1.6346, + "step": 2000 + }, + { + "epoch": 5.74, + "learning_rate": 4.8929999999999994e-05, + "loss": 1.5687, + "step": 2100 + }, + { + "epoch": 6.01, + "learning_rate": 5.126333333333333e-05, + "loss": 1.5288, + "step": 2200 + }, + { + "epoch": 6.28, + "learning_rate": 5.359666666666667e-05, + "loss": 1.4756, + "step": 2300 + }, + { + "epoch": 6.56, + "learning_rate": 5.593e-05, + "loss": 1.4463, + "step": 2400 + }, + { + "epoch": 6.83, + "learning_rate": 5.826333333333333e-05, + "loss": 1.4291, + "step": 2500 + }, + { + "epoch": 7.1, + "learning_rate": 6.059666666666666e-05, + "loss": 1.4114, + "step": 2600 + }, + { + "epoch": 7.38, + "learning_rate": 6.293e-05, + "loss": 1.3955, + "step": 2700 + }, + { + "epoch": 7.65, + "learning_rate": 6.526333333333332e-05, + "loss": 1.3691, + "step": 2800 + }, + { + "epoch": 7.92, + "learning_rate": 6.759666666666666e-05, + "loss": 1.3556, + "step": 2900 + }, + { + "epoch": 8.2, + "learning_rate": 6.992999999999999e-05, + "loss": 1.3454, + "step": 3000 + }, + { + "epoch": 8.2, + "eval_loss": 0.49262478947639465, + "eval_runtime": 209.1038, + "eval_samples_per_second": 23.194, + "eval_steps_per_second": 1.454, + "eval_wer": 0.5703299486541871, + "step": 3000 + }, + { + "epoch": 8.47, + "learning_rate": 6.955620915032679e-05, + "loss": 1.326, + "step": 3100 + }, + { + "epoch": 8.74, + "learning_rate": 6.90986928104575e-05, + "loss": 1.318, + "step": 3200 + }, + { + "epoch": 9.02, + "learning_rate": 6.864117647058823e-05, + "loss": 1.3012, + "step": 3300 + }, + { + "epoch": 9.29, + "learning_rate": 6.818366013071895e-05, + "loss": 1.2888, + "step": 3400 + }, + { + "epoch": 9.56, + "learning_rate": 6.772614379084966e-05, + "loss": 1.2874, + "step": 3500 + }, + { + "epoch": 9.84, + "learning_rate": 6.726862745098038e-05, + "loss": 1.2699, + "step": 3600 + }, + { + "epoch": 10.11, + "learning_rate": 6.681111111111111e-05, + "loss": 1.2558, + "step": 3700 + }, + { + "epoch": 10.38, + "learning_rate": 6.635359477124183e-05, + "loss": 1.2512, + "step": 3800 + }, + { + "epoch": 10.66, + "learning_rate": 6.589607843137254e-05, + "loss": 1.2502, + "step": 3900 + }, + { + "epoch": 10.93, + "learning_rate": 6.543856209150327e-05, + "loss": 1.246, + "step": 4000 + }, + { + "epoch": 11.2, + "learning_rate": 6.498104575163397e-05, + "loss": 1.2205, + "step": 4100 + }, + { + "epoch": 11.48, + "learning_rate": 6.45235294117647e-05, + "loss": 1.2192, + "step": 4200 + }, + { + "epoch": 11.75, + "learning_rate": 6.406601307189542e-05, + "loss": 1.2146, + "step": 4300 + }, + { + "epoch": 12.02, + "learning_rate": 6.360849673202614e-05, + "loss": 1.2143, + "step": 4400 + }, + { + "epoch": 12.3, + "learning_rate": 6.315098039215685e-05, + "loss": 1.205, + "step": 4500 + }, + { + "epoch": 12.57, + "learning_rate": 6.269346405228757e-05, + "loss": 1.1777, + "step": 4600 + }, + { + "epoch": 12.84, + "learning_rate": 6.22359477124183e-05, + "loss": 1.1901, + "step": 4700 + }, + { + "epoch": 13.11, + "learning_rate": 6.177843137254901e-05, + "loss": 1.1729, + "step": 4800 + }, + { + "epoch": 13.39, + "learning_rate": 6.132091503267974e-05, + "loss": 1.1813, + "step": 4900 + }, + { + "epoch": 13.66, + "learning_rate": 6.086339869281045e-05, + "loss": 1.1773, + "step": 5000 + }, + { + "epoch": 13.93, + "learning_rate": 6.040588235294117e-05, + "loss": 1.1517, + "step": 5100 + }, + { + "epoch": 14.21, + "learning_rate": 5.994836601307189e-05, + "loss": 1.1568, + "step": 5200 + }, + { + "epoch": 14.48, + "learning_rate": 5.9490849673202613e-05, + "loss": 1.1591, + "step": 5300 + }, + { + "epoch": 14.75, + "learning_rate": 5.903333333333333e-05, + "loss": 1.146, + "step": 5400 + }, + { + "epoch": 15.03, + "learning_rate": 5.8575816993464045e-05, + "loss": 1.1561, + "step": 5500 + }, + { + "epoch": 15.3, + "learning_rate": 5.811830065359477e-05, + "loss": 1.1304, + "step": 5600 + }, + { + "epoch": 15.57, + "learning_rate": 5.7660784313725484e-05, + "loss": 1.1355, + "step": 5700 + }, + { + "epoch": 15.85, + "learning_rate": 5.720326797385621e-05, + "loss": 1.137, + "step": 5800 + }, + { + "epoch": 16.12, + "learning_rate": 5.674575163398693e-05, + "loss": 1.1401, + "step": 5900 + }, + { + "epoch": 16.39, + "learning_rate": 5.628823529411764e-05, + "loss": 1.1202, + "step": 6000 + }, + { + "epoch": 16.39, + "eval_loss": 0.35287711024284363, + "eval_runtime": 207.6346, + "eval_samples_per_second": 23.358, + "eval_steps_per_second": 1.464, + "eval_wer": 0.3944187331629481, + "step": 6000 + }, + { + "epoch": 16.67, + "learning_rate": 5.583071895424836e-05, + "loss": 1.1132, + "step": 6100 + }, + { + "epoch": 16.94, + "learning_rate": 5.537777777777777e-05, + "loss": 1.1199, + "step": 6200 + }, + { + "epoch": 17.21, + "learning_rate": 5.4920261437908495e-05, + "loss": 1.1089, + "step": 6300 + }, + { + "epoch": 17.49, + "learning_rate": 5.446274509803921e-05, + "loss": 1.1038, + "step": 6400 + }, + { + "epoch": 17.76, + "learning_rate": 5.400522875816993e-05, + "loss": 1.1022, + "step": 6500 + }, + { + "epoch": 18.03, + "learning_rate": 5.354771241830065e-05, + "loss": 1.1059, + "step": 6600 + }, + { + "epoch": 18.31, + "learning_rate": 5.3090196078431366e-05, + "loss": 1.097, + "step": 6700 + }, + { + "epoch": 18.58, + "learning_rate": 5.263267973856209e-05, + "loss": 1.0793, + "step": 6800 + }, + { + "epoch": 18.85, + "learning_rate": 5.217516339869281e-05, + "loss": 1.0814, + "step": 6900 + }, + { + "epoch": 19.13, + "learning_rate": 5.171764705882352e-05, + "loss": 1.087, + "step": 7000 + }, + { + "epoch": 19.4, + "learning_rate": 5.126013071895424e-05, + "loss": 1.0784, + "step": 7100 + }, + { + "epoch": 19.67, + "learning_rate": 5.0802614379084966e-05, + "loss": 1.0618, + "step": 7200 + }, + { + "epoch": 19.95, + "learning_rate": 5.034509803921568e-05, + "loss": 1.069, + "step": 7300 + }, + { + "epoch": 20.22, + "learning_rate": 4.9887581699346405e-05, + "loss": 1.0555, + "step": 7400 + }, + { + "epoch": 20.49, + "learning_rate": 4.9430065359477114e-05, + "loss": 1.0559, + "step": 7500 + }, + { + "epoch": 20.77, + "learning_rate": 4.897254901960784e-05, + "loss": 1.0545, + "step": 7600 + }, + { + "epoch": 21.04, + "learning_rate": 4.851503267973856e-05, + "loss": 1.0644, + "step": 7700 + }, + { + "epoch": 21.31, + "learning_rate": 4.8057516339869276e-05, + "loss": 1.0541, + "step": 7800 + }, + { + "epoch": 21.58, + "learning_rate": 4.76e-05, + "loss": 1.0467, + "step": 7900 + }, + { + "epoch": 21.86, + "learning_rate": 4.7142483660130714e-05, + "loss": 1.0309, + "step": 8000 + }, + { + "epoch": 22.13, + "learning_rate": 4.668496732026143e-05, + "loss": 1.0453, + "step": 8100 + }, + { + "epoch": 22.4, + "learning_rate": 4.622745098039215e-05, + "loss": 1.0321, + "step": 8200 + }, + { + "epoch": 22.68, + "learning_rate": 4.5769934640522876e-05, + "loss": 1.0439, + "step": 8300 + }, + { + "epoch": 22.95, + "learning_rate": 4.5316993464052286e-05, + "loss": 1.0403, + "step": 8400 + }, + { + "epoch": 23.22, + "learning_rate": 4.485947712418301e-05, + "loss": 1.0145, + "step": 8500 + }, + { + "epoch": 23.5, + "learning_rate": 4.440196078431372e-05, + "loss": 1.0228, + "step": 8600 + }, + { + "epoch": 23.77, + "learning_rate": 4.394444444444444e-05, + "loss": 1.0236, + "step": 8700 + }, + { + "epoch": 24.04, + "learning_rate": 4.348692810457516e-05, + "loss": 1.0185, + "step": 8800 + }, + { + "epoch": 24.32, + "learning_rate": 4.302941176470588e-05, + "loss": 1.0165, + "step": 8900 + }, + { + "epoch": 24.59, + "learning_rate": 4.2571895424836596e-05, + "loss": 1.0058, + "step": 9000 + }, + { + "epoch": 24.59, + "eval_loss": 0.31432652473449707, + "eval_runtime": 204.5409, + "eval_samples_per_second": 23.712, + "eval_steps_per_second": 1.486, + "eval_wer": 0.3340931592641201, + "step": 9000 + }, + { + "epoch": 24.86, + "learning_rate": 4.211437908496731e-05, + "loss": 1.0177, + "step": 9100 + }, + { + "epoch": 25.14, + "learning_rate": 4.1656862745098035e-05, + "loss": 1.0175, + "step": 9200 + }, + { + "epoch": 25.41, + "learning_rate": 4.119934640522876e-05, + "loss": 1.0046, + "step": 9300 + }, + { + "epoch": 25.68, + "learning_rate": 4.0741830065359473e-05, + "loss": 0.9922, + "step": 9400 + }, + { + "epoch": 25.96, + "learning_rate": 4.028431372549019e-05, + "loss": 1.0011, + "step": 9500 + }, + { + "epoch": 26.23, + "learning_rate": 3.982679738562091e-05, + "loss": 0.9852, + "step": 9600 + }, + { + "epoch": 26.5, + "learning_rate": 3.936928104575163e-05, + "loss": 0.9901, + "step": 9700 + }, + { + "epoch": 26.78, + "learning_rate": 3.891176470588235e-05, + "loss": 0.9848, + "step": 9800 + }, + { + "epoch": 27.05, + "learning_rate": 3.8454248366013074e-05, + "loss": 1.0035, + "step": 9900 + }, + { + "epoch": 27.32, + "learning_rate": 3.799673202614378e-05, + "loss": 0.9707, + "step": 10000 + }, + { + "epoch": 27.6, + "learning_rate": 3.7539215686274506e-05, + "loss": 0.9894, + "step": 10100 + }, + { + "epoch": 27.87, + "learning_rate": 3.708169934640523e-05, + "loss": 0.9873, + "step": 10200 + }, + { + "epoch": 28.14, + "learning_rate": 3.6624183006535944e-05, + "loss": 0.9902, + "step": 10300 + }, + { + "epoch": 28.42, + "learning_rate": 3.616666666666667e-05, + "loss": 0.97, + "step": 10400 + }, + { + "epoch": 28.69, + "learning_rate": 3.570915032679738e-05, + "loss": 0.9613, + "step": 10500 + }, + { + "epoch": 28.96, + "learning_rate": 3.52516339869281e-05, + "loss": 0.9734, + "step": 10600 + }, + { + "epoch": 29.23, + "learning_rate": 3.479411764705882e-05, + "loss": 0.9514, + "step": 10700 + }, + { + "epoch": 29.51, + "learning_rate": 3.434117647058823e-05, + "loss": 0.9566, + "step": 10800 + }, + { + "epoch": 29.78, + "learning_rate": 3.388366013071895e-05, + "loss": 0.9632, + "step": 10900 + }, + { + "epoch": 30.05, + "learning_rate": 3.343071895424836e-05, + "loss": 0.9635, + "step": 11000 + }, + { + "epoch": 30.33, + "learning_rate": 3.297320261437908e-05, + "loss": 0.9581, + "step": 11100 + }, + { + "epoch": 30.6, + "learning_rate": 3.2515686274509805e-05, + "loss": 0.9545, + "step": 11200 + }, + { + "epoch": 30.87, + "learning_rate": 3.205816993464052e-05, + "loss": 0.9501, + "step": 11300 + }, + { + "epoch": 31.15, + "learning_rate": 3.1600653594771244e-05, + "loss": 0.9506, + "step": 11400 + }, + { + "epoch": 31.42, + "learning_rate": 3.114313725490196e-05, + "loss": 0.9414, + "step": 11500 + }, + { + "epoch": 31.69, + "learning_rate": 3.0685620915032675e-05, + "loss": 0.9484, + "step": 11600 + }, + { + "epoch": 31.97, + "learning_rate": 3.0228104575163395e-05, + "loss": 0.9474, + "step": 11700 + }, + { + "epoch": 32.24, + "learning_rate": 2.9770588235294114e-05, + "loss": 0.9237, + "step": 11800 + }, + { + "epoch": 32.51, + "learning_rate": 2.9313071895424837e-05, + "loss": 0.9376, + "step": 11900 + }, + { + "epoch": 32.79, + "learning_rate": 2.8855555555555553e-05, + "loss": 0.9287, + "step": 12000 + }, + { + "epoch": 32.79, + "eval_loss": 0.28960883617401123, + "eval_runtime": 208.0073, + "eval_samples_per_second": 23.316, + "eval_steps_per_second": 1.461, + "eval_wer": 0.29796689000944027, + "step": 12000 + }, + { + "epoch": 33.06, + "learning_rate": 2.8398039215686272e-05, + "loss": 0.9325, + "step": 12100 + }, + { + "epoch": 33.33, + "learning_rate": 2.794052287581699e-05, + "loss": 0.9349, + "step": 12200 + }, + { + "epoch": 33.61, + "learning_rate": 2.748300653594771e-05, + "loss": 0.9342, + "step": 12300 + }, + { + "epoch": 33.88, + "learning_rate": 2.702549019607843e-05, + "loss": 0.9282, + "step": 12400 + }, + { + "epoch": 34.15, + "learning_rate": 2.6567973856209146e-05, + "loss": 0.9338, + "step": 12500 + }, + { + "epoch": 34.43, + "learning_rate": 2.611045751633987e-05, + "loss": 0.9195, + "step": 12600 + }, + { + "epoch": 34.7, + "learning_rate": 2.5652941176470585e-05, + "loss": 0.9146, + "step": 12700 + }, + { + "epoch": 34.97, + "learning_rate": 2.5195424836601305e-05, + "loss": 0.9249, + "step": 12800 + }, + { + "epoch": 35.25, + "learning_rate": 2.4737908496732024e-05, + "loss": 0.9137, + "step": 12900 + }, + { + "epoch": 35.52, + "learning_rate": 2.4280392156862743e-05, + "loss": 0.9147, + "step": 13000 + }, + { + "epoch": 35.79, + "learning_rate": 2.3822875816993463e-05, + "loss": 0.9171, + "step": 13100 + }, + { + "epoch": 36.07, + "learning_rate": 2.336535947712418e-05, + "loss": 0.9178, + "step": 13200 + }, + { + "epoch": 36.34, + "learning_rate": 2.29078431372549e-05, + "loss": 0.9164, + "step": 13300 + }, + { + "epoch": 36.61, + "learning_rate": 2.2450326797385617e-05, + "loss": 0.909, + "step": 13400 + }, + { + "epoch": 36.89, + "learning_rate": 2.1997385620915028e-05, + "loss": 0.9106, + "step": 13500 + }, + { + "epoch": 37.16, + "learning_rate": 2.153986928104575e-05, + "loss": 0.9059, + "step": 13600 + }, + { + "epoch": 37.43, + "learning_rate": 2.1082352941176467e-05, + "loss": 0.899, + "step": 13700 + }, + { + "epoch": 37.7, + "learning_rate": 2.0629411764705878e-05, + "loss": 0.9044, + "step": 13800 + }, + { + "epoch": 37.98, + "learning_rate": 2.01718954248366e-05, + "loss": 0.9037, + "step": 13900 + }, + { + "epoch": 38.25, + "learning_rate": 1.971437908496732e-05, + "loss": 0.9013, + "step": 14000 + }, + { + "epoch": 38.52, + "learning_rate": 1.9256862745098036e-05, + "loss": 0.8963, + "step": 14100 + }, + { + "epoch": 38.8, + "learning_rate": 1.879934640522876e-05, + "loss": 0.8998, + "step": 14200 + }, + { + "epoch": 39.07, + "learning_rate": 1.8341830065359474e-05, + "loss": 0.8995, + "step": 14300 + }, + { + "epoch": 39.34, + "learning_rate": 1.7884313725490194e-05, + "loss": 0.9125, + "step": 14400 + }, + { + "epoch": 39.62, + "learning_rate": 1.7426797385620913e-05, + "loss": 0.8982, + "step": 14500 + }, + { + "epoch": 39.89, + "learning_rate": 1.6969281045751633e-05, + "loss": 0.8959, + "step": 14600 + }, + { + "epoch": 40.16, + "learning_rate": 1.6511764705882352e-05, + "loss": 0.8826, + "step": 14700 + }, + { + "epoch": 40.44, + "learning_rate": 1.605424836601307e-05, + "loss": 0.8871, + "step": 14800 + }, + { + "epoch": 40.71, + "learning_rate": 1.559673202614379e-05, + "loss": 0.8815, + "step": 14900 + }, + { + "epoch": 40.98, + "learning_rate": 1.5139215686274508e-05, + "loss": 0.8849, + "step": 15000 + }, + { + "epoch": 40.98, + "eval_loss": 0.2726878821849823, + "eval_runtime": 205.4369, + "eval_samples_per_second": 23.608, + "eval_steps_per_second": 1.48, + "eval_wer": 0.27975409269876356, + "step": 15000 + }, + { + "epoch": 41.26, + "learning_rate": 1.4681699346405228e-05, + "loss": 0.8804, + "step": 15100 + }, + { + "epoch": 41.53, + "learning_rate": 1.4224183006535945e-05, + "loss": 0.8861, + "step": 15200 + }, + { + "epoch": 41.8, + "learning_rate": 1.3766666666666665e-05, + "loss": 0.8913, + "step": 15300 + }, + { + "epoch": 42.08, + "learning_rate": 1.3309150326797386e-05, + "loss": 0.8769, + "step": 15400 + }, + { + "epoch": 42.35, + "learning_rate": 1.2851633986928103e-05, + "loss": 0.885, + "step": 15500 + }, + { + "epoch": 42.62, + "learning_rate": 1.2394117647058823e-05, + "loss": 0.8788, + "step": 15600 + }, + { + "epoch": 42.9, + "learning_rate": 1.1936601307189542e-05, + "loss": 0.8752, + "step": 15700 + }, + { + "epoch": 43.17, + "learning_rate": 1.147908496732026e-05, + "loss": 0.869, + "step": 15800 + }, + { + "epoch": 43.44, + "learning_rate": 1.102156862745098e-05, + "loss": 0.8773, + "step": 15900 + }, + { + "epoch": 43.72, + "learning_rate": 1.0564052287581699e-05, + "loss": 0.8757, + "step": 16000 + }, + { + "epoch": 43.99, + "learning_rate": 1.0106535947712418e-05, + "loss": 0.8693, + "step": 16100 + }, + { + "epoch": 44.26, + "learning_rate": 9.649019607843137e-06, + "loss": 0.863, + "step": 16200 + }, + { + "epoch": 44.54, + "learning_rate": 9.191503267973855e-06, + "loss": 0.8634, + "step": 16300 + }, + { + "epoch": 44.81, + "learning_rate": 8.733986928104574e-06, + "loss": 0.8549, + "step": 16400 + }, + { + "epoch": 45.08, + "learning_rate": 8.276470588235294e-06, + "loss": 0.8528, + "step": 16500 + }, + { + "epoch": 45.36, + "learning_rate": 7.818954248366013e-06, + "loss": 0.861, + "step": 16600 + }, + { + "epoch": 45.63, + "learning_rate": 7.361437908496731e-06, + "loss": 0.8571, + "step": 16700 + }, + { + "epoch": 45.9, + "learning_rate": 6.903921568627451e-06, + "loss": 0.8595, + "step": 16800 + }, + { + "epoch": 46.17, + "learning_rate": 6.44640522875817e-06, + "loss": 0.8605, + "step": 16900 + }, + { + "epoch": 46.45, + "learning_rate": 5.988888888888888e-06, + "loss": 0.8635, + "step": 17000 + }, + { + "epoch": 46.72, + "learning_rate": 5.5313725490196075e-06, + "loss": 0.8594, + "step": 17100 + }, + { + "epoch": 46.99, + "learning_rate": 5.073856209150326e-06, + "loss": 0.8662, + "step": 17200 + }, + { + "epoch": 47.27, + "learning_rate": 4.616339869281045e-06, + "loss": 0.8569, + "step": 17300 + }, + { + "epoch": 47.54, + "learning_rate": 4.158823529411764e-06, + "loss": 0.8583, + "step": 17400 + }, + { + "epoch": 47.81, + "learning_rate": 3.7013071895424833e-06, + "loss": 0.8585, + "step": 17500 + }, + { + "epoch": 48.09, + "learning_rate": 3.2437908496732026e-06, + "loss": 0.8439, + "step": 17600 + }, + { + "epoch": 48.36, + "learning_rate": 2.786274509803921e-06, + "loss": 0.8487, + "step": 17700 + }, + { + "epoch": 48.63, + "learning_rate": 2.3287581699346405e-06, + "loss": 0.8459, + "step": 17800 + }, + { + "epoch": 48.91, + "learning_rate": 1.8712418300653593e-06, + "loss": 0.8576, + "step": 17900 + }, + { + "epoch": 49.18, + "learning_rate": 1.4137254901960782e-06, + "loss": 0.8665, + "step": 18000 + }, + { + "epoch": 49.18, + "eval_loss": 0.2661794126033783, + "eval_runtime": 208.8108, + "eval_samples_per_second": 23.227, + "eval_steps_per_second": 1.456, + "eval_wer": 0.269577030231862, + "step": 18000 + }, + { + "epoch": 49.45, + "learning_rate": 9.562091503267974e-07, + "loss": 0.8569, + "step": 18100 + }, + { + "epoch": 49.73, + "learning_rate": 4.986928104575163e-07, + "loss": 0.8505, + "step": 18200 + }, + { + "epoch": 50.0, + "learning_rate": 4.117647058823529e-08, + "loss": 0.863, + "step": 18300 + }, + { + "epoch": 50.0, + "step": 18300, + "total_flos": 9.169878518581522e+19, + "train_loss": 1.3658743798928183, + "train_runtime": 33116.2978, + "train_samples_per_second": 17.657, + "train_steps_per_second": 0.553 + } + ], + "max_steps": 18300, + "num_train_epochs": 50, + "total_flos": 9.169878518581522e+19, + "trial_name": null, + "trial_params": null +} diff --git a/training_args.bin b/training_args.bin new file mode 100644 index 0000000..0e5d5b1 --- /dev/null +++ b/training_args.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a025fb8da0349575d672e8384eb9d0aaca1183d9dabc68b3258eff7650d9b19c +size 3055 diff --git a/vocab.json b/vocab.json new file mode 100644 index 0000000..43bc166 --- /dev/null +++ b/vocab.json @@ -0,0 +1 @@ +{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 10, "k": 11, "l": 12, "m": 13, "n": 14, "o": 15, "p": 16, "q": 17, "r": 18, "s": 19, "t": 20, "u": 21, "v": 22, "w": 23, "x": 24, "y": 25, "z": 26, "¬": 27, "à": 28, "á": 29, "â": 30, "ä": 31, "é": 32, "ê": 33, "ë": 34, "î": 35, "ï": 36, "ñ": 37, "ò": 38, "ô": 39, "ö": 40, "û": 41, "ÿ": 42, "ŵ": 43, "ŷ": 44, "|": 0, "[UNK]": 45, "[PAD]": 46} \ No newline at end of file diff --git a/welsh_training_script.ipynb b/welsh_training_script.ipynb new file mode 100644 index 0000000..bdec05e --- /dev/null +++ b/welsh_training_script.ipynb @@ -0,0 +1,9832 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "ZG_P29nKcSeI" + }, + "source": [ + "# HuggingFace challenge - Debugger notebook\n", + "Run this notebook to verify your libraries versions, check GPU config and run a quick training" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "YacvHugMc1Ka" + }, + "outputs": [], + "source": [ + "# %%capture\n", + "# !pip install https://github.com/kpu/kenlm/archive/master.zip pyctcdecode\n", + "# !pip install datasets==1.18.3\n", + "# !pip install git+https://github.com/huggingface/transformers.git\n", + "# !pip install huggingface_hub==0.1\n", + "# !pip install torchaudio==0.10.0+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html\n", + "# !pip install jiwer\n", + "# !pip install -U git+https://github.com/huggingface/transformers.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vy63SoiZbnB5", + "outputId": "17391c60-b894-4571-b8a4-d46b18cb42e2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/huggingface/transformers.git\n", + " Cloning https://github.com/huggingface/transformers.git to /tmp/pip-req-build-i45amciw\n", + " Running command git clone -q https://github.com/huggingface/transformers.git /tmp/pip-req-build-i45amciw\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing wheel metadata ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (0.1.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (3.4.2)\n", + "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (4.10.1)\n", + "Requirement already satisfied: tokenizers!=0.11.3,>=0.10.1 in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (0.11.4)\n", + "Requirement already satisfied: sacremoses in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (0.0.47)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (1.19.5)\n", + "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (4.62.3)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (2.23.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (6.0)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (21.3)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.7/dist-packages (from transformers==4.17.0.dev0) (2019.12.20)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from huggingface-hub<1.0,>=0.1.0->transformers==4.17.0.dev0) (3.10.0.2)\n", + "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=20.0->transformers==4.17.0.dev0) (3.0.7)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->transformers==4.17.0.dev0) (3.7.0)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->transformers==4.17.0.dev0) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->transformers==4.17.0.dev0) (2021.10.8)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->transformers==4.17.0.dev0) (3.0.4)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->transformers==4.17.0.dev0) (1.24.3)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers==4.17.0.dev0) (1.15.0)\n", + "Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers==4.17.0.dev0) (1.1.0)\n", + "Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers==4.17.0.dev0) (7.1.2)\n" + ] + } + ], + "source": [ + "# !pip install -U git+https://github.com/huggingface/transformers.git" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "T2utsYSKszvv" + }, + "outputs": [], + "source": [ + "import platform\n", + "import multiprocessing\n", + "\n", + "import torch\n", + "import transformers\n", + "import datasets\n", + "\n", + "import soundfile" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ejKNEyJEcSeO" + }, + "source": [ + "## Print main infos" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5P6I-W9ts-kR", + "outputId": "bd0c00d8-91c9-4b1a-8f2c-24182c2b227f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Platform: Linux-5.11.0-37-generic-x86_64-with-glibc2.10\n", + "CPU cores: 60\n", + "Python version: 3.8.8\n", + "PyTorch version: 1.10.1+cu102\n", + "GPU is visible: True\n", + "Transformers version: 4.16.0.dev0\n", + "Datasets version: 1.18.3\n", + "soundfile version: 0.10.3\n" + ] + } + ], + "source": [ + "print(f\"Platform: {platform.platform()}\")\n", + "print(f\"CPU cores: {multiprocessing.cpu_count()}\")\n", + "\n", + "print(f\"Python version: {platform.python_version()}\")\n", + "\n", + "print(f\"PyTorch version: {torch.__version__}\")\n", + "print(f\"GPU is visible: {torch.cuda.is_available()}\")\n", + "\n", + "print(f\"Transformers version: {transformers.__version__}\")\n", + "print(f\"Datasets version: {datasets.__version__}\")\n", + "\n", + "print(f\"soundfile version: {soundfile.__version__}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_VUKw21PcSeQ" + }, + "source": [ + "## Check your GPU informations (if any)\n", + "If you launched an AI Training job with GPU resources, they should be listed below (Tesla V100s 32GB).\n", + "Driver and CUDA version " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YT7fRnKctggU", + "outputId": "1fb2c851-11c3-4fcd-ad23-9032f25d7f8d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sat Jan 29 03:27:00 2022 \n", + "+-----------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 470.57.02 Driver Version: 470.57.02 CUDA Version: 11.4 |\n", + "|-------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|===============================+======================+======================|\n", + "| 0 Tesla V100S-PCI... Off | 00000000:00:06.0 Off | 0 |\n", + "| N/A 35C P0 26W / 250W | 4MiB / 32510MiB | 0% Default |\n", + "| | | N/A |\n", + "+-------------------------------+----------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=============================================================================|\n", + "| No running processes found |\n", + "+-----------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 241, + "referenced_widgets": [ + "50a1252082d942b09bfc620a9fa9d1d0", + "e270b7c82f784ebbbba4b17fb07c310d", + "32eb83bb6fd34c56bb345368e47e8f6f", + "34417f648cd54ed5b6d91f53af3e2713", + "7518572223ac480b89af2ab71f38b2ed", + "ce8bb7d0fb744e7b9ce2ff35cfdbc679", + "aa47a09bf444413ba95322d979c1908c", + "0b83a8775ea1441980d8ba945be752fe", + "127389ec566e423ab9a8f60a9d61caaa", + "4e4bc5550505497ba35f6bd7dde2893f", + "e5124c5171e04625b70795e4b7a18819", + "e410e7aecf23433f880a0f7169a8ce97", + "0f6b3cf1d33f46f594934874170bcd83", + "e549178ba75f4939aba6ae1cf743722a", + "9c28978adf974326a21259ae56f47fe9", + "7d3231a0b7794b11af662170b352d9e0" + ] + }, + "id": "3Wj2W4tWcSeR", + "outputId": "ad4eb63f-d643-45bd-b8d7-6adfefd9f773" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Login successful\n", + "Your token has been saved to /root/.huggingface/token\n", + "\u001b[1m\u001b[31mAuthenticated through git-crendential store but this isn't the helper defined on your machine.\n", + "You will have to re-authenticate when pushing to the Hugging Face Hub. Run the following command in your terminal to set it as the default\n", + "\n", + "git config --global credential.helper store\u001b[0m\n" + ] + } + ], + "source": [ + "from huggingface_hub import notebook_login\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "wHpUxFQPeWE2" + }, + "outputs": [], + "source": [ + "%%capture\n", + "!apt install git-lfs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TorMtpwPv6RQ" + }, + "source": [ + "## Quick training run with a dummy model and data\n", + "more information on https://github.com/huggingface/transformers/tree/master/examples/pytorch/speech-recognition" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fevoJD15u4Ss", + "outputId": "64745ecf-65b0-494d-a88d-52826eaae0f8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2022-01-28 09:12:30-- https://raw.githubusercontent.com/huggingface/transformers/master/examples/research_projects/robust-speech-event/run_speech_recognition_ctc_bnb.py\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.111.133, 185.199.109.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 31209 (30K) [text/plain]\n", + "Saving to: ‘run_speech_recognition_ctc.py’\n", + "\n", + "run_speech_recognit 100%[===================>] 30.48K --.-KB/s in 0.001s \n", + "\n", + "2022-01-28 09:12:30 (21.4 MB/s) - ‘run_speech_recognition_ctc.py’ saved [31209/31209]\n", + "\n" + ] + } + ], + "source": [ + "!wget -O run_speech_recognition_ctc.py https://raw.githubusercontent.com/huggingface/transformers/master/examples/pytorch/speech-recognition/run_speech_recognition_ctc.py\n", + "# !wget -O run_speech_recognition_ctc.py https://raw.githubusercontent.com/huggingface/transformers/master/examples/research_projects/robust-speech-event/run_speech_recognition_ctc_bnb.py" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "XJRA51HjcSeT" + }, + "outputs": [], + "source": [ + "# \t--learning_rate=\"7.5e-5\" \\\n", + "# 84.5" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hZOB6ZAnsvDX", + "outputId": "7b6a85b5-950c-46a1-c005-b885f8a9bd17" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nvcc: NVIDIA (R) Cuda compiler driver\n", + "Copyright (c) 2005-2020 NVIDIA Corporation\n", + "Built on Mon_Oct_12_20:09:46_PDT_2020\n", + "Cuda compilation tools, release 11.1, V11.1.105\n", + "Build cuda_11.1.TC455_06.29190527_0\n" + ] + } + ], + "source": [ + "!nvcc --version" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NKlgW0E-sldT", + "outputId": "b925521a-29d2-4787-dd5b-6520dda688e4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting bitsandbytes-cuda111\n", + " Downloading bitsandbytes_cuda111-0.26.0-py3-none-any.whl (4.0 MB)\n", + "\u001b[K |████████████████████████████████| 4.0 MB 4.3 MB/s \n", + "\u001b[?25hInstalling collected packages: bitsandbytes-cuda111\n", + "Successfully installed bitsandbytes-cuda111-0.26.0\n" + ] + } + ], + "source": [ + "!pip install bitsandbytes-cuda111" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "remove special characters from datasets: 11695ex [00:02, 4262.69ex/s]\n", + "remove special characters from datasets: 4850ex [00:01, 4827.87ex/s]\n", + "loading configuration file https://huggingface.co/facebook/wav2vec2-xls-r-300m/resolve/main/config.json from cache at /workspace/.cache/huggingface/transformers/dabc27df63e37bd2a7a221c7774e35f36a280fbdf917cf54cadfc7df8c786f6f.a3e4c3c967d9985881e0ae550a5f6f668f897db5ab2e0802f9b97973b15970e6\n", + "Model config Wav2Vec2Config {\n", + " \"_name_or_path\": \"facebook/wav2vec2-xls-r-300m\",\n", + " \"activation_dropout\": 0.0,\n", + " \"adapter_kernel_size\": 3,\n", + " \"adapter_stride\": 2,\n", + " \"add_adapter\": false,\n", + " \"apply_spec_augment\": true,\n", + " \"architectures\": [\n", + " \"Wav2Vec2ForPreTraining\"\n", + " ],\n", + " \"attention_dropout\": 0.1,\n", + " \"bos_token_id\": 1,\n", + " \"classifier_proj_size\": 256,\n", + " \"codevector_dim\": 768,\n", + " \"contrastive_logits_temperature\": 0.1,\n", + " \"conv_bias\": true,\n", + " \"conv_dim\": [\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512\n", + " ],\n", + " \"conv_kernel\": [\n", + " 10,\n", + " 3,\n", + " 3,\n", + " 3,\n", + " 3,\n", + " 2,\n", + " 2\n", + " ],\n", + " \"conv_stride\": [\n", + " 5,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2\n", + " ],\n", + " \"ctc_loss_reduction\": \"sum\",\n", + " \"ctc_zero_infinity\": false,\n", + " \"diversity_loss_weight\": 0.1,\n", + " \"do_stable_layer_norm\": true,\n", + " \"eos_token_id\": 2,\n", + " \"feat_extract_activation\": \"gelu\",\n", + " \"feat_extract_dropout\": 0.0,\n", + " \"feat_extract_norm\": \"layer\",\n", + " \"feat_proj_dropout\": 0.1,\n", + " \"feat_quantizer_dropout\": 0.0,\n", + " \"final_dropout\": 0.0,\n", + " \"gradient_checkpointing\": false,\n", + " \"hidden_act\": \"gelu\",\n", + " \"hidden_dropout\": 0.1,\n", + " \"hidden_size\": 1024,\n", + " \"initializer_range\": 0.02,\n", + " \"intermediate_size\": 4096,\n", + " \"layer_norm_eps\": 1e-05,\n", + " \"layerdrop\": 0.1,\n", + " \"mask_feature_length\": 10,\n", + " \"mask_feature_min_masks\": 0,\n", + " \"mask_feature_prob\": 0.0,\n", + " \"mask_time_length\": 10,\n", + " \"mask_time_min_masks\": 2,\n", + " \"mask_time_prob\": 0.075,\n", + " \"model_type\": \"wav2vec2\",\n", + " \"num_adapter_layers\": 3,\n", + " \"num_attention_heads\": 16,\n", + " \"num_codevector_groups\": 2,\n", + " \"num_codevectors_per_group\": 320,\n", + " \"num_conv_pos_embedding_groups\": 16,\n", + " \"num_conv_pos_embeddings\": 128,\n", + " \"num_feat_extract_layers\": 7,\n", + " \"num_hidden_layers\": 24,\n", + " \"num_negatives\": 100,\n", + " \"output_hidden_size\": 1024,\n", + " \"pad_token_id\": 0,\n", + " \"proj_codevector_dim\": 768,\n", + " \"tdnn_dilation\": [\n", + " 1,\n", + " 2,\n", + " 3,\n", + " 1,\n", + " 1\n", + " ],\n", + " \"tdnn_dim\": [\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 1500\n", + " ],\n", + " \"tdnn_kernel\": [\n", + " 5,\n", + " 3,\n", + " 3,\n", + " 1,\n", + " 1\n", + " ],\n", + " \"torch_dtype\": \"float32\",\n", + " \"transformers_version\": \"4.16.0.dev0\",\n", + " \"use_weighted_layer_sum\": false,\n", + " \"vocab_size\": 32,\n", + " \"xvector_output_dim\": 512\n", + "}\n", + "\n", + "100%|█████████████████████████████████████████████| 1/1 [00:00<00:00, 1.44ba/s]\n", + "100%|█████████████████████████████████████████████| 1/1 [00:00<00:00, 7.07ba/s]\n", + "Didn't find file ./wav2vec2-large-xls-r-300m-welsh/tokenizer.json. We won't load it.\n", + "loading file ./wav2vec2-large-xls-r-300m-welsh/vocab.json\n", + "loading file ./wav2vec2-large-xls-r-300m-welsh/tokenizer_config.json\n", + "loading file ./wav2vec2-large-xls-r-300m-welsh/added_tokens.json\n", + "loading file ./wav2vec2-large-xls-r-300m-welsh/special_tokens_map.json\n", + "loading file None\n", + "Adding to the vocabulary\n", + "Adding to the vocabulary\n", + "loading configuration file https://huggingface.co/facebook/wav2vec2-xls-r-300m/resolve/main/config.json from cache at /workspace/.cache/huggingface/transformers/dabc27df63e37bd2a7a221c7774e35f36a280fbdf917cf54cadfc7df8c786f6f.a3e4c3c967d9985881e0ae550a5f6f668f897db5ab2e0802f9b97973b15970e6\n", + "Model config Wav2Vec2Config {\n", + " \"_name_or_path\": \"facebook/wav2vec2-xls-r-300m\",\n", + " \"activation_dropout\": 0.0,\n", + " \"adapter_kernel_size\": 3,\n", + " \"adapter_stride\": 2,\n", + " \"add_adapter\": false,\n", + " \"apply_spec_augment\": true,\n", + " \"architectures\": [\n", + " \"Wav2Vec2ForPreTraining\"\n", + " ],\n", + " \"attention_dropout\": 0.1,\n", + " \"bos_token_id\": 1,\n", + " \"classifier_proj_size\": 256,\n", + " \"codevector_dim\": 768,\n", + " \"contrastive_logits_temperature\": 0.1,\n", + " \"conv_bias\": true,\n", + " \"conv_dim\": [\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512\n", + " ],\n", + " \"conv_kernel\": [\n", + " 10,\n", + " 3,\n", + " 3,\n", + " 3,\n", + " 3,\n", + " 2,\n", + " 2\n", + " ],\n", + " \"conv_stride\": [\n", + " 5,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2\n", + " ],\n", + " \"ctc_loss_reduction\": \"sum\",\n", + " \"ctc_zero_infinity\": false,\n", + " \"diversity_loss_weight\": 0.1,\n", + " \"do_stable_layer_norm\": true,\n", + " \"eos_token_id\": 2,\n", + " \"feat_extract_activation\": \"gelu\",\n", + " \"feat_extract_dropout\": 0.0,\n", + " \"feat_extract_norm\": \"layer\",\n", + " \"feat_proj_dropout\": 0.1,\n", + " \"feat_quantizer_dropout\": 0.0,\n", + " \"final_dropout\": 0.0,\n", + " \"gradient_checkpointing\": false,\n", + " \"hidden_act\": \"gelu\",\n", + " \"hidden_dropout\": 0.1,\n", + " \"hidden_size\": 1024,\n", + " \"initializer_range\": 0.02,\n", + " \"intermediate_size\": 4096,\n", + " \"layer_norm_eps\": 1e-05,\n", + " \"layerdrop\": 0.1,\n", + " \"mask_feature_length\": 10,\n", + " \"mask_feature_min_masks\": 0,\n", + " \"mask_feature_prob\": 0.0,\n", + " \"mask_time_length\": 10,\n", + " \"mask_time_min_masks\": 2,\n", + " \"mask_time_prob\": 0.075,\n", + " \"model_type\": \"wav2vec2\",\n", + " \"num_adapter_layers\": 3,\n", + " \"num_attention_heads\": 16,\n", + " \"num_codevector_groups\": 2,\n", + " \"num_codevectors_per_group\": 320,\n", + " \"num_conv_pos_embedding_groups\": 16,\n", + " \"num_conv_pos_embeddings\": 128,\n", + " \"num_feat_extract_layers\": 7,\n", + " \"num_hidden_layers\": 24,\n", + " \"num_negatives\": 100,\n", + " \"output_hidden_size\": 1024,\n", + " \"pad_token_id\": 0,\n", + " \"proj_codevector_dim\": 768,\n", + " \"tdnn_dilation\": [\n", + " 1,\n", + " 2,\n", + " 3,\n", + " 1,\n", + " 1\n", + " ],\n", + " \"tdnn_dim\": [\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 1500\n", + " ],\n", + " \"tdnn_kernel\": [\n", + " 5,\n", + " 3,\n", + " 3,\n", + " 1,\n", + " 1\n", + " ],\n", + " \"torch_dtype\": \"float32\",\n", + " \"transformers_version\": \"4.16.0.dev0\",\n", + " \"use_weighted_layer_sum\": false,\n", + " \"vocab_size\": 32,\n", + " \"xvector_output_dim\": 512\n", + "}\n", + "\n", + "loading feature extractor configuration file https://huggingface.co/facebook/wav2vec2-xls-r-300m/resolve/main/preprocessor_config.json from cache at /workspace/.cache/huggingface/transformers/6fb028b95b394059e7d3b367bbca2382b576c66aebe896f04d2cd34e1b575f5b.d4484dc1c81456a2461485e7168b04347a7b9a4e3b1ef3aba723323b33e12326\n", + "Feature extractor Wav2Vec2FeatureExtractor {\n", + " \"do_normalize\": true,\n", + " \"feature_extractor_type\": \"Wav2Vec2FeatureExtractor\",\n", + " \"feature_size\": 1,\n", + " \"padding_side\": \"right\",\n", + " \"padding_value\": 0,\n", + " \"return_attention_mask\": true,\n", + " \"sampling_rate\": 16000\n", + "}\n", + "\n", + "loading weights file https://huggingface.co/facebook/wav2vec2-xls-r-300m/resolve/main/pytorch_model.bin from cache at /workspace/.cache/huggingface/transformers/1e6a6507f3b689035cd4b247e2a37c154e27f39143f31357a49b4e38baeccc36.1edb32803799e27ed554eb7dd935f6745b1a0b17b0ea256442fe24db6eb546cd\n", + "Some weights of the model checkpoint at facebook/wav2vec2-xls-r-300m were not used when initializing Wav2Vec2ForCTC: ['project_q.weight', 'quantizer.weight_proj.weight', 'quantizer.codevectors', 'quantizer.weight_proj.bias', 'project_hid.bias', 'project_hid.weight', 'project_q.bias']\n", + "- This IS expected if you are initializing Wav2Vec2ForCTC from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing Wav2Vec2ForCTC from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", + "Some weights of Wav2Vec2ForCTC were not initialized from the model checkpoint at facebook/wav2vec2-xls-r-300m and are newly initialized: ['lm_head.weight', 'lm_head.bias']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n", + "preprocess datasets: 11695ex [02:01, 95.89ex/s] \n", + "preprocess datasets: 4850ex [00:51, 94.54ex/s] \n", + "100%|██████████████████████████████████████████| 12/12 [00:00<00:00, 734.68ba/s]\n", + "100%|████████████████████████████████████████████| 5/5 [00:00<00:00, 755.84ba/s]\n", + "Configuration saved in ./wav2vec2-large-xls-r-300m-welsh/preprocessor_config.json\n", + "tokenizer config file saved in ./wav2vec2-large-xls-r-300m-welsh/tokenizer_config.json\n", + "Special tokens file saved in ./wav2vec2-large-xls-r-300m-welsh/special_tokens_map.json\n", + "added tokens file saved in ./wav2vec2-large-xls-r-300m-welsh/added_tokens.json\n", + "Configuration saved in ./wav2vec2-large-xls-r-300m-welsh/config.json\n", + "loading feature extractor configuration file ./wav2vec2-large-xls-r-300m-welsh/preprocessor_config.json\n", + "loading configuration file ./wav2vec2-large-xls-r-300m-welsh/config.json\n", + "Model config Wav2Vec2Config {\n", + " \"_name_or_path\": \"./wav2vec2-large-xls-r-300m-welsh\",\n", + " \"activation_dropout\": 0.1,\n", + " \"adapter_kernel_size\": 3,\n", + " \"adapter_stride\": 2,\n", + " \"add_adapter\": false,\n", + " \"apply_spec_augment\": true,\n", + " \"architectures\": [\n", + " \"Wav2Vec2ForPreTraining\"\n", + " ],\n", + " \"attention_dropout\": 0.0,\n", + " \"bos_token_id\": 1,\n", + " \"classifier_proj_size\": 256,\n", + " \"codevector_dim\": 768,\n", + " \"contrastive_logits_temperature\": 0.1,\n", + " \"conv_bias\": true,\n", + " \"conv_dim\": [\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512\n", + " ],\n", + " \"conv_kernel\": [\n", + " 10,\n", + " 3,\n", + " 3,\n", + " 3,\n", + " 3,\n", + " 2,\n", + " 2\n", + " ],\n", + " \"conv_stride\": [\n", + " 5,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2\n", + " ],\n", + " \"ctc_loss_reduction\": \"mean\",\n", + " \"ctc_zero_infinity\": false,\n", + " \"diversity_loss_weight\": 0.1,\n", + " \"do_stable_layer_norm\": true,\n", + " \"eos_token_id\": 2,\n", + " \"feat_extract_activation\": \"gelu\",\n", + " \"feat_extract_dropout\": 0.0,\n", + " \"feat_extract_norm\": \"layer\",\n", + " \"feat_proj_dropout\": 0.0,\n", + " \"feat_quantizer_dropout\": 0.0,\n", + " \"final_dropout\": 0.0,\n", + " \"hidden_act\": \"gelu\",\n", + " \"hidden_dropout\": 0.0,\n", + " \"hidden_size\": 1024,\n", + " \"initializer_range\": 0.02,\n", + " \"intermediate_size\": 4096,\n", + " \"layer_norm_eps\": 1e-05,\n", + " \"layerdrop\": 0.0,\n", + " \"mask_feature_length\": 64,\n", + " \"mask_feature_min_masks\": 0,\n", + " \"mask_feature_prob\": 0.25,\n", + " \"mask_time_length\": 10,\n", + " \"mask_time_min_masks\": 2,\n", + " \"mask_time_prob\": 0.75,\n", + " \"model_type\": \"wav2vec2\",\n", + " \"num_adapter_layers\": 3,\n", + " \"num_attention_heads\": 16,\n", + " \"num_codevector_groups\": 2,\n", + " \"num_codevectors_per_group\": 320,\n", + " \"num_conv_pos_embedding_groups\": 16,\n", + " \"num_conv_pos_embeddings\": 128,\n", + " \"num_feat_extract_layers\": 7,\n", + " \"num_hidden_layers\": 24,\n", + " \"num_negatives\": 100,\n", + " \"output_hidden_size\": 1024,\n", + " \"pad_token_id\": 46,\n", + " \"proj_codevector_dim\": 768,\n", + " \"tdnn_dilation\": [\n", + " 1,\n", + " 2,\n", + " 3,\n", + " 1,\n", + " 1\n", + " ],\n", + " \"tdnn_dim\": [\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 512,\n", + " 1500\n", + " ],\n", + " \"tdnn_kernel\": [\n", + " 5,\n", + " 3,\n", + " 3,\n", + " 1,\n", + " 1\n", + " ],\n", + " \"torch_dtype\": \"float32\",\n", + " \"transformers_version\": \"4.16.0.dev0\",\n", + " \"use_weighted_layer_sum\": false,\n", + " \"vocab_size\": 49,\n", + " \"xvector_output_dim\": 512\n", + "}\n", + "\n", + "loading feature extractor configuration file ./wav2vec2-large-xls-r-300m-welsh/preprocessor_config.json\n", + "Feature extractor Wav2Vec2FeatureExtractor {\n", + " \"do_normalize\": true,\n", + " \"feature_extractor_type\": \"Wav2Vec2FeatureExtractor\",\n", + " \"feature_size\": 1,\n", + " \"padding_side\": \"right\",\n", + " \"padding_value\": 0,\n", + " \"return_attention_mask\": true,\n", + " \"sampling_rate\": 16000\n", + "}\n", + "\n", + "Didn't find file ./wav2vec2-large-xls-r-300m-welsh/tokenizer.json. We won't load it.\n", + "loading file ./wav2vec2-large-xls-r-300m-welsh/vocab.json\n", + "loading file ./wav2vec2-large-xls-r-300m-welsh/tokenizer_config.json\n", + "loading file ./wav2vec2-large-xls-r-300m-welsh/added_tokens.json\n", + "loading file ./wav2vec2-large-xls-r-300m-welsh/special_tokens_map.json\n", + "loading file None\n", + "Adding to the vocabulary\n", + "Adding to the vocabulary\n", + "/workspace/votic_training/./wav2vec2-large-xls-r-300m-welsh is already a clone of https://huggingface.co/infinitejoy/wav2vec2-large-xls-r-300m-welsh. Make sure you pull the latest changes with `repo.git_pull()`.\n", + "Using amp half precision backend\n", + "The following columns in the training set don't have a corresponding argument in `Wav2Vec2ForCTC.forward` and have been ignored: input_length.\n", + "/opt/conda/lib/python3.8/site-packages/transformers/optimization.py:306: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use thePyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n", + " warnings.warn(\n", + "***** Running training *****\n", + " Num examples = 11695\n", + " Num Epochs = 50\n", + " Instantaneous batch size per device = 32\n", + " Total train batch size (w. parallel, distributed & accumulation) = 32\n", + " Gradient Accumulation steps = 1\n", + " Total optimization steps = 18300\n", + " 16%|█████▌ | 3000/18300 [1:26:46<7:41:42, 1.81s/it]The following columns in the evaluation set don't have a corresponding argument in `Wav2Vec2ForCTC.forward` and have been ignored: input_length.\n", + "***** Running Evaluation *****\n", + " Num examples = 4850\n", + " Batch size = 16\n", + "\n", + " 0%| | 0/304 [00:00 main\n", + "\n", + "Upload file pytorch_model.bin: 100%|███████| 1.18G/1.18G [01:09<00:00, 18.1MB/s]\n", + "Dropping the following result as it does not have all the necessary fields:\n", + "{'dataset': {'name': 'MOZILLA-FOUNDATION/COMMON_VOICE_7_0 - CY', 'type': 'common_voice', 'args': 'Config: cy, Training split: train+validation, Eval split: test'}}\n", + "To https://huggingface.co/infinitejoy/wav2vec2-large-xls-r-300m-welsh\n", + " 079b1fd..22e577c main -> main\n", + "\n" + ] + } + ], + "source": [ + "!python run_speech_recognition_ctc.py \\\n", + "\t--dataset_name=\"mozilla-foundation/common_voice_7_0\" \\\n", + "\t--model_name_or_path=\"facebook/wav2vec2-xls-r-300m\" \\\n", + "\t--dataset_config_name=\"cy\" \\\n", + "\t--output_dir=\"./wav2vec2-large-xls-r-300m-welsh\" \\\n", + "\t--overwrite_output_dir \\\n", + "\t--num_train_epochs=\"50\" \\\n", + "\t--per_device_train_batch_size=\"32\" \\\n", + "\t--per_device_eval_batch_size=\"16\" \\\n", + "\t--gradient_accumulation_steps=\"1\" \\\n", + "\t--learning_rate=\"7e-5\" \\\n", + "\t--warmup_steps=\"3000\" \\\n", + "\t--length_column_name=\"input_length\" \\\n", + "\t--evaluation_strategy=\"steps\" \\\n", + "\t--text_column_name=\"sentence\" \\\n", + "\t--chars_to_ignore , ? . ! \\- \\; \\: \\\" “ % ‘ ” � — ’ … – \\' \\\n", + "\t--save_steps=\"3000\" \\\n", + "\t--eval_steps=\"3000\" \\\n", + "\t--logging_steps=\"100\" \\\n", + "\t--layerdrop=\"0.0\" \\\n", + "\t--activation_dropout=\"0.1\" \\\n", + "\t--save_total_limit=\"2\" \\\n", + "\t--freeze_feature_encoder \\\n", + "\t--feat_proj_dropout=\"0.0\" \\\n", + "\t--mask_time_prob=\"0.75\" \\\n", + "\t--mask_time_length=\"10\" \\\n", + "\t--mask_feature_prob=\"0.25\" \\\n", + "\t--mask_feature_length=\"64\" \\\n", + "\t--gradient_checkpointing \\\n", + "\t--use_auth_token \\\n", + "\t--fp16 \\\n", + "\t--group_by_length \\\n", + "\t--do_train --do_eval \\\n", + " --push_to_hub > out.log" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0zBb4QMVcSeV" + }, + "outputs": [], + "source": [ + "# !rm -rf wav2vec2-large-xls-r-300m-bashkir" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jxvhTTQ2cSeV" + }, + "outputs": [], + "source": [ + "!ls -ltr" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "okCO9-XTcSeV", + "outputId": "a47bb25e-904a-4c1e-8871-d996a16b6bcc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filesystem Size Used Avail Use% Mounted on\n", + "overlay 3.5T 1.2T 2.2T 34% /\n", + "tmpfs 64M 0 64M 0% /dev\n", + "tmpfs 87G 0 87G 0% /sys/fs/cgroup\n", + "tmpfs 87G 0 87G 0% /dev/shm\n", + "/dev/md0 3.5T 1.2T 2.2T 34% /etc/group\n", + "tmpfs 87G 12K 87G 1% /proc/driver/nvidia\n", + "/dev/vda1 49G 6.5G 42G 14% /usr/bin/nvidia-smi\n", + "udev 87G 0 87G 0% /dev/nvidia0\n", + "tmpfs 87G 0 87G 0% /proc/acpi\n", + "tmpfs 87G 0 87G 0% /proc/scsi\n", + "tmpfs 87G 0 87G 0% /sys/firmware\n" + ] + } + ], + "source": [ + "!df -h" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "axSDvjOMdkxW" + }, + "outputs": [], + "source": [ + "# !pip install -U datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 238, + "referenced_widgets": [ + "7c34d36b28e54989b0c509eae1bd9a0f", + "eba629a92467433c92840e4450e7a937", + "cf1afb1025d24c1cbbb1eefd26535a26", + "f347c0838adf462d886a4ae36a3a6b41", + "37bdb17bf4734fd4b92759c874a4d4b8", + "4685ef4f82764fada48035b4de9af9e2", + "aab799184cf8453e9cf026a32abff619", + "1795d07714684311b1ccea7514f298e4", + "7fa8f65c508e4e629b1a2212aaa64ebc", + "c139ed75ff4d47d593f8cb5f3fa4c105", + "776dc15d8836456281084dc154d769e4", + "f3a862eb1219484b8d9381fb0d16b063", + "da3f94cc1140466cbcbdb3e03cbea8c2", + "2fedf1edcc184d9b8c67712511f8bfef", + "25142b9649ef403c8b37cdb7f9a8de4b", + "8f5cd0e3111241b8a61914dac82acf73", + "7340567ea42d42709f8099a249f6b5dd", + "7365cf85ddff4b26a27c9b797c573949", + "2fbc062ac19f4eb7a8adff2a5118bea4", + "ae5b0f9f37e44e8e965f7e20dfdf3bfa", + "24aeaf260d2240d08466c5e3a01d95cb", + "06ec543be0a34943959c3140119c4d6e", + "311cbd6bf6df4c35b7819e49fb55a562", + "3bc2760daaa346b2b20d76d6cf4ed336", + "c4b226675ad84ff29f62847767065469", + "0be3f91b1071464d979c0c59baff32f4", + "7c4a653d81474818b084b71657f71e0f", + "cb10ec01c16a4c50bf8e4c8aec491aa2", + "ec67f65de50b4038ac3b01496ef56f98", + "4b2562825d8e4c5484008cd054e01216", + "209d975f5d4e4300bf01bb6b2472d493", + "690f71c3c232421c8cd92a28b5435b55", + "4f4d422bdd49486c940713c19e754479", + "e5d1a213afc04270926da41e12b30362", + "30afb513746845b481227b3191df4c90", + "c7017ddc94104c27b42658f27f275908", + "155de8f44ddf4021a5d1d4d4968934db", + "cb3b32862a12486f8625d667bb45c368", + "832b4fcaf152402e84bfdaf9833d061f", + "8af6a305cc8a4a038f74f39e6ea8f040", + "4c316c3eddd64af1b4d892516e1ced03", + "efd0fc9b3766457484533a6eb59f2cd4", + "27d72d36fe604e5d96d6a979ed6d50ee", + "f90669ec059249ca81a0e2c5891834db", + "67d3fcb0869a4485b24846d3b1e34fca", + "3db73d64f4e54cad8f8cd0f5facc33c0", + "d434124da4654ada92573070353dbce1", + "3c36f662c44e453ca935753e6dc18060", + "0d0ab06d275d49f5b1ac57b28c53c158", + "61771b0bdfe543b88fc8673a510a986c", + "63d4b794d9df49c6ab6f77f10a76861d", + "42bb543380e14d859f42e966b3c54bc2", + "00a1878e3cda42e1982093e185935937", + "9cce7704e9e74588aa7aa3b9ddf9672f", + "a27c1dd0b5c447058bf8abde274d7085", + "1ee70ac9891d4104ad801f75b4081c9f", + "eda7343054624f4d8a2e2b981b4fab41", + "f56579df97b94a5a8b3a0fbf32905687", + "aee17658cd4b4fe49a759ad6c9d5a576", + "3a6e34083c8f4066a6718c957958cfa6", + "8148f4330d0f441998d9a3ca4942bc22", + "9ea974dfe1184fe3897a7d9d031c7624", + "a968de55d2e148f88084ac96444c17ee", + "c0aeab2086de4ca7ad8b5f0bbcde009c", + "05d04f345a3148dd9053a5d524592333", + "7a68ba6f90a24162a973ba5146c2f546", + "a4411af1dda24dec9b863793ccd22390", + "f085643a56b94b74bb7e883598170f01", + "ee8a677f68a147e5b10a35518616e264", + "315ae5446f264660bbe6119e8261495d", + "64b970adf3af40268fb60e38140157e2", + "2ac4df7918404aed92611750471cd85f", + "7bf164fec94c40858cf5280937f8e00a", + "0e1672eeb5244df9bf0cbd095625d68a", + "ee80362b77ef4375bb931af34bc16d07", + "fed5fdea500f46618789c44aef2bff3b", + "f49c5c9c58ee482a8264e422d4610a8a", + "6a9e0e280ef7493eb4557429d6f53685", + "c51fb67419ed47f98c5ed4ad4e33aeff", + "2de6d3927c534397ab122a9cf6332a33", + "f3891dcc62b74ccd8d5a61b0ca761b2a", + "9958cd546fbe477092527a14bb3bfe21", + "639f180d5e02425dba7d4c4bca07c59b", + "4da0d9054bd74fb2a77bb40371c99a7b", + "3f8a5e226fbf4175b4fa7f39a2a9d290", + "41515b22976648aabe660b8df3506c4c", + "b2a72b0caf104aee8dd95bff01cc52a4", + "6b8769a26838449e9d7d45fc5cc7a6f6", + "50862512d9c14dbd92f8cc3d795d4cd2", + "352fc0a527024af8a284c53f4d521fec", + "67653ac95966464994b1e0a889cfc5d9", + "778d0a9a7de243eba8dd1c0caf3aa82e", + "14eb779636914797867b7315f347839d", + "25a5802292874e49bb42a1489ff54b31", + "89a05d4149534d78935e169c6623f458", + "49f46100f43346d2bdb402e2fd1a1951", + "5e2e7ad6aa8f4f51adf7f6376b84f618", + "2e918f153be0489dbf0ad64bc45c563c", + "c319fa946f3e4380864aed6d3fbb77e7" + ] + }, + "id": "82uZWUF_cSeW", + "outputId": "e78215f2-d452-4d92-a94c-0a469f8760d4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading and preparing dataset common_voice/cy to /workspace/.cache/huggingface/datasets/mozilla-foundation___common_voice/cy/7.0.0/fe20cac47c166e25b1f096ab661832e3da7cf298ed4a91dcaa1343ad972d175b...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset common_voice downloaded and prepared to /workspace/.cache/huggingface/datasets/mozilla-foundation___common_voice/cy/7.0.0/fe20cac47c166e25b1f096ab661832e3da7cf298ed4a91dcaa1343ad972d175b. Subsequent calls will reuse this data.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Reusing dataset common_voice (/workspace/.cache/huggingface/datasets/mozilla-foundation___common_voice/cy/7.0.0/fe20cac47c166e25b1f096ab661832e3da7cf298ed4a91dcaa1343ad972d175b)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11695\n" + ] + } + ], + "source": [ + "from datasets import load_dataset, load_metric, Audio\n", + "\n", + "common_voice_train = load_dataset(\"mozilla-foundation/common_voice_7_0\", \"cy\", use_auth_token=True, split=\"train+validation\")\n", + "common_voice_test = load_dataset(\"mozilla-foundation/common_voice_7_0\", \"cy\", use_auth_token=True, split=\"test\")\n", + "\n", + "print(len(common_voice_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1Qa9wKa4cSeW", + "outputId": "da721286-89ac-421c-a269-e779449488c6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Dataset({\n", + " features: ['client_id', 'path', 'audio', 'sentence', 'up_votes', 'down_votes', 'age', 'gender', 'accent', 'locale', 'segment'],\n", + " num_rows: 11695\n", + "})" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "common_voice_train" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "H_KRIMbEcSeX", + "outputId": "90601843-d465-4cd3-dff0-9d2302e02699" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "18273.4375" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(common_voice_train) * 50 / 32" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "ZUc_UAMbcSeX" + }, + "outputs": [], + "source": [ + "common_voice_train = common_voice_train.remove_columns([\"accent\", \"age\", \"client_id\", \"down_votes\", \"gender\", \"locale\", \"segment\", \"up_votes\"])\n", + "common_voice_test = common_voice_test.remove_columns([\"accent\", \"age\", \"client_id\", \"down_votes\", \"gender\", \"locale\", \"segment\", \"up_votes\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "OKxWKzjMcSeX" + }, + "outputs": [], + "source": [ + "from datasets import ClassLabel\n", + "import random\n", + "import pandas as pd\n", + "from IPython.display import display, HTML\n", + "\n", + "def show_random_elements(dataset, num_examples=10):\n", + " assert num_examples <= len(dataset), \"Can't pick more elements than there are in the dataset.\"\n", + " picks = []\n", + " for _ in range(num_examples):\n", + " pick = random.randint(0, len(dataset)-1)\n", + " while pick in picks:\n", + " pick = random.randint(0, len(dataset)-1)\n", + " picks.append(pick)\n", + " \n", + " df = pd.DataFrame(dataset[picks])\n", + " display(HTML(df.to_html()))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 363 + }, + "id": "uR3e--0AcSeY", + "outputId": "efb84606-2717-4040-ca02-86975a2f4824" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sentence
0Fel arfer ceir dau, ac maent yn gweithio fel pâr.
1Prif fwyd y siani flewog ydy coed masarn.
2Casgliad o deithiau cerdded o gwmpas Henffordd.
3\"Yr ymennydd yw canolfan reoli'r corff cyfan.\"
4Edrychai ar yr aderyn bach gyda'i wasgod sgarlad fel petai'n falch ohono.
5\"Hoffwn wneud rhywbeth sydd yn lleihau'r niwed i'r amgylchedd\"
6Dydyn nhw eu hunain ddim yn gwybod be maen nhw'n neud.
7\"Mae'n gallu siarad, chwythu tân a gwireddu dymuniadau pobl.\"
8Roedd y rhan fwyaf o'r dynion yn labro ar y ffermydd o gwmpas.
9Ef hefyd a gasglodd ynghyd ei barddoniaeth, mewn sawl cyfrol.
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_random_elements(common_voice_train.remove_columns([\"path\", \"audio\"]), num_examples=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "x_zfqqoVcSeY" + }, + "outputs": [], + "source": [ + "import re\n", + "chars_to_remove_regex = '[\\,\\?\\.\\!\\-\\;\\:\\\"\\“\\%\\‘\\”\\�\\—\\’\\…\\–\\']'\n", + "\n", + "def remove_special_characters(batch):\n", + " batch[\"sentence\"] = re.sub(chars_to_remove_regex, '', batch[\"sentence\"]).lower()\n", + " return batch" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 81, + "referenced_widgets": [ + "d8426e73abce4cbaa58a89aef1fce8b7", + "ae51183c24fe42809d080fd15c298f92", + "21c9c4302a76449784f314c15ca59bea", + "fcc23e29fde64cde92f2ae57d7cabd78", + "61ac7115c9b24ebb855343cc01b1d3f4", + "90b3e47068e747c7be958d22fb56fe4f", + "820d84c1afc7416e9368a246ab8d5ce9", + "07447e6083b04bfeb04e5a601fe475bd", + "822d95bb43c44a4394441d92e25120d7", + "138580d9724141448ff8a5e11ef415ce", + "1a03059af7bb40da924ecf3e709d7e0d", + "b9d888877a7e4a24b07f4fb91ceda179", + "36db5c636fcf46518685b91a168d9c11", + "4407f3810d5d4820acf8db794ce305e6", + "72fee1a44b5343a7add71c9649139317", + "9b22b13729bf4f20b8b96da540cfaa3f", + "90bde27c6e564ca285a65d6b594d6865", + "256669df6862481cbd0bbcee229e2efe", + "07b40214652e48adbae525787288795d", + "57e054662b5d497b8e1f3d99fb72034f", + "81a7889575ed4e0293f7ce56032e6edb", + "00a619827a094be4ae891726e44ddd97" + ] + }, + "id": "BQfNU564cSeZ", + "outputId": "6ca3ff91-8acb-4096-d746-aed7edb4055a" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "beeaa6be02b046e8b9026d861a00a2ba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0ex [00:00, ?ex/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3cce8cac8645441fad2de2ad557e6af3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0ex [00:00, ?ex/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "common_voice_train = common_voice_train.map(remove_special_characters)\n", + "common_voice_test = common_voice_test.map(remove_special_characters)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "liHWiYx9cSeZ" + }, + "outputs": [], + "source": [ + "# start_with_ar = common_voice_train.filter(lambda example: \"⅛\" in example['sentence'])\n", + "# start_with_ar[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "gdGzeDEVcSeZ" + }, + "outputs": [], + "source": [ + "# start_with_ar" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "d9Fe6xH1cSea" + }, + "outputs": [], + "source": [ + "def replace_hatted_characters(batch):\n", + "# batch[\"sentence\"] = re.sub('[â]', 'a', batch[\"sentence\"])\n", + "# batch[\"sentence\"] = re.sub('[î]', 'i', batch[\"sentence\"])\n", + "# batch[\"sentence\"] = re.sub('[ô]', 'o', batch[\"sentence\"])\n", + "# batch[\"sentence\"] = re.sub('[û]', 'u', batch[\"sentence\"])\n", + "# batch[\"sentence\"] = re.sub('&', 'and', batch[\"sentence\"])\n", + " return batch" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 81, + "referenced_widgets": [ + "e106fee906b8408ebba822b4ff70693f", + "af14186997de449f997936a81d69876b", + "2d251c97292c4824a6cb218548c17353", + "fcf8a57a02ec44398b95f4a64ad2f0fe", + "8aaba2878c2c484e8fbf9d81354f924f", + "95c3ba1f3cef4ca887dd8461db595c0a", + "7092d73471c44875b496924bc82858df", + "2d63896d07f64d91abb45c257ace72db", + "781d2e3803574e2c841acfd1e090b84f", + "d43443cf2579467a9cc3e9f05c607615", + "19b70fdd00dc47f8b79f0d3acc68d11a", + "992b23b615fb4e88a92782c64ad60cc2", + "46031a26e4ff42819f1169eb07718b46", + "0c8b1327b27449a49f9b71fdc80d831c", + "c22392fb7cf0489caf741568e796fc9d", + "b17ceb2a58d64747aafd29836e681e02", + "cb8b0320a4794b278f86c33bbfc9825f", + "1e7f593023d544e1afe46359567abfca", + "33fffaf4bc4a405187a2dd4eaa7ffc67", + "173c6246acdb4a3bbf6dce2e236499a2", + "478464758f2b455bb8848ef4046ed11d", + "ce845667dcf54353b02299f85dcda29d" + ] + }, + "id": "f8K35VABcSea", + "outputId": "3c0f55b5-3d44-4058-b362-896ebb58901c" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3992c89e3b914930b00dca9b6a1f053c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0ex [00:00, ?ex/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "02563aa4c48d4536bc308191ad5bfe98", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0ex [00:00, ?ex/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "common_voice_train = common_voice_train.map(replace_hatted_characters)\n", + "common_voice_test = common_voice_test.map(replace_hatted_characters)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "DOIBoakvcSea" + }, + "outputs": [], + "source": [ + "def extract_all_chars(batch):\n", + " all_text = \" \".join(batch[\"sentence\"])\n", + " vocab = list(set(all_text))\n", + " return {\"vocab\": [vocab], \"all_text\": [all_text]}" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 81, + "referenced_widgets": [ + "43a3718f19944ea7bda27a96e3816a78", + "2ec6b96f3d8449c08a8b62b85ccb57dc", + "8137d055bfd14a058a8755d00e5fe260", + "6fa1c2f06d0c43c38c76a7ace7c178a5", + "d8593055a0ea45f5ab13377c18e2b1e0", + "85ff02f4cd7141a4aba5e1e83bb144d2", + "fe412730e037441b961a664573d02ae7", + "a33fe3bf150949fd9679ff1fe91d4433", + "49aa86ddf29944b281b830b99e1ac4fe", + "efb5e6e4970f43d1b6197e4aaedac0b7", + "6e1517cd2bed4a35b52de6cdc812b75c", + "557ddd52295c43a69b6fd2689edb46b4", + "19630b62bebe4a8f9e775e59ee46fb9c", + "4256584d0f934678901c4c1ac7f73d42", + "0120e6cb1edc429ebf0a6437dc3378fe", + "d9c616f1d67c4590a55bf797d8ab1904", + "2d96a892d0a94a89b756e23ff19a1c1f", + "c87e36307bf84cf4970afce9e496117d", + "20d3b7a6a43143419d9cb64e557b3acc", + "16dd9300014545caa901274f385e6a91", + "c6c51e30cbb1472f9e1a49bc0f5bb2cc", + "002decc6fb504205ae9f61a4871e1532" + ] + }, + "id": "ZvFltuhucSea", + "outputId": "fb969f7f-7172-4d82-8116-3dab25bd85a2" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1a8caed7f95a4d49ab361976060274ac", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 main\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "'https://huggingface.co/infinitejoy/wav2vec2-large-xls-r-300m-welsh/commit/03ec13af00e374f3ccee1256ed774c84d572abe4'" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vocab_dict[\"|\"] = vocab_dict[\" \"]\n", + "del vocab_dict[\" \"]\n", + "\n", + "vocab_dict[\"[UNK]\"] = len(vocab_dict)\n", + "vocab_dict[\"[PAD]\"] = len(vocab_dict)\n", + "print(len(vocab_dict))\n", + "\n", + "import json\n", + "with open('./vocab.json', 'w') as vocab_file:\n", + " json.dump(vocab_dict, vocab_file)\n", + " \n", + "from transformers import Wav2Vec2CTCTokenizer\n", + "\n", + "tokenizer = Wav2Vec2CTCTokenizer.from_pretrained(\"./\", unk_token=\"[UNK]\", pad_token=\"[PAD]\", word_delimiter_token=\"|\")\n", + "\n", + "repo_name = \"wav2vec2-large-xls-r-300m-welsh\"\n", + "\n", + "# tokenizer.save_pretrained(repo_name)\n", + "\n", + "tokenizer.push_to_hub(repo_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1XVJcIykcSeb", + "outputId": "67c53812-24ce-4dee-bb95-608971d61338" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2022-01-30 07:10:29-- https://raw.githubusercontent.com/huggingface/transformers/master/examples/research_projects/robust-speech-event/eval.py\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 4738 (4.6K) [text/plain]\n", + "Saving to: ‘eval.py’\n", + "\n", + "eval.py 100%[===================>] 4.63K --.-KB/s in 0s \n", + "\n", + "2022-01-30 07:10:29 (16.6 MB/s) - ‘eval.py’ saved [4738/4738]\n", + "\n", + "total 1232584\n", + "-rw-r--r-- 1 ovh ovh 300 Jan 30 02:51 vocab.json\n", + "-rw-r--r-- 1 ovh ovh 260 Jan 30 02:51 tokenizer_config.json\n", + "-rw-r--r-- 1 ovh ovh 309 Jan 30 02:51 special_tokens_map.json\n", + "-rw-r--r-- 1 ovh ovh 23 Jan 30 02:51 added_tokens.json\n", + "drwxr-xr-x 2 ovh ovh 4096 Jan 30 04:36 checkpoint-500\n", + "drwxr-xr-x 2 ovh ovh 4096 Jan 30 06:22 checkpoint-1000\n", + "-rw-r--r-- 1 ovh ovh 2521 Jan 30 07:06 trainer_state.json\n", + "-rw-r--r-- 1 ovh ovh 197 Jan 30 07:06 train_results.json\n", + "-rw-r--r-- 1 ovh ovh 224 Jan 30 07:06 eval_results.json\n", + "-rw-r--r-- 1 ovh ovh 2033 Jan 30 07:06 config.json\n", + "-rw-r--r-- 1 ovh ovh 398 Jan 30 07:06 all_results.json\n", + "-rw-r--r-- 1 ovh ovh 1262063089 Jan 30 07:06 pytorch_model.bin\n", + "-rw-r--r-- 1 ovh ovh 212 Jan 30 07:06 preprocessor_config.json\n", + "-rw-r--r-- 1 ovh ovh 3055 Jan 30 07:06 training_args.bin\n", + "-rw-r--r-- 1 ovh ovh 1709 Jan 30 07:08 README.md\n", + "-rw-r--r-- 1 ovh ovh 4738 Jan 30 07:10 eval.py\n", + "-rw-r--r-- 1 ovh ovh 30348 Jan 30 07:10 run_speech_recognition_ctc.py\n" + ] + } + ], + "source": [ + "!wget -O eval.py https://raw.githubusercontent.com/huggingface/transformers/master/examples/research_projects/robust-speech-event/eval.py\n", + "!cp eval.py wav2vec2-large-xls-r-300m-irish\n", + "!cp run_speech_recognition_ctc.py wav2vec2-large-xls-r-300m-irish\n", + "!ls -ltr wav2vec2-large-xls-r-300m-irish" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "id": "OLB-MXricSec", + "outputId": "784016e5-2c0a-4235-b432-96bf126b33ba" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error: mkl-service + Intel(R) MKL: MKL_THREADING_LAYER=INTEL is incompatible with libgomp-a34b3233.so.1 library.\n", + "\tTry to import numpy first or set the threading layer accordingly. Set MKL_SERVICE_FORCE_INTEL to force it.\n" + ] + } + ], + "source": [ + "!cd wav2vec2-large-xls-r-300m-welsh;python eval.py \\\n", + " --model_id ./ --dataset mozilla-foundation/common_voice_7_0 --config cy --split test --log_outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "id": "aoMHnv5ocSec" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error: mkl-service + Intel(R) MKL: MKL_THREADING_LAYER=INTEL is incompatible with libgomp-a34b3233.so.1 library.\n", + "\tTry to import numpy first or set the threading layer accordingly. Set MKL_SERVICE_FORCE_INTEL to force it.\n" + ] + } + ], + "source": [ + "!cd wav2vec2-large-xls-r-300m-irish; python eval.py \\\n", + " --model_id ./ --dataset speech-recognition-community-v2/dev_data \\\n", + " --config cy --split validation --chunk_length_s 10 --stride_length_s 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "referenced_widgets": [ + "24592b0be30e4eafb1949cf09d1c4fb4", + "f9bf2ab0d2fa4d3f9235cc6d1ab772f1", + "b0791474a34043da8057e06741472ade", + "1ccbd582d616458b87c76ac8dc5b6b36" + ] + }, + "id": "5vvo9g7HcSec", + "outputId": "c2cab8b0-2b67-4039-b8ca-9ab13c9629c3" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "24592b0be30e4eafb1949cf09d1c4fb4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading: 0%| | 0.00/260 [00:00\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mlogits\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_values\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlogits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mlogits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m32\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m: 55" + ] + } + ], + "source": [ + "# from transformers import AutoModelForCTC, AutoProcessor\n", + "# from datasets import load_dataset\n", + "\n", + "# model = AutoModelForCTC.from_pretrained(\"infinitejoy/wav2vec2-large-xls-r-300m-bashkir\")\n", + "# processor = AutoProcessor.from_pretrained(\"infinitejoy/wav2vec2-large-xls-r-300m-bashkir\")\n", + "\n", + "# input_values = processor(common_voice_test[0][\"audio\"][\"array\"], return_tensors=\"pt\", sampling_rate=16_000).input_values\n", + "# # input_values = input_values.to(\"cuda\")\n", + "\n", + "# logits = model(input_values).logits\n", + "\n", + "# assert logits.shape[-1] == 32, logits.shape[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "referenced_widgets": [ + "42ac3a57a96b4987b0c62aa41aa13702", + "29dbfe94c1e9436ea3feefd9a7ba5d34", + "acd0b1dccad24943bf760273d89aced3" + ] + }, + "id": "z26_Ce-kcSed", + "outputId": "fb46fc7b-5450-4d76-e2cb-3b6417133d44" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Reusing dataset common_voice (/workspace/.cache/huggingface/datasets/mozilla-foundation___common_voice/lv/7.0.0/fe20cac47c166e25b1f096ab661832e3da7cf298ed4a91dcaa1343ad972d175b)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "81d295b921134614b692ce51d86e1fda", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading: 0%| | 0.00/1.99k [00:00\nHugging Face\n
\nThe AI community building the future\n
\nImmediately click login after typing your password or it might be stored in plain text in this notebook file.\n" + } + }, + "33fffaf4bc4a405187a2dd4eaa7ffc67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "34417f648cd54ed5b6d91f53af3e2713": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_127389ec566e423ab9a8f60a9d61caaa", + "IPY_MODEL_4e4bc5550505497ba35f6bd7dde2893f" + ], + "layout": "IPY_MODEL_0b83a8775ea1441980d8ba945be752fe" + } + }, + "352fc0a527024af8a284c53f4d521fec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "36db5c636fcf46518685b91a168d9c11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37bdb17bf4734fd4b92759c874a4d4b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_776dc15d8836456281084dc154d769e4", + "placeholder": "​", + "style": "IPY_MODEL_c139ed75ff4d47d593f8cb5f3fa4c105", + "value": " 9.88k/9.88k [00:00<00:00, 9.35kB/s]" + } + }, + "3a6e34083c8f4066a6718c957958cfa6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a68ba6f90a24162a973ba5146c2f546", + "placeholder": "​", + "style": "IPY_MODEL_05d04f345a3148dd9053a5d524592333", + "value": " 134/0 [00:00<00:00, 369.59 examples/s]" + } + }, + "3bc2760daaa346b2b20d76d6cf4ed336": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c36f662c44e453ca935753e6dc18060": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "info", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00a1878e3cda42e1982093e185935937", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_42bb543380e14d859f42e966b3c54bc2", + "value": 1 + } + }, + "3db73d64f4e54cad8f8cd0f5facc33c0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f8a5e226fbf4175b4fa7f39a2a9d290": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "41515b22976648aabe660b8df3506c4c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "4256584d0f934678901c4c1ac7f73d42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c87e36307bf84cf4970afce9e496117d", + "placeholder": "​", + "style": "IPY_MODEL_2d96a892d0a94a89b756e23ff19a1c1f", + "value": "100%" + } + }, + "42bb543380e14d859f42e966b3c54bc2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "43a3718f19944ea7bda27a96e3816a78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8137d055bfd14a058a8755d00e5fe260", + "IPY_MODEL_6fa1c2f06d0c43c38c76a7ace7c178a5", + "IPY_MODEL_d8593055a0ea45f5ab13377c18e2b1e0" + ], + "layout": "IPY_MODEL_2ec6b96f3d8449c08a8b62b85ccb57dc" + } + }, + "4407f3810d5d4820acf8db794ce305e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_256669df6862481cbd0bbcee229e2efe", + "placeholder": "​", + "style": "IPY_MODEL_90bde27c6e564ca285a65d6b594d6865", + "value": "" + } + }, + "46031a26e4ff42819f1169eb07718b46": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4685ef4f82764fada48035b4de9af9e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "478464758f2b455bb8848ef4046ed11d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "49aa86ddf29944b281b830b99e1ac4fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "49f46100f43346d2bdb402e2fd1a1951": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4b2562825d8e4c5484008cd054e01216": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4c316c3eddd64af1b4d892516e1ced03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4da0d9054bd74fb2a77bb40371c99a7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e4bc5550505497ba35f6bd7dde2893f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "PasswordModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "PasswordModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Password:", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_7d3231a0b7794b11af662170b352d9e0", + "placeholder": "​", + "style": "IPY_MODEL_9c28978adf974326a21259ae56f47fe9", + "value": "" + } + }, + "4f4d422bdd49486c940713c19e754479": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "50862512d9c14dbd92f8cc3d795d4cd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_67653ac95966464994b1e0a889cfc5d9", + "IPY_MODEL_778d0a9a7de243eba8dd1c0caf3aa82e", + "IPY_MODEL_14eb779636914797867b7315f347839d" + ], + "layout": "IPY_MODEL_352fc0a527024af8a284c53f4d521fec" + } + }, + "50a1252082d942b09bfc620a9fa9d1d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_32eb83bb6fd34c56bb345368e47e8f6f", + "IPY_MODEL_34417f648cd54ed5b6d91f53af3e2713", + "IPY_MODEL_7518572223ac480b89af2ab71f38b2ed" + ], + "layout": "IPY_MODEL_e270b7c82f784ebbbba4b17fb07c310d" + } + }, + "557ddd52295c43a69b6fd2689edb46b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4256584d0f934678901c4c1ac7f73d42", + "IPY_MODEL_0120e6cb1edc429ebf0a6437dc3378fe", + "IPY_MODEL_d9c616f1d67c4590a55bf797d8ab1904" + ], + "layout": "IPY_MODEL_19630b62bebe4a8f9e775e59ee46fb9c" + } + }, + "57e054662b5d497b8e1f3d99fb72034f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "5e2e7ad6aa8f4f51adf7f6376b84f618": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "61771b0bdfe543b88fc8673a510a986c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "61ac7115c9b24ebb855343cc01b1d3f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1a03059af7bb40da924ecf3e709d7e0d", + "placeholder": "​", + "style": "IPY_MODEL_138580d9724141448ff8a5e11ef415ce", + "value": " 1386/? [00:00<00:00, 3063.39ex/s]" + } + }, + "639f180d5e02425dba7d4c4bca07c59b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63d4b794d9df49c6ab6f77f10a76861d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64b970adf3af40268fb60e38140157e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f49c5c9c58ee482a8264e422d4610a8a", + "placeholder": "​", + "style": "IPY_MODEL_fed5fdea500f46618789c44aef2bff3b", + "value": " 0/0 [00:00<?, ? examples/s]" + } + }, + "67653ac95966464994b1e0a889cfc5d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_89a05d4149534d78935e169c6623f458", + "placeholder": "​", + "style": "IPY_MODEL_25a5802292874e49bb42a1489ff54b31", + "value": "" + } + }, + "67d3fcb0869a4485b24846d3b1e34fca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d434124da4654ada92573070353dbce1", + "IPY_MODEL_3c36f662c44e453ca935753e6dc18060", + "IPY_MODEL_0d0ab06d275d49f5b1ac57b28c53c158" + ], + "layout": "IPY_MODEL_3db73d64f4e54cad8f8cd0f5facc33c0" + } + }, + "690f71c3c232421c8cd92a28b5435b55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6a9e0e280ef7493eb4557429d6f53685": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2de6d3927c534397ab122a9cf6332a33", + "IPY_MODEL_f3891dcc62b74ccd8d5a61b0ca761b2a", + "IPY_MODEL_9958cd546fbe477092527a14bb3bfe21" + ], + "layout": "IPY_MODEL_c51fb67419ed47f98c5ed4ad4e33aeff" + } + }, + "6b8769a26838449e9d7d45fc5cc7a6f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6e1517cd2bed4a35b52de6cdc812b75c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6fa1c2f06d0c43c38c76a7ace7c178a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_49aa86ddf29944b281b830b99e1ac4fe", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a33fe3bf150949fd9679ff1fe91d4433", + "value": 1 + } + }, + "7092d73471c44875b496924bc82858df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72fee1a44b5343a7add71c9649139317": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57e054662b5d497b8e1f3d99fb72034f", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_07b40214652e48adbae525787288795d", + "value": 1 + } + }, + "7340567ea42d42709f8099a249f6b5dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7365cf85ddff4b26a27c9b797c573949": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7518572223ac480b89af2ab71f38b2ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_e410e7aecf23433f880a0f7169a8ce97", + "style": "IPY_MODEL_e5124c5171e04625b70795e4b7a18819", + "tooltip": "" + } + }, + "776dc15d8836456281084dc154d769e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "778d0a9a7de243eba8dd1c0caf3aa82e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "info", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5e2e7ad6aa8f4f51adf7f6376b84f618", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_49f46100f43346d2bdb402e2fd1a1951", + "value": 1 + } + }, + "781d2e3803574e2c841acfd1e090b84f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "7a68ba6f90a24162a973ba5146c2f546": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7bf164fec94c40858cf5280937f8e00a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c34d36b28e54989b0c509eae1bd9a0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cf1afb1025d24c1cbbb1eefd26535a26", + "IPY_MODEL_f347c0838adf462d886a4ae36a3a6b41", + "IPY_MODEL_37bdb17bf4734fd4b92759c874a4d4b8" + ], + "layout": "IPY_MODEL_eba629a92467433c92840e4450e7a937" + } + }, + "7c4a653d81474818b084b71657f71e0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f4d422bdd49486c940713c19e754479", + "placeholder": "​", + "style": "IPY_MODEL_690f71c3c232421c8cd92a28b5435b55", + "value": " 49.7k/49.7k [00:00<00:00, 5.02kB/s]" + } + }, + "7d3231a0b7794b11af662170b352d9e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7fa8f65c508e4e629b1a2212aaa64ebc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8137d055bfd14a058a8755d00e5fe260": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fe412730e037441b961a664573d02ae7", + "placeholder": "​", + "style": "IPY_MODEL_85ff02f4cd7141a4aba5e1e83bb144d2", + "value": "100%" + } + }, + "8148f4330d0f441998d9a3ca4942bc22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "81a7889575ed4e0293f7ce56032e6edb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "820d84c1afc7416e9368a246ab8d5ce9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "822d95bb43c44a4394441d92e25120d7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "832b4fcaf152402e84bfdaf9833d061f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "85ff02f4cd7141a4aba5e1e83bb144d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "89a05d4149534d78935e169c6623f458": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8aaba2878c2c484e8fbf9d81354f924f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_19b70fdd00dc47f8b79f0d3acc68d11a", + "placeholder": "​", + "style": "IPY_MODEL_d43443cf2579467a9cc3e9f05c607615", + "value": " 1386/? [00:00<00:00, 3192.10ex/s]" + } + }, + "8af6a305cc8a4a038f74f39e6ea8f040": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f5cd0e3111241b8a61914dac82acf73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_06ec543be0a34943959c3140119c4d6e", + "placeholder": "​", + "style": "IPY_MODEL_24aeaf260d2240d08466c5e3a01d95cb", + "value": " 2.98k/2.98k [00:00<00:00, 6.54kB/s]" + } + }, + "90b3e47068e747c7be958d22fb56fe4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "90bde27c6e564ca285a65d6b594d6865": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "95c3ba1f3cef4ca887dd8461db595c0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "992b23b615fb4e88a92782c64ad60cc2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0c8b1327b27449a49f9b71fdc80d831c", + "IPY_MODEL_c22392fb7cf0489caf741568e796fc9d", + "IPY_MODEL_b17ceb2a58d64747aafd29836e681e02" + ], + "layout": "IPY_MODEL_46031a26e4ff42819f1169eb07718b46" + } + }, + "9958cd546fbe477092527a14bb3bfe21": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6b8769a26838449e9d7d45fc5cc7a6f6", + "placeholder": "​", + "style": "IPY_MODEL_b2a72b0caf104aee8dd95bff01cc52a4", + "value": " 848/0 [00:00<00:00, 1414.45 examples/s]" + } + }, + "9b22b13729bf4f20b8b96da540cfaa3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00a619827a094be4ae891726e44ddd97", + "placeholder": "​", + "style": "IPY_MODEL_81a7889575ed4e0293f7ce56032e6edb", + "value": " 149/? [00:00<00:00, 1609.27ex/s]" + } + }, + "9c28978adf974326a21259ae56f47fe9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9cce7704e9e74588aa7aa3b9ddf9672f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9ea974dfe1184fe3897a7d9d031c7624": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a27c1dd0b5c447058bf8abde274d7085": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a33fe3bf150949fd9679ff1fe91d4433": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a4411af1dda24dec9b863793ccd22390": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ee8a677f68a147e5b10a35518616e264", + "IPY_MODEL_315ae5446f264660bbe6119e8261495d", + "IPY_MODEL_64b970adf3af40268fb60e38140157e2" + ], + "layout": "IPY_MODEL_f085643a56b94b74bb7e883598170f01" + } + }, + "a968de55d2e148f88084ac96444c17ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "aa47a09bf444413ba95322d979c1908c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aab799184cf8453e9cf026a32abff619": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae51183c24fe42809d080fd15c298f92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae5b0f9f37e44e8e965f7e20dfdf3bfa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aee17658cd4b4fe49a759ad6c9d5a576": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "info", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c0aeab2086de4ca7ad8b5f0bbcde009c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a968de55d2e148f88084ac96444c17ee", + "value": 1 + } + }, + "af14186997de449f997936a81d69876b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b17ceb2a58d64747aafd29836e681e02": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce845667dcf54353b02299f85dcda29d", + "placeholder": "​", + "style": "IPY_MODEL_478464758f2b455bb8848ef4046ed11d", + "value": " 149/? [00:00<00:00, 1769.20ex/s]" + } + }, + "b2a72b0caf104aee8dd95bff01cc52a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b9d888877a7e4a24b07f4fb91ceda179": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4407f3810d5d4820acf8db794ce305e6", + "IPY_MODEL_72fee1a44b5343a7add71c9649139317", + "IPY_MODEL_9b22b13729bf4f20b8b96da540cfaa3f" + ], + "layout": "IPY_MODEL_36db5c636fcf46518685b91a168d9c11" + } + }, + "c0aeab2086de4ca7ad8b5f0bbcde009c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "c139ed75ff4d47d593f8cb5f3fa4c105": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c22392fb7cf0489caf741568e796fc9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_173c6246acdb4a3bbf6dce2e236499a2", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_33fffaf4bc4a405187a2dd4eaa7ffc67", + "value": 1 + } + }, + "c319fa946f3e4380864aed6d3fbb77e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c4b226675ad84ff29f62847767065469": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ec67f65de50b4038ac3b01496ef56f98", + "placeholder": "​", + "style": "IPY_MODEL_cb10ec01c16a4c50bf8e4c8aec491aa2", + "value": "Downloading: 100%" + } + }, + "c51fb67419ed47f98c5ed4ad4e33aeff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6c51e30cbb1472f9e1a49bc0f5bb2cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c7017ddc94104c27b42658f27f275908": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8af6a305cc8a4a038f74f39e6ea8f040", + "placeholder": "​", + "style": "IPY_MODEL_832b4fcaf152402e84bfdaf9833d061f", + "value": "Downloading: 100%" + } + }, + "c87e36307bf84cf4970afce9e496117d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb10ec01c16a4c50bf8e4c8aec491aa2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cb3b32862a12486f8625d667bb45c368": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f90669ec059249ca81a0e2c5891834db", + "placeholder": "​", + "style": "IPY_MODEL_27d72d36fe604e5d96d6a979ed6d50ee", + "value": " 63.6M/63.6M [00:03<00:00, 35.4MB/s]" + } + }, + "cb8b0320a4794b278f86c33bbfc9825f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ce845667dcf54353b02299f85dcda29d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce8bb7d0fb744e7b9ce2ff35cfdbc679": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cf1afb1025d24c1cbbb1eefd26535a26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aab799184cf8453e9cf026a32abff619", + "placeholder": "​", + "style": "IPY_MODEL_4685ef4f82764fada48035b4de9af9e2", + "value": "Downloading: 100%" + } + }, + "d434124da4654ada92573070353dbce1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63d4b794d9df49c6ab6f77f10a76861d", + "placeholder": "​", + "style": "IPY_MODEL_61771b0bdfe543b88fc8673a510a986c", + "value": "" + } + }, + "d43443cf2579467a9cc3e9f05c607615": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d8426e73abce4cbaa58a89aef1fce8b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_21c9c4302a76449784f314c15ca59bea", + "IPY_MODEL_fcc23e29fde64cde92f2ae57d7cabd78", + "IPY_MODEL_61ac7115c9b24ebb855343cc01b1d3f4" + ], + "layout": "IPY_MODEL_ae51183c24fe42809d080fd15c298f92" + } + }, + "d8593055a0ea45f5ab13377c18e2b1e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6e1517cd2bed4a35b52de6cdc812b75c", + "placeholder": "​", + "style": "IPY_MODEL_efb5e6e4970f43d1b6197e4aaedac0b7", + "value": " 1/1 [00:00<00:00, 8.08ba/s]" + } + }, + "d9c616f1d67c4590a55bf797d8ab1904": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_002decc6fb504205ae9f61a4871e1532", + "placeholder": "​", + "style": "IPY_MODEL_c6c51e30cbb1472f9e1a49bc0f5bb2cc", + "value": " 1/1 [00:00<00:00, 19.32ba/s]" + } + }, + "da3f94cc1140466cbcbdb3e03cbea8c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e106fee906b8408ebba822b4ff70693f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2d251c97292c4824a6cb218548c17353", + "IPY_MODEL_fcf8a57a02ec44398b95f4a64ad2f0fe", + "IPY_MODEL_8aaba2878c2c484e8fbf9d81354f924f" + ], + "layout": "IPY_MODEL_af14186997de449f997936a81d69876b" + } + }, + "e270b7c82f784ebbbba4b17fb07c310d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "e410e7aecf23433f880a0f7169a8ce97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5124c5171e04625b70795e4b7a18819": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + }, + "e549178ba75f4939aba6ae1cf743722a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5d1a213afc04270926da41e12b30362": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c7017ddc94104c27b42658f27f275908", + "IPY_MODEL_155de8f44ddf4021a5d1d4d4968934db", + "IPY_MODEL_cb3b32862a12486f8625d667bb45c368" + ], + "layout": "IPY_MODEL_30afb513746845b481227b3191df4c90" + } + }, + "eba629a92467433c92840e4450e7a937": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec67f65de50b4038ac3b01496ef56f98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eda7343054624f4d8a2e2b981b4fab41": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee80362b77ef4375bb931af34bc16d07": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "ee8a677f68a147e5b10a35518616e264": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7bf164fec94c40858cf5280937f8e00a", + "placeholder": "​", + "style": "IPY_MODEL_2ac4df7918404aed92611750471cd85f", + "value": "" + } + }, + "efb5e6e4970f43d1b6197e4aaedac0b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "efd0fc9b3766457484533a6eb59f2cd4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f085643a56b94b74bb7e883598170f01": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f347c0838adf462d886a4ae36a3a6b41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7fa8f65c508e4e629b1a2212aaa64ebc", + "max": 9880, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1795d07714684311b1ccea7514f298e4", + "value": 9880 + } + }, + "f3891dcc62b74ccd8d5a61b0ca761b2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "info", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_41515b22976648aabe660b8df3506c4c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3f8a5e226fbf4175b4fa7f39a2a9d290", + "value": 1 + } + }, + "f3a862eb1219484b8d9381fb0d16b063": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2fedf1edcc184d9b8c67712511f8bfef", + "IPY_MODEL_25142b9649ef403c8b37cdb7f9a8de4b", + "IPY_MODEL_8f5cd0e3111241b8a61914dac82acf73" + ], + "layout": "IPY_MODEL_da3f94cc1140466cbcbdb3e03cbea8c2" + } + }, + "f49c5c9c58ee482a8264e422d4610a8a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f56579df97b94a5a8b3a0fbf32905687": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ea974dfe1184fe3897a7d9d031c7624", + "placeholder": "​", + "style": "IPY_MODEL_8148f4330d0f441998d9a3ca4942bc22", + "value": "" + } + }, + "f90669ec059249ca81a0e2c5891834db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fcc23e29fde64cde92f2ae57d7cabd78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_822d95bb43c44a4394441d92e25120d7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_07447e6083b04bfeb04e5a601fe475bd", + "value": 1 + } + }, + "fcf8a57a02ec44398b95f4a64ad2f0fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_781d2e3803574e2c841acfd1e090b84f", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2d63896d07f64d91abb45c257ace72db", + "value": 1 + } + }, + "fe412730e037441b961a664573d02ae7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fed5fdea500f46618789c44aef2bff3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}