diff --git a/README.md b/README.md index fc779a2c..035a03e9 100644 --- a/README.md +++ b/README.md @@ -11,14 +11,17 @@ ```python -# instantiate pretrained speaker diarization pipeline +# 1. visit hf.co/pyannote/speaker-diarization and accept user conditions (only if requested) +# 2. visit hf.co/settings/tokens to create an access token (only if you had to go through 1.) +# 3. instantiate pretrained speaker diarization pipeline from pyannote.audio import Pipeline -pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization") +pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization", + use_auth_token="ACCESS_TOKEN_GOES_HERE") -# apply pretrained pipeline +# 4. apply pretrained pipeline diarization = pipeline("audio.wav") -# print the result +# 5. print the result for turn, _, speaker in diarization.itertracks(yield_label=True): print(f"start={turn.start:.1f}s stop={turn.end:.1f}s speaker_{speaker}") # start=0.2s stop=1.5s speaker_A diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index c12edb26..2a49360b 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -34,6 +34,7 @@ import torch import torch.nn as nn import torch.optim from huggingface_hub import hf_hub_download +from huggingface_hub.utils import RepositoryNotFoundError from pyannote.core import SlidingWindow from pytorch_lightning.utilities.cloud_io import load as pl_load from pytorch_lightning.utilities.model_summary import ModelSummary @@ -415,6 +416,10 @@ class Model(pl.LightningModule): @staticmethod def check_version(library: Text, theirs: Text, mine: Text): + + theirs = ".".join(theirs.split(".")[:3]) + mine = ".".join(mine.split(".")[:3]) + theirs = VersionInfo.parse(theirs) mine = VersionInfo.parse(mine) if theirs.major != mine.major: @@ -777,22 +782,38 @@ class Model(pl.LightningModule): model_id = checkpoint revision = None - path_for_pl = hf_hub_download( - model_id, - HF_PYTORCH_WEIGHTS_NAME, - repo_type="model", - revision=revision, - library_name="pyannote", - library_version=__version__, - cache_dir=cache_dir, - # force_download=False, - # proxies=None, - # etag_timeout=10, - # resume_download=False, - use_auth_token=use_auth_token, - # local_files_only=False, - # legacy_cache_layout=False, - ) + try: + path_for_pl = hf_hub_download( + model_id, + HF_PYTORCH_WEIGHTS_NAME, + repo_type="model", + revision=revision, + library_name="pyannote", + library_version=__version__, + cache_dir=cache_dir, + # force_download=False, + # proxies=None, + # etag_timeout=10, + # resume_download=False, + use_auth_token=use_auth_token, + # local_files_only=False, + # legacy_cache_layout=False, + ) + except RepositoryNotFoundError: + print( + f""" +Could not download '{model_id}' model. +It might be because the model is private or gated so make +sure to authenticate. Visit https://hf.co/settings/tokens to +create your access token and retry with: + + >>> Model.from_pretrained('{model_id}', + ... use_auth_token=YOUR_AUTH_TOKEN) + +If this still does not work, it might be because the model is gated: +visit https://hf.co/{model_id} to accept the user conditions.""" + ) + return None # HACK Huggingface download counters rely on config.yaml # HACK Therefore we download config.yaml even though we diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index 6d19453e..1c28e52f 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -29,6 +29,7 @@ from typing import Callable, List, Optional, Text, Union import yaml from huggingface_hub import hf_hub_download +from huggingface_hub.utils import RepositoryNotFoundError from pyannote.core.utils.helper import get_class_by_name from pyannote.database import FileFinder, ProtocolFile from pyannote.pipeline import Pipeline as _Pipeline @@ -78,22 +79,39 @@ class Pipeline(_Pipeline): model_id = checkpoint_path revision = None - config_yml = hf_hub_download( - model_id, - PIPELINE_PARAMS_NAME, - repo_type="model", - revision=revision, - library_name="pyannote", - library_version=__version__, - cache_dir=cache_dir, - # force_download=False, - # proxies=None, - # etag_timeout=10, - # resume_download=False, - use_auth_token=use_auth_token, - # local_files_only=False, - # legacy_cache_layout=False, - ) + try: + config_yml = hf_hub_download( + model_id, + PIPELINE_PARAMS_NAME, + repo_type="model", + revision=revision, + library_name="pyannote", + library_version=__version__, + cache_dir=cache_dir, + # force_download=False, + # proxies=None, + # etag_timeout=10, + # resume_download=False, + use_auth_token=use_auth_token, + # local_files_only=False, + # legacy_cache_layout=False, + ) + + except RepositoryNotFoundError: + print( + f""" +Could not download '{model_id}' pipeline. +It might be because the pipeline is private or gated so make +sure to authenticate. Visit https://hf.co/settings/tokens to +create your access token and retry with: + + >>> Pipeline.from_pretrained('{model_id}', + ... use_auth_token=YOUR_AUTH_TOKEN) + +If this still does not work, it might be because the pipeline is gated: +visit https://hf.co/{model_id} to accept the user conditions.""" + ) + return None with open(config_yml, "r") as fp: config = yaml.load(fp, Loader=yaml.SafeLoader) @@ -103,7 +121,9 @@ class Pipeline(_Pipeline): Klass = get_class_by_name( pipeline_name, default_module_name="pyannote.pipeline.blocks" ) - pipeline = Klass(**config["pipeline"].get("params", {})) + params = config["pipeline"].get("params", {}) + params.setdefault("use_auth_token", use_auth_token) + pipeline = Klass(**params) # freeze parameters if "freeze" in config: diff --git a/pyannote/audio/interactive/pipeline/recipe.py b/pyannote/audio/interactive/pipeline/recipe.py index 271a678f..df9cc06b 100644 --- a/pyannote/audio/interactive/pipeline/recipe.py +++ b/pyannote/audio/interactive/pipeline/recipe.py @@ -175,7 +175,7 @@ def pipeline( beep: bool = False, ) -> Dict[str, Any]: - pipeline = Pipeline.from_pretrained(pipeline) + pipeline = Pipeline.from_pretrained(pipeline, use_auth_token=True) classes = pipeline.classes() if isinstance(classes, Iterator): diff --git a/pyannote/audio/pipelines/multilabel.py b/pyannote/audio/pipelines/multilabel.py index 16990df6..0f6e3211 100644 --- a/pyannote/audio/pipelines/multilabel.py +++ b/pyannote/audio/pipelines/multilabel.py @@ -25,7 +25,7 @@ # Hervé BREDIN - http://herve.niderb.fr -from typing import Callable, Optional, Union +from typing import Callable, Optional, Text, Union from pyannote.core import Annotation, SlidingWindowFeature from pyannote.metrics.identification import IdentificationErrorRate @@ -53,6 +53,10 @@ class MultiLabelSegmentation(Pipeline): Defaults to optimizing identification error rate. share_min_duration : bool, optional If True, `min_duration_on` and `min_duration_off` are shared among labels. + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` inference_kwargs : dict, optional Keywords arguments passed to Inference. @@ -70,11 +74,12 @@ class MultiLabelSegmentation(Pipeline): """ def __init__( - self, - segmentation: PipelineModel = None, - fscore: bool = False, - share_min_duration: bool = False, - **inference_kwargs, + self, + segmentation: PipelineModel = None, + fscore: bool = False, + share_min_duration: bool = False, + use_auth_token: Union[Text, None] = None, + **inference_kwargs, ): super().__init__() @@ -87,9 +92,9 @@ class MultiLabelSegmentation(Pipeline): self.segmentation = segmentation self.fscore = fscore self.share_min_duration = share_min_duration - + # load model and send it to GPU (when available and not already on GPU) - model = get_model(segmentation) + model = get_model(segmentation, use_auth_token=use_auth_token) if model.device.type == "cpu": (segmentation_device,) = get_devices(needs=1) model.to(segmentation_device) @@ -134,12 +139,16 @@ class MultiLabelSegmentation(Pipeline): label: Binarize( onset=self.thresholds[label]["onset"], offset=self.thresholds[label]["offset"], - min_duration_on=(self.thresholds[label]["min_duration_on"] - if not self.share_min_duration - else self.min_duration_on), # noqa - min_duration_off=(self.thresholds[label]["min_duration_off"] - if not self.share_min_duration - else self.min_duration_off) , # noqa + min_duration_on=( + self.thresholds[label]["min_duration_on"] + if not self.share_min_duration + else self.min_duration_on + ), # noqa + min_duration_off=( + self.thresholds[label]["min_duration_off"] + if not self.share_min_duration + else self.min_duration_off + ), # noqa ) for label in self._classes } @@ -185,7 +194,7 @@ class MultiLabelSegmentation(Pipeline): for i, label in enumerate(self._classes): # extract raw segmentation of current label label_segmentation = SlidingWindowFeature( - segmentations.data[:, i: i + 1], segmentations.sliding_window + segmentations.data[:, i : i + 1], segmentations.sliding_window ) # obtain hard segments label_annotation: Annotation = self._binarize[label](label_segmentation) diff --git a/pyannote/audio/pipelines/overlapped_speech_detection.py b/pyannote/audio/pipelines/overlapped_speech_detection.py index 6d8a8e7f..2d07a76c 100644 --- a/pyannote/audio/pipelines/overlapped_speech_detection.py +++ b/pyannote/audio/pipelines/overlapped_speech_detection.py @@ -22,19 +22,19 @@ """Overlapped speech detection pipelines""" -from typing import Optional, Callable +from typing import Callable, Optional, Text, Union import numpy as np +from pyannote.core import Annotation, SlidingWindowFeature, Timeline +from pyannote.database import get_annotated +from pyannote.metrics.detection import DetectionPrecisionRecallFMeasure +from pyannote.pipeline.parameter import Uniform from pyannote.audio import Inference from pyannote.audio.core.io import AudioFile from pyannote.audio.core.pipeline import Pipeline from pyannote.audio.pipelines.utils import PipelineModel, get_devices, get_model from pyannote.audio.utils.signal import Binarize -from pyannote.core import Annotation, Timeline, SlidingWindowFeature -from pyannote.database import get_annotated -from pyannote.metrics.detection import DetectionPrecisionRecallFMeasure -from pyannote.pipeline.parameter import Uniform def to_overlap(annotation: Annotation) -> Annotation: @@ -95,6 +95,10 @@ class OverlappedSpeechDetection(Pipeline): recall : float, optional Optimize precision at target recall Defaults to optimize precision/recall fscore + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` inference_kwargs : dict, optional Keywords arguments passed to Inference. @@ -113,6 +117,7 @@ class OverlappedSpeechDetection(Pipeline): segmentation: PipelineModel = "pyannote/segmentation", precision: Optional[float] = None, recall: Optional[float] = None, + use_auth_token: Union[Text, None] = None, **inference_kwargs, ): super().__init__() @@ -120,7 +125,7 @@ class OverlappedSpeechDetection(Pipeline): self.segmentation = segmentation # load model and send it to GPU (when available and not already on GPU) - model = get_model(segmentation) + model = get_model(segmentation, use_auth_token=use_auth_token) if model.device.type == "cpu": (segmentation_device,) = get_devices(needs=1) model.to(segmentation_device) diff --git a/pyannote/audio/pipelines/resegmentation.py b/pyannote/audio/pipelines/resegmentation.py index 659a18fe..7e3969a2 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -22,7 +22,7 @@ """Resegmentation pipeline""" -from typing import Callable, Optional, Text +from typing import Callable, Optional, Text, Union import numpy as np from pyannote.core import Annotation, Segment, SlidingWindowFeature @@ -66,6 +66,10 @@ class Resegmentation(SpeakerDiarizationMixin, Pipeline): Optimize for a variant of diarization error rate. Defaults to {"collar": 0.0, "skip_overlap": False}. This is used in `get_metric` when instantiating the metric: GreedyDiarizationErrorRate(**der_variant). + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` Hyper-parameters ---------------- @@ -82,6 +86,7 @@ class Resegmentation(SpeakerDiarizationMixin, Pipeline): segmentation: PipelineModel = "pyannote/segmentation", diarization: Text = "diarization", der_variant: dict = None, + use_auth_token: Union[Text, None] = None, ): super().__init__() @@ -89,7 +94,7 @@ class Resegmentation(SpeakerDiarizationMixin, Pipeline): self.segmentation = segmentation self.diarization = diarization - model: Model = get_model(segmentation) + model: Model = get_model(segmentation, use_auth_token=use_auth_token) (device,) = get_devices(needs=1) model.to(device) self._segmentation = Inference(model) diff --git a/pyannote/audio/pipelines/segmentation.py b/pyannote/audio/pipelines/segmentation.py index 31ff1848..34eb207c 100644 --- a/pyannote/audio/pipelines/segmentation.py +++ b/pyannote/audio/pipelines/segmentation.py @@ -22,29 +22,30 @@ """Speaker segmentation pipeline""" -from typing import Callable, Optional import math -import numpy as np +from typing import Callable, Optional, Text, Union + import networkx as nx +import numpy as np from pyannote.core import SlidingWindowFeature from pyannote.pipeline.parameter import Uniform -from pyannote.audio.core.pipeline import Pipeline from pyannote.audio.core.inference import Inference -from pyannote.audio.core.model import Model from pyannote.audio.core.io import AudioFile +from pyannote.audio.core.model import Model +from pyannote.audio.core.pipeline import Pipeline from pyannote.audio.pipelines.utils import ( PipelineModel, SpeakerDiarizationMixin, get_devices, get_model, ) -from pyannote.audio.utils.signal import binarize from pyannote.audio.utils.metric import ( DiscreteDiarizationErrorRate, SlidingDiarizationErrorRate, ) from pyannote.audio.utils.permutation import mae_cost_func, permutate +from pyannote.audio.utils.signal import binarize class SpeakerSegmentation(SpeakerDiarizationMixin, Pipeline): @@ -59,6 +60,10 @@ class SpeakerSegmentation(SpeakerDiarizationMixin, Pipeline): Skip final conversion to pyannote.core.Annotation. Defaults to False. skip_stitching : bool, optional Skip stitching step. Defaults to False + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` Hyper-parameters ---------------- @@ -80,6 +85,7 @@ class SpeakerSegmentation(SpeakerDiarizationMixin, Pipeline): segmentation: PipelineModel = "pyannote/segmentation", skip_conversion: bool = False, skip_stitching: bool = False, + use_auth_token: Union[Text, None] = None, ): super().__init__() @@ -87,7 +93,7 @@ class SpeakerSegmentation(SpeakerDiarizationMixin, Pipeline): self.skip_stitching = skip_stitching self.skip_conversion = skip_conversion - model: Model = get_model(segmentation) + model: Model = get_model(segmentation, use_auth_token=use_auth_token) (device,) = get_devices(needs=1) model.to(device) self._segmentation = Inference(model) @@ -126,7 +132,10 @@ class SpeakerSegmentation(SpeakerDiarizationMixin, Pipeline): if not (self.skip_stitching or self.skip_conversion): parameters.update( - {"min_duration_on": 0.0, "min_duration_off": 0.0,} + { + "min_duration_on": 0.0, + "min_duration_off": 0.0, + } ) return parameters @@ -140,7 +149,7 @@ class SpeakerSegmentation(SpeakerDiarizationMixin, Pipeline): segmentations: SlidingWindowFeature, onset: float = 0.5 ) -> nx.Graph: """Build stitching graph - + Parameters ---------- segmentations : (num_chunks, num_frames, local_num_speakers)-shaped SlidingWindowFeature @@ -349,4 +358,3 @@ class SpeakerSegmentation(SpeakerDiarizationMixin, Pipeline): ) return SlidingDiarizationErrorRate(window=2.0 * self._segmentation.duration) - diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index d93116bd..348e1cf1 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -24,7 +24,7 @@ import itertools import math -from typing import Callable, Optional +from typing import Callable, Optional, Text, Union import numpy as np import torch @@ -86,6 +86,10 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): Optimize for a variant of diarization error rate. Defaults to {"collar": 0.0, "skip_overlap": False}. This is used in `get_metric` when instantiating the metric: GreedyDiarizationErrorRate(**der_variant). + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` Usage ----- @@ -112,12 +116,13 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): embedding_batch_size: int = 32, segmentation_batch_size: int = 32, der_variant: dict = None, + use_auth_token: Union[Text, None] = None, ): super().__init__() self.segmentation_model = segmentation - model: Model = get_model(segmentation) + model: Model = get_model(segmentation, use_auth_token=use_auth_token) self.segmentation_batch_size = segmentation_batch_size self.segmentation_duration = ( @@ -156,7 +161,7 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): else: self._embedding = PretrainedSpeakerEmbedding( - self.embedding, device=emb_device + self.embedding, device=emb_device, use_auth_token=use_auth_token ) self._audio = Audio(sample_rate=self._embedding.sample_rate, mono=True) metric = self._embedding.metric diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index bbbf1f17..1ebd40fd 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -27,7 +27,7 @@ try: except ImportError: from backports.cached_property import cached_property -from typing import Text +from typing import Text, Union import numpy as np import torch @@ -202,6 +202,10 @@ class SpeechBrainPretrainedSpeakerEmbedding: Name of SpeechBrain model device : torch.device, optional Device + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` Usage ----- @@ -222,6 +226,7 @@ class SpeechBrainPretrainedSpeakerEmbedding: self, embedding: Text = "speechbrain/spkrec-ecapa-voxceleb", device: torch.device = None, + use_auth_token: Union[Text, None] = None, ): if not SPEECHBRAIN_IS_AVAILABLE: @@ -238,6 +243,7 @@ class SpeechBrainPretrainedSpeakerEmbedding: source=self.embedding, savedir=f"{CACHE_DIR}/speechbrain", run_opts={"device": self.device}, + use_auth_token=use_auth_token, ) @cached_property @@ -352,6 +358,10 @@ class PyannoteAudioPretrainedSpeakerEmbedding: pyannote.audio model device : torch.device, optional Device + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` Usage ----- @@ -372,12 +382,13 @@ class PyannoteAudioPretrainedSpeakerEmbedding: self, embedding: PipelineModel = "pyannote/embedding", device: torch.device = None, + use_auth_token: Union[Text, None] = None, ): super().__init__() self.embedding = embedding self.device = device - self.model_: Model = get_model(self.embedding) + self.model_: Model = get_model(self.embedding, use_auth_token=use_auth_token) self.model_.eval() self.model_.to(self.device) @@ -412,7 +423,11 @@ class PyannoteAudioPretrainedSpeakerEmbedding: return embeddings.cpu().numpy() -def PretrainedSpeakerEmbedding(embedding: PipelineModel, device: torch.device = None): +def PretrainedSpeakerEmbedding( + embedding: PipelineModel, + device: torch.device = None, + use_auth_token: Union[Text, None] = None, +): """Pretrained speaker embedding Parameters @@ -422,6 +437,10 @@ def PretrainedSpeakerEmbedding(embedding: PipelineModel, device: torch.device = or a pyannote.audio model. device : torch.device, optional Device + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` Usage ----- @@ -441,13 +460,17 @@ def PretrainedSpeakerEmbedding(embedding: PipelineModel, device: torch.device = """ if isinstance(embedding, str) and "speechbrain" in embedding: - return SpeechBrainPretrainedSpeakerEmbedding(embedding, device=device) + return SpeechBrainPretrainedSpeakerEmbedding( + embedding, device=device, use_auth_token=use_auth_token + ) elif isinstance(embedding, str) and "nvidia" in embedding: return NeMoPretrainedSpeakerEmbedding(embedding, device=device) else: - return PyannoteAudioPretrainedSpeakerEmbedding(embedding, device=device) + return PyannoteAudioPretrainedSpeakerEmbedding( + embedding, device=device, use_auth_token=use_auth_token + ) class SpeakerEmbedding(Pipeline): @@ -465,6 +488,10 @@ class SpeakerEmbedding(Pipeline): Pretrained segmentation (or voice activity detection) model. See pyannote.audio.pipelines.utils.get_model for supported format. Defaults to no voice activity detection. + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` Usage ----- @@ -480,18 +507,23 @@ class SpeakerEmbedding(Pipeline): self, embedding: PipelineModel = "pyannote/embedding", segmentation: PipelineModel = None, + use_auth_token: Union[Text, None] = None, ): super().__init__() self.embedding = embedding self.segmentation = segmentation - self.embedding_model_: Model = get_model(embedding) + self.embedding_model_: Model = get_model( + embedding, use_auth_token=use_auth_token + ) if self.segmentation is None: models = [self.embedding_model_] else: - segmentation_model: Model = get_model(self.segmentation) + segmentation_model: Model = get_model( + self.segmentation, use_auth_token=use_auth_token + ) models = [self.embedding_model_, segmentation_model] # send models to GPU (when GPUs are available and model is not already on GPU) diff --git a/pyannote/audio/pipelines/utils/getter.py b/pyannote/audio/pipelines/utils/getter.py index 3550e485..4c589ad0 100644 --- a/pyannote/audio/pipelines/utils/getter.py +++ b/pyannote/audio/pipelines/utils/getter.py @@ -32,7 +32,10 @@ from pyannote.audio import Inference, Model PipelineModel = Union[Model, Text, Mapping] -def get_model(model: PipelineModel) -> Model: +def get_model( + model: PipelineModel, + use_auth_token: Union[Text, None] = None, +) -> Model: """Load pretrained model and set it into `eval` mode. Parameter @@ -42,6 +45,10 @@ def get_model(model: PipelineModel) -> Model: When `str`, assumes that this is either the path to a checkpoint or the name of a pretrained model on Huggingface.co and loads with `Model.from_pretrained(model)` When `dict`, loads with `Model.from_pretrained(**model)`. + use_auth_token : str, optional + When loading a private or gated huggingface.co pipeline, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by visiting https://hf.co/settings/tokens Returns ------- @@ -65,9 +72,12 @@ def get_model(model: PipelineModel) -> Model: pass elif isinstance(model, Text): - model = Model.from_pretrained(model, strict=False) + model = Model.from_pretrained( + model, use_auth_token=use_auth_token, strict=False + ) elif isinstance(model, Mapping): + model.setdefault("use_auth_token", use_auth_token) model = Model.from_pretrained(**model) else: diff --git a/pyannote/audio/pipelines/voice_activity_detection.py b/pyannote/audio/pipelines/voice_activity_detection.py index b14eab69..b146758a 100644 --- a/pyannote/audio/pipelines/voice_activity_detection.py +++ b/pyannote/audio/pipelines/voice_activity_detection.py @@ -25,9 +25,16 @@ import tempfile from copy import deepcopy from types import MethodType -from typing import Optional, Union, Callable +from typing import Callable, Optional, Text, Union import numpy as np +from pyannote.core import Annotation, SlidingWindowFeature +from pyannote.database.protocol import SpeakerDiarizationProtocol +from pyannote.metrics.detection import ( + DetectionErrorRate, + DetectionPrecisionRecallFMeasure, +) +from pyannote.pipeline.parameter import Categorical, Integer, LogUniform, Uniform from pytorch_lightning import Trainer from torch.optim import SGD from torch_audiomentations.core.transforms_interface import BaseWaveformTransform @@ -47,13 +54,6 @@ from pyannote.audio.pipelines.utils import ( ) from pyannote.audio.tasks import VoiceActivityDetection as VoiceActivityDetectionTask from pyannote.audio.utils.signal import Binarize -from pyannote.core import Annotation, SlidingWindowFeature -from pyannote.database.protocol import SpeakerDiarizationProtocol -from pyannote.metrics.detection import ( - DetectionErrorRate, - DetectionPrecisionRecallFMeasure, -) -from pyannote.pipeline.parameter import Categorical, Integer, LogUniform, Uniform class OracleVoiceActivityDetection(Pipeline): @@ -90,6 +90,10 @@ class VoiceActivityDetection(Pipeline): fscore : bool, optional Optimize (precision/recall) fscore. Defaults to optimizing detection error rate. + use_auth_token : str, optional + When loading private huggingface.co models, set `use_auth_token` + to True or to a string containing your hugginface.co authentication + token that can be obtained by running `huggingface-cli login` inference_kwargs : dict, optional Keywords arguments passed to Inference. @@ -107,6 +111,7 @@ class VoiceActivityDetection(Pipeline): self, segmentation: PipelineModel = "pyannote/segmentation", fscore: bool = False, + use_auth_token: Union[Text, None] = None, **inference_kwargs, ): super().__init__() @@ -115,7 +120,7 @@ class VoiceActivityDetection(Pipeline): self.fscore = fscore # load model and send it to GPU (when available and not already on GPU) - model = get_model(segmentation) + model = get_model(segmentation, use_auth_token=use_auth_token) if model.device.type == "cpu": (segmentation_device,) = get_devices(needs=1) model.to(segmentation_device) diff --git a/tutorials/applying_a_model.ipynb b/tutorials/applying_a_model.ipynb index 3c10d82f..2319ab06 100644 --- a/tutorials/applying_a_model.ipynb +++ b/tutorials/applying_a_model.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -23,28 +23,28 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# clone pyannote-audio Github repository and update ROOT_DIR accordingly\n", - "ROOT_DIR = \"/Users/bredin/Development/pyannote/pyannote-audio\"\n", + "ROOT_DIR = \"/Users/hbredin/Development/pyannote/pyannote-audio\"\n", "AUDIO_FILE = f\"{ROOT_DIR}/tutorials/assets/sample.wav\"" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -67,18 +67,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['pyannote/TestModelForContinuousIntegration',\n", + "['pyannote/segmentation',\n", " 'pyannote/embedding',\n", - " 'pyannote/segmentation']" + " 'pyannote/TestModelForContinuousIntegration',\n", + " 'pyannote/Segmentation-PyanNet-DIHARD']" ] }, - "execution_count": 4, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -93,28 +94,43 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's load the speaker segmentation model..." + "To load the speaker segmentation model, \n", + "\n", + "* accept the user conditions on [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation).\n", + "* login using `notebook_login` below" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/Users/bredin/miniconda3/envs/pyannote/lib/python3.8/site-packages/pytorch_lightning/core/memory.py:16: LightningDeprecationWarning: `pytorch_lightning.core.memory.get_memory_profile` and `pytorch_lightning.core.memory.get_gpu_memory_map` have been moved to `pytorch_lightning.utilities.memory` since v1.5 and will be removed in v1.7.\n", - " rank_zero_deprecation(\n", - "/Users/bredin/miniconda3/envs/pyannote/lib/python3.8/site-packages/pytorch_lightning/core/memory.py:25: LightningDeprecationWarning: `pytorch_lightning.core.memory.LayerSummary` and `pytorch_lightning.core.memory.ModelSummary` have been moved to `pytorch_lightning.utilities.model_summary` since v1.5 and will be removed in v1.7.\n", - " rank_zero_deprecation(\n" + "Login successful\n", + "Your token has been saved to /Users/hbredin/.huggingface/token\n", + "\u001b[1m\u001b[31mAuthenticated through git-credential store but this isn't the helper defined on your machine.\n", + "You might have to re-authenticate when pushing to the Hugging Face Hub. Run the following command in your terminal in case you want to set this credential helper as the default\n", + "\n", + "git config --global credential.helper store\u001b[0m\n" ] } ], + "source": [ + "from huggingface_hub import notebook_login\n", + "notebook_login()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from pyannote.audio import Model\n", - "model = Model.from_pretrained(\"pyannote/segmentation\")" + "model = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)" ] }, { @@ -126,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -137,16 +153,16 @@ "0 | sincnet | SincNet | 42.6 K | [3, 1, 32000] | [3, 60, 115] \n", "1 | lstm | LSTM | 1.4 M | [3, 115, 60] | [[3, 115, 256], [[8, 3, 128], [8, 3, 128]]]\n", "2 | linear | ModuleList | 49.4 K | ? | ? \n", - "3 | classifier | Linear | 516 | [3, 115, 128] | [3, 115, 4] \n", - "4 | activation | Sigmoid | 0 | [3, 115, 4] | [3, 115, 4] \n", + "3 | classifier | Linear | 387 | [3, 115, 128] | [3, 115, 3] \n", + "4 | activation | Sigmoid | 0 | [3, 115, 3] | [3, 115, 3] \n", "--------------------------------------------------------------------------------------------------------\n", "1.5 M Trainable params\n", "0 Non-trainable params\n", "1.5 M Total params\n", - "5.892 Total estimated model params size (MB)" + "5.891 Total estimated model params size (MB)" ] }, - "execution_count": 6, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -164,16 +180,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Specifications(problem=, resolution=, duration=5.0, warm_up=(0.0, 0.0), classes=['speaker#1', 'speaker#2', 'speaker#3', 'speaker#4'], permutation_invariant=True)" + "Specifications(problem=, resolution=, duration=5.0, warm_up=(0.0, 0.0), classes=['speaker#1', 'speaker#2', 'speaker#3'], permutation_invariant=True)" ] }, - "execution_count": 7, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -190,7 +206,7 @@ "... which can be understood like that:\n", "\n", "* `duration = 5.0`: the model ingests 5s-long audio chunks\n", - "* `Resolution.FRAME` and `len(classes) == 4`: the model output a sequence of frame-wise 4-dimensoinal scores\n", + "* `Resolution.FRAME` and `len(classes) == 3`: the model output a sequence of frame-wise 3-dimensoinal scores\n", "* `Problem.MULTI_LABEL_CLASSIFICATION` for each frame, more than one speaker can be active at once" ] }, @@ -203,17 +219,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -229,21 +245,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For each of the 11 positions of the 5s window, the model outputs a 4-dimensional vector every 16ms (293 frames for 5 seconds), corresponding to the probabilities that each of (up to) 4 speakers is active. " + "For each of the 11 positions of the 5s window, the model outputs a 3-dimensional vector every 16ms (293 frames for 5 seconds), corresponding to the probabilities that each of (up to) 3 speakers is active. " ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(11, 293, 4)" + "(11, 293, 3)" ] }, - "execution_count": 9, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -263,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -289,17 +305,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -320,17 +336,17 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAAEiCAYAAAB6P56CAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3deXRc9X338c/v3tm0Wqs3WVh4BYxZgjFLSEgIDVtJCiEkzemTJqek6ZK0edJAk+c0DVlo0pzkSVqeNH2gcJ4sbWkCIYWWFAiQUBI2mbB4wcYbXiTbkka7NNu9v+ePGcmSLdsaaUajK71f58yZO/f+7u/3HfnHIH/8u3eMtVYAAAAAAAAIBqfUBQAAAAAAAGDyCHMAAAAAAAAChDAHAAAAAAAgQAhzAAAAAAAAAoQwBwAAAAAAIEAIcwAAAAAAAAIklE/jhoYG29LSUqRSAAAAAAAA5p9NmzZ1WmsbJ9s+rzCnpaVFra2t+VcFAAAAAACACRlj3synPZdZAQAAAAAABAhhDgAAAAAAQIAQ5gAAAAAAAAQIYQ4AAAAAAECAEOYAAAAAAAAECGEOAAAAAABAgBDmAAAAAAAABEio1AUAAGaWTaXkp9KSJKe8TMY5da5vrZWslXxfsva41yP7nLIyGddVIpPQQHpAleFKRd2oMn5Gh4YOKeWllPASSmaS8qwna618+bK580e3ZceNb2SObhsz8f4x2+M38zt3bJsT1XDSvk6wf1LnTqafE723WVzD2GNGRo7jyJEjxzhyHVdhJ6yqcJWUTMqm09lHxhs3ljFGchyZaFRONCqFQuPGsNbKplKyyaSs58mtrpZx3QnfOwAAQNAR5gDAPLP7Pe9Vau/e0demvFxGucDG9yXfP7o9EtpMUn9tVI+f7+iZFSlVD1mt22d1yQ5Hjm/14EXS0+uN7AnCEsxfi+NWX3jAVX1navInOY5MLCYTCo2GOGPnanT1Kq14+OEiVAsAAFB6hDkAMM/UffSj8gcGJFn5g0Pyh4ayfwl2XRnHSMZIjisZ5VbtjOzLPo/uc5zcISMZR12DHTr04P/TjU9KNz6ZHcsa6ciaWoUTnv70P7v1kf7zNPDJDylSV6+Qk11ZYWTkmOwqDUlyjDNuhcfYVTrjtk8QMp2ozWT2j+vnJG0m1Zc9QfsC1XHC/QWqYVL9TObcCdr51pdvfXnWk+/7WvR3P9aC+Bbd93ZHibCUcSXfkU5fcLquablGDWX12XMzXi64SchPJLOrcNLp7GqdWFQmGpOJRmQcV055mQAAAOYqwhwAmGdqP3BzUfp9+o0H9dcLQvrpJfeo7jd7FV6yWLH163VWba2s76vrn+6Rvv1tVW16Q813/V+VX3BBUepAcPjDw+r8x/+rrl9uU/SG9+jyj1+lqBuVJG3u3KzvbfmefuD/P33zsm/q7cveXuJqAQAAZg9zon/ZnMiGDRtsa2trEcsBAATVl5/9sn6252d65nefGV1lc6zkzp3a/4cfl1NZqdN/8oBMiH9TmK/8wUHtef/NSu3erQU3vU+LP/c5ORUV49p0DHXoT5/4U+3r36eHfuchLSxfWKJqAQAAissYs8lau2Gy7fk2KwBAQezs2anVtatPGORIUnTVKi287TYld+xQz/33z2B1mG06/v7vldqzR8v+4Tta+pWvHBfkSFJjeaO+efk3lcwkde/me0tQJQAAwOxEmAMAKIi9fXvVsqDllO2qrnq3yjdsUMed/0fewGDxC8Osk25vV/xf/lU1N71PVVdccdK2zdXNuur0q/TQroeU9tIzVCEAAMDsRpgDAJi2vlSf4om4WqpbTtnWGKPGv/i0vK4u9T38UPGLw6zT8+MfS5mMGv7ojybV/rrTr1N/ql+/bvt1kSsDAAAIBsIcAMC07e3dK0mTCnMkqey88xRdu1Y9P/1p8YrCrNX36GOquORihZuaJtX+4iUXqyxUpmfbny1yZQAAAMFAmAMAmLa2wTZJUlPV5P5yboxR1ZVXKvHqa1xqNc94A4NK7d6tsjy+zSzshnVe43l68dCLRawMAAAgOAhzAADT1jnUKUlqLGuc9Dll554jWavE5s3FKguzUGLLFslala1fn9d5GxZv0I7uHepJ9BSpMgAAgOAgzAEATFvncKdCTkg10ZpJnxPL/WV++NVXi1UWZqHk9tclSbGzzsrrvAsXXyhJ2nR4U8FrAgAACBrCHADAtHUMd6ihrEHGmEmfE6qtVWjhQqV27y5iZZht0m3tMrGY3Pr6vM47u/5sxdyYXjj0QpEqAwAACA7CHADAtHUOd+Z1idWI8GnNSh3YX4SKMFulDx1SePHivII/KXvfnHMXnquXjrxUpMoAAACCgzAHADBtIytz8hVZ1qz0/gNFqAizVbq9TeGlS6Z07gWLLtD2+Hb1pfoKXBUAAECwEOYAAKatc2jqK3Myhw/LTySKUBVmo0z7IYUWTy3M2bBog6ysXj7ycoGrAgAACBbCHADAtKS9tLqT3Woon8LKnObmbB8HDxa6LMxCNp1WpqND4cWLp3T++ob1CjkhtR5uLXBlAAAAwUKYAwCYlq5El6T8vpZ8xEiYk9q3r6A1YXbKxLslaxVamP9ckaRYKKb1Dev5RisAADDvEeYAAKalY6hD0tTCnPDIyhzumzMveN1xSZJbWzflPjYu3qjNnZvVOdxZqLIAAAAChzAHADAtHcPZMGcql1m5dXVyysuV2s83Ws0Hma7sKq5Q/dTDnGtXXCvf+npk9yOFKgsAACBwCHMAANMyskKiIZZ/mGOMUbi5WWnCnHnBi3dLyoZ4U7ViwQqdXX+2Ht79cKHKAgAACBzCHADAtHQMd8jIqL6sfkrnR05rVuoAYc58cPQyq9pp9XP9yuv1evx1bevaVoiyAAAAAocwBwAwLZ3DnaqN1SrkhKZ0fnhZs9L7D8j6foErw2yTiccl15W7YMG0+rluxXUqC5Xph9t+WKDKAAAAgoUwBwAwLZ1DnVO6+fGIcPMy2WRSmQ5uaDvXefFuuTU1Ms70fv1YEF2gG1bdoEf2PKIjQ0cKVB0AAEBwEOYAAKalY7hjSjc/HhFpPk2SlN7P15PPdV53XKG66V1iNeL3zvo9eb6nf339XwvSHwAAQJAQ5gAApqVjuGNaK3MizcskSal93DdnrsvEu6f1teRjNVc1612nvUs/2v4jDaWHCtInAABAUBDmAACmzLe+4sPx6V1m1dQkEw4ruWtnASvDbOTF49P6JqtjfXjdh9WX6tNDux4qWJ8AAABBQJgDAJiy7kS3MjajhrKpX2ZlwmFFV69WchvfTDTXefHCXWYlSec1nqdzGs/R3a/drcH0YMH6BQAAmO2m9tUjAAAoe4mVJDWWT31ljiRFzzpTAz9/QtZaGWMKURpmGZtOy+vtlVs3ta+wn4gxRrduuFUf/tmH9YeP/6Gaq5rlGle3brhVjuOoOlJdsLEAAABmE1bmAACmrH2gXZK0pGLJtPqJnXmmvJ4eZQ4dKkRZmIW8nh5JklvAlTmSdN7C83THZXdoZ/dOPbXvKT206yG97d/epo/+10eV8TMFHQsAAGC2IMwBAExZ22CbpEKEOWdJkhJcajVnZeLdkqRQAe+ZM+L6ldfr6Q8+rWc++Iw+dMaHJEkfOuNDCjksQAYAAHMTYQ4AYMraB9oVdaOqi03vL+ixtWskY5TYSpgzV3ndcUkq2LdZHSvqRhV2w/rsxs/q8Zse1/vWvK8o4wAAAMwGhDkAgClrG2zTkool077PjVNRocjy5Ups3VqgyjDbePFsmFPIGyBPxBijxRWLizoGAABAqRHmAACmrH2gvWB/cS47/3wNb9ok6/sF6Q+zy8hlVoX8anIAAID5ijAHADAlGT+jnT07tapmVUH6K9+4UV5vr5JvvFGQ/jC7ePG4ZIzcmppSlwIAABB4hDkAgCnZ1bNLCS+hdQ3rCtJf+YUXSpKGXnixIP1hdsl0x+UuWCDjuqUuBQAAIPAIcwAAU7K5c7MkaV19YcKcyLImhZYu0dCLhDlzkRfv5hIrAACAAiHMAQBMyS/2/0KLyhdpefXygvVZceFGDb3wgqznFaxPzA5eV1dRvpYcAABgPiLMAQDkrTfZq2fantFVLVfJMYX7X0nlO98pr6dHg889V7A+MTtkulmZAwAAUCiEOQCAvD2570ll/IyuOf2agvZb+c53yKmuVs+P7y9ovyg9Lx6XW+SvJQcAAJgvCHMAAHl7dO+jWla5rGD3yxnhRKOq/cDN6n/sMSV37Spo3ygdP5mU192tUGNjqUsBAACYEwhzAAB5iSfieq79OV19+tUyxhS8/7qPfEROZaUOffFLstYWvH/MvEx7uyQpvLSpxJUAAADMDYQ5ADCPWGv16N5H9d8H/nvKffz8zZ/Ls56ubrm6gJUdFaqv18LP/IWGXnhBvQ88UJQxMLPSo2HO0hJXAgAAMDcQ5gDAPGKM0T++8o+6Z/M9U+7j0b2PqqW6RWtq1xSwsvFqbrpJ5Rs36vBXv6bUgQNFGwczI93WJkkKNxHmAAAAFAJhDgDMM1cuv1IvHX5JncOdeZ/bMdShFw+9qGtOv6Yol1iNMI6jpV/9G8kYHfrrvy7aOJgZ6YNtkjEKL1pU6lIAAADmBMIcAJhnrjztSllZ/WL/L/I+97E3H5OVLdolVmOFm5rU+MlPaPDXz/JV5QGX2LpV4eZmmXC41KUAAADMCYQ5ADDPrKldo2WVy/TzfT/P6zzf+vrx9h/rzLoztaJmRZGqG6/mAx9QeNkytd16mwaffXZGxkRh+UNDGnz2WVVefnmpSwEAAJgzCHMAYJ4xxujq06/Ws23Pant8+6TP+9H2H2lX7y59eN2Hi1jdeE4spqa/+7ac8nLtu+Vj6nnwpzM2Ngqj9+H/kE0mVXXllaUuBQAAYM4gzAGAeegj6z6iBZEFuuWxW/Tdl7+rw4OHJ2w3nBnW0wee1ief+KTueP4OvbXprbqm5ZoZrbVs3Tq1PPCAKi7aqPbPfU6HvvwVJbbv4GvLAyDT1aWO/3OnYueeo/KNF5a6HAAAgDnD5PPL8IYNG2xra2sRywEAzJTdvbv19Re/rl8d/JUkqamySevq16m+rF7xRFzb49u1r3+ffOurLlanm9ferFvW36KoGy1JvTaV0qGvflU9//YjyfcVPeMM1dx0kxZc/9tyFywoSU04sfShQ9p3yy1K7z+gln+7T7Ezzih1SQAAALOWMWaTtXbDpNsT5gDAPJMckCIVUu7bqPb37ddjbz6mLV1btLVrqwbSA6oMV2pN7RqdUXeGzm44W5csuURhd3bcvDbT2am+xx5T7/0PKLF1q0w0qqrf+i3FzjpL4WVNCjc1KdLUJGfBgqJ+4xYmlonH1fvQQ+r8h+9Knqdl3/mOKi6+qNRlAQAAzGqEOQCAk/K+c6mcvn3ya1fI1p4uVS2RopUy0SqZSKUUrcyGPaEyyQ1LbkRyo5KRlBqSUgNSolfKDMt4KSk9nHsMZQeIVkmRSskJjQZGxjhSKCaFY9l+IxVSeX32Ec6N44Qkmdw5uedThDHDW7ao5/771f/Iz+T19o475lRUKNzUpPCyZdnnpqUK1dZKbkjGdSTHzT67rozrZl+HXMlxcq9zz8Y52s5xpNxj9Bw399oZ02ai81z3uHBp9P/Bxz5PtC/3bE9xfKK+jm5O7pwJfzcYOZbOyB8clD84IK+nR6m9byq1d2/2sWeP0u3tkrUqv/hiLf78Xym6cuXxfUmS70t+5piHd3Tb+tl2Y+fDcfPDmeBY7hwnlJ2LAAAAAUCYAwA4qW999bOqHdylFnNYLeaQGk2PKkxy2v0mbUiSFDWZafc1Ed8aWUlWJvfIbmcZZVJG6UFXmcGQ0oOOMoOuMoOOvNy2zbBKp1hMyCpc5SlU5Slc7alsaVrhGm9cFjfypxaSJ1e+HFPcex7tDZ2ulr96uahjAAAAFEq+YU6omMUAAGaf5nd/Qj1DKb1hpe3WyreS73sKZYbkZIYV8QYV8Ybk+im5flqOTcv10zLylXbLlHIrlHIrlXaiyjgReU5EaTcma7L/S3H9lCLeoIz1sgNaSdZXyE8p5CcU8pOKeEOKZXpVlu5WyE/KtZlceyuT+0cGM7oGZWTfmP3WTnjcjAx4zHFZK5NIyyQy2RUmvs3VNbJtZXybXQwyZp+ssn2PbT/yGLdPMv6YY6N9HzOGtdJIAGWO/njGvh6zMW4z+/oEgdSx+4/te3SfmXicoz/JCcYc/8I6kg2HpIgrGw3JrymTLQ9PuJLq2H8vssaRb9zsQ7lnExqzffRh5RyN7MbMCTsS5dnsn7fJ/pCVzYaOxnzhyga1TPzTAgAACDzCHACYZ266YFmpSwAAAAAwDXw1OQAAAAAAQIAQ5gAAAAAAAAQIYQ4AAAAAAECAEOYAAAAAAAAECGEOAAAAAABAgBDmAAAAAAAABAhhDgAAAAAAQIAQ5gAAAAAAAASIsdZOvrEx/ZK2F68cYFZokNRZ6iKAImOeY65jjmM+YJ5jPmCeYz5okFRhrW2c7AmhPAfYbq3dkOc5QKAYY1qZ55jrmOeY65jjmA+Y55gPmOeYD3LzvCWfc7jMCgAAAAAAIEAIcwAAAAAAAAIk3zDnrqJUAcwuzHPMB8xzzHXMccwHzHPMB8xzzAd5z/O8boAMAAAAAACA0uIyKwAAAAAAgAAhzAEAAAAAAAgQwhwAAAAAAIAAIcwBAAAAAAAIEMIcAAAAAACAACHMAQAAAAAACBDCHAAAAAAAgAAhzAEAAAAAAAgQwhwAAAAAAIAACeXTuKGhwba0tBSpFAAAAAAAgPln06ZNndbaxsm2zyvMaWlpUWtra/5VAQAAAAAAYELGmDfzac9lVgAAAAAAAAFCmAMAAAAAABAghDkAAAAAAAABQpgDAAAAAAAQIIQ5AAAAAAAAAUKYAwAAAAAAECCEOQAAAAAAAAESKnUBAADMZdZa7bryt2R9X/I8ydpSlzQ5rivjOJLrSo6RcVzJdXLPR48ZY8a/dh1ppK1xRo+5tbUKL1ksp6JCie071L61Val4p9oaXf3wHUaesXKs1FfhKBGRZMzRWswJq5y+af5x2Gl2MO3zpzmfpjv+WOc1nqe73n1XwfoDAAAnRpgDAEARGWNUvuGC8QHHrGdlvWz4ZK0veb6s7x3/7Ntsm1xQZTMZ2eSY1yPnehl5m7rlxeOSpFRlTHvqElJ1VOs2D+pvNo8fPR0La3BxteJrFur13zlX6croiSu1NhsoTYMpalo0ifFLXH+h3n9TVVNB+gEAAKdGmAMAQJEt/du/LXUJs4KfSKi7q01XPnGj3t3yHn3tbV9TYvMWJXfuzDYwktfVpXRbu1J79qjmyRe07nBEy3/4A5lwuLTFAwAAzCKEOQAAYEY4sZjecI4oYz3dsPoGGWNUtv5sla0/e8L2vQ//h9puvVV9jzyiBe997wxXCwAAMHsFYa03AACYI3Z2Z1fhrKpZdcq21b99nSIrVyr+z/9S7LIAAAAChTAHAADMmJ09O1UTrVF9rP6UbY0xqrnxRiVefVWp/ftnoDoAAIBgIMwBAAAzZm/fXq1YsGLSN/2tvvoqSVL/E08UsywAAIBAIcwBAAAzpnO4UwvLF066fbipSeGmJg2//EoRqwIAAAgWwhwAADBjOoY61FDWkNc5Zeeeo+FXCHMAAABGEOYAAIAZMZQe0lBmKO8wJ7b+HGXa25Xp6ipSZQAAAMFCmAMAAGZE13A2jMk3zImuWilJSu3dW+iSAAAAAokwBwAAzIjORKek/MOcyPLlkghzAAAARhDmAACAGdEx1CEp/zAnvHSpFA4T5gAAAOQQ5gAAgBnRneiWJNXF6vI6z4RCijQ3E+YAAADkEOYAAIAZ0ZvqlSQtiC7I+9xw8zKlDhwsdEkAAACBRJgDAABmRG+yV2WhMkXcSN7nRpqalD5ImAMAACAR5gAAgBnSm+yd0qocSQo3Ncnv65PX11fgqgAAAIKHMAcAAMyI3lSvFkSmGuYskySl29oKWRIAAEAgEeYAAIAZMd2VOZK41AoAAECEOQAAYIZMK8xZRpgDAAAwgjAHAADMiOmEOW5NjUx5OWEOAACACHMAAMAMsNZO6545xhhFmpYqRZgDAABAmAMAAIpvODOsjJ+Z8socSQovbVL6IDdABgAAIMwBAABF15vslaTphTlNTUofOCBrbaHKAgAACCTCHAAAUHS9qVyYM8XLrCQpsvw0+f398rq7C1UWAABAIBHmAACAoivEypzI6adLklJ79hSkJgAAgKAizAEAAEVXkDBnxQpJUnL37oLUBAAAEFSEOQAAoOhGL7Oazj1zliyRiUSU2s3KHAAAML8R5gAAgKIbWZlTHamech/GdRVds0aJ114rVFkAAACBRJgDAACKri/Zp5gbUywUm1Y/5Rs3aviVV+QnEgWqDAAAIHgIcwAAQNH1pnpVHZ36qpwR5RsvlE2nNfzSSwWoCgAAIJgIcwAAQNF1J7pVE62Zdj8VF10kE4up/8mnClAVAABAMBHmAACAoosn4qqN1U67H6esTBWXXqr+J5+QtbYAlQEAAAQPYQ4AACi67kS36qJ1Bemr6l1XKNPWruS2bQXpDwAAIGgIcwAAQNF1J7oLsjJHkirf+U7JcdT/xJMF6Q8AACBoCHMAAEBRpb20+tP9qolN/545khSqq1PZ+eer/4knCtIfAABA0BDmAACAoupOdktSwS6zkqSqK65Q8vXXldq3r2B9AgAABAVhDgAAKKruRDbMKdRlVpJUfe01kjHq/em/F6xPAACAoCDMAQAARRVPxCUVNswJL1miire+VT0PPijreQXrFwAAIAgIcwAAQFF1DndKkhrKGgrab837blSmvV2Dzz1X0H4BAABmO8IcAABQVCNhzsLyhQXtt/Jd75K7YIF6H/hJQfsFAACY7QhzAABAUR0ZOqLyULkqwhUF7deJRFR9/fXq//nP5fX1FbRvAACA2YwwBwAAFFXHcEfBV+WMWHD9b8umUup/4smi9A8AADAbEeYAAICi6hjqUGN5Y1H6jp1zjsJNTer72SNF6R8AAGA2IswBAABFdWToiBrLihPmGGNUfc3VGvz1s8p0dxdlDAAAgNmGMAcAABRNd6JbBwcOqqW6pWhjVF93nZTJKH7vvUUbAwAAYDYhzAEAAEXz67Zfy8rqsqbLijZG7MwzVfP+m9R19z+p+777ijYOAADAbBEqdQEAAGBuSvtpfW/L97SofJHWNawr6liLPv95ZTo6dej2Lyp9sE2Nf/5nMiF+zQEAAHMTK3MAACiyH2z9gV7teFUpL1XqUmZMxs/os09/Vtvi23TbhbfJMcX9lcOJRNT093+nmptvVtfdd2vfRz6q9OEjRR0TAACgVPgnKwAAiqg70a07f3OnhjPDqghX6PJll+vyZZdr45KNqo/VyxhT6hILylqr1sOt+vZL39arHa/qMxs+o3e3vHtGxnYiES350hdVvuECtX/hdu2+9lrVf+xjqvvw/5BTXj4jNQAAAMwEY62ddOMNGzbY1tbWIpYDAMDc05vs1a8O/krPH3peT+57Uj3JHklSWahMSyuWamnl0cfC8oVaVL5IC8sXqixUpqgbVcSNKOJE5Dpuid/JUWkvrfbBdh3oP6ADA7lH/wFt7tys9sF2NZQ16NYNt+raFdeWpL7knj068o1vauCJJ2SiUZVf8BZFVq1SeOlSOWXlcsrL5JSVyZSVjXvtlJfLxGIykYhMOCzjsIgZAAAUnzFmk7V2w6TbE+YAAFBcL/3dB3JbRp6kPe6wdoWG1emk1Omkc4+Uhox30n6MlVwZuTIKWTO6PfLa0cSrfCa79sdK8mXlS/KNlSc7un9ka2R7wGRkx3Qcskb1fkRNfkzrM9W6OF2nSJ5Xc1uZSdc6Wc6hfoV3xOW298vpSchk/PxqcozkGlnXkUKObMSVwrn3ZUz2ZzCyuurY7Vybsdt5tS+Eyf+ad4p+Tt2Rt2Spzr/rxwUaEACA+SXfMIfLrAAAKLJF3S/JyOYeUrOs3i6Nvh45NmikrpCjTlfqChmljFHSSCljlDJSxhhlJGWMlJHJPo/Z708QAhz9K7iZYN/4do4k11q5klybfT2aMUhyrJVygUuNZ7Uk42tJxtfStK96z07rRnymYKnDMcKS1mUf1ko2LdmMkc2MefbGv5YnWd/IepL87LY8yXqSTefaWjOSfmXZ8c/WTrz/6HFzkmOF/REU7Eq+U/STyiQKNBAAADgVwhwAAIqs6fY3JtWuQdLy4pYCAACAOYALwQEAAAAAAAKEMAcAAAAAACBACHMAAAAAAAAChDAHAAAAAAAgQAhzAAAAAAAAAoQwBwAAAAAAIEAIcwAAAAAAAAKEMAcAAAAAACBAjLV28o2N6Ze0vXjlALNCg6TOUhcBFBFzHPMB8xzzAfMc8wHzHPNBg6QKa23jZE8I5TnAdmvthjzPAQLFGNPKPMdcxhzHfMA8x3zAPMd8wDzHfJCb5y35nMNlVgAAAAAAAAFCmAMAAAAAABAg+YY5dxWlCmB2YZ5jrmOOYz5gnmM+YJ5jPmCeYz7Ie57ndQNkAAAAAAAAlBaXWQEAAAAAAAQIYQ4AAAAAAECAEOYAAAAAAAAECGEOAAAAAABAgBDmAAAAAAAABAhhDgAAAAAAQIAQ5gAAAAAAAAQIYQ4AAAAAAECAEOYAAAAAAAAESCifxg0NDbalpaVIpQAAAAAAAMw/mzZt6rTWNk62fV5hTktLi1pbW/OvCgAAAAAAABMyxryZT3suswIAAAAAAAgQwhwAAAAAAIAAIcwBAAAAAAAIEMIcAAAAAACAACHMAQAAAAAACBDCHAAAAAAAgAAhzAEAAAAAAAiQUKkLAAAAKKSkl9TfPP83pS4jL0Zm/Gtjjjs2+myOaTvm3JFjx7Y9tv8J207Q/+h5RpNve4paRvbVx+p145obFXbCx9U2whsY1PBvfiOvp0eZrk55XV2yqZSsbyXfl/U9aWTb+mPGMdLIeMZk6zdm/LHRx5hzRtsfc+y480bf5AR9jtk/Yb8n7tOMrXmiPh1XZeefr9jaNSf8mQEA5gfCHAAAMKd4vqdnDj5T6jImz4482XHPkmTt8ftOtH/0/GOPHdP/Sdse0//J2h7b/0THTtT/iJ6+ygoAABQnSURBVG3xbbr90tsnPGY9T3vf/36l9uw5ujMclhOJSK6bDT4cR3IcGcc5Gt5YO742a497WE2wf/TcSZxzbJsZVvvh/6FFn/vcccEeAGD+IMwBAABzSnm4XE+8/4lSl4FT+OKzX9TDux7WZzZ8RpWRyuOOD73wglJ79qjhE59Q9bXXKlRfJ6e6esIAw+YCHMeU7g4CdoIASKNhliYOiGzu6ESh0gShkZ9IKn7vver+/g+UOXxEtb/7QVVcfHEJ3i0AoNQIcwAAADDj3rPyPbp/x/36VduvdFXLVccdH/jFL2ViMdXf8gdyYrET9vPvO/9d39r0LfWn+rW0cqmWVy/XDatv0BXNV8zoypWjl05NcKyA4yz6/F/JqahQ1z33KFRfR5gDAPMUYQ4AAABm3NratZKkN/venPB4au9eRVpaThjkpLyU7nj+Dv3kjZ/o/IXn65yGc9Q22KYtnVv0qac+pbcsfIs+u/GzOrP+zKK9h1IwxmjhX3xaDZ/8hOzwcKnLAQCUCGEOAAAAZlx5uFyNZY3a17dvwuOp/fsVXbliwmNpL63/+Yv/qacPPK2Prf+Y/uS8P1HIyf5a6/meHtz5oO78zZ364H9+UF+45Au6cfWNRXsfpeJEIlIkUuoyAAAlwleTAwAAoCSaq5q1v3//cfut7yt94IDCzadNeN6XnvuSnj7wtD5/8ef1Z2/5s9EgR5Jcx9VNa27Swzc8rIsWX6SvPPcVHeg/ULT3AABAKRDmAAAAoCROFOZkDh+WTaUUOa35uGOP7H5EP935U31s/cd089qbT9h3daRaX37rl2VkdO/mewtaNwAApUaYAwAAgJJYVrVMHcMdSnrJcfszhw9LksJLlozbf6D/gL783Jd1XuN5+pPz/uSU/S+qWKRrV1yr/9z9nxpKDxWucAAASowwBwAAACWxuGKxJOnw4OFx+zM9PZIkt7Z23P5vtH5DvvX1tbd/bdylVSfz3pXv1VBmSE8ffLoAFQMAMDsQ5gAAAKAkllRkV94cGjw0br/XnQtzampG97UPtOuJfU/o99f9vpoqmyY9xrkLz1XUjeq1jtcKUDEAALMDYQ4AAABKYmRlTvtg+7j93gQrc17rzIYxb1/29rzGCDthra1bq82dm6dTKgAAswphDgAAAEpiUfkiSROszOnpkUIhOZWVo/u2dm1VyAlpTe2avMc5u/5sbYtvk2/96RUMAMAsQZgDAACAkoiFYqqL1R2/Mqe7W+6CBTLGjO7b2rVVq2tWK+JG8h5nbd1aDWeG+YpyAMCcQZgDAACAkmmpbtHu3t3j9nk9PXJrj94vx1qrrfGtOqv+rCmNsbpmtSTpje43pl4oAACzCGEOAAAASmZVzSrt7Nkpa+3oPq+nZ9zNjw8OHFRvsnfKYc7KmpUyMtrRs2Pa9QIAMBsQ5gAAAKBkVtasVH+qX0eGjozu87rjCo25+fHWrq2SNOUwpzxcrpYFLXq149XpFQsAwCxBmAMAAICSWV2bvQRqV8+u0X2Zzi659fWjr7d2bVXIhEbbTsVFiy/SpsOblPJSUy8WAIBZgjAHAAAAJbOyZqUkaWfPTkmSTafl9fQo1NA42mZr11atrl2tqBud8jiXLr1Uw5lhvdLxyvQKBgBgFiDMAQAAQMnUxepUF6vTrt7sypxMvFuyVqGG7Mocz/emdfPjERcuvlAhE9Kv23497ZoBACg1whwAAACU1KqaVdrZnV2Zk+nskCSFGhokSQ/teki9yV5d1nTZtMaojFTqnMZzCHMAAHMCYQ4AAABKauQbrXzry+vqkiS59fVKZBL6zsvf0dn1Z+tdp71r2uNcuvRSbevapu5E97T7AgCglAhzAAAAUFJratdoKDOkgwMHlenolCSFGhv1z9v+WYeHDuvTGz4tY8y0x7lk6SWysnq+/flp9wUAQCkR5gAAAKCkRr6l6o3uN5Q5cliSNFgZ0j2v3aO3Nb1NFy6+sCDjrKtfp4pwhTYd3lSQ/gAAKBXCHAAAAJTUqppVMjLa0b1DqQMH5DY06Msvf10D6QF96oJPFWwc13G1tnatdnTvKFifAACUAmEOAAAASqo8XK5FFYu0r2+f0gcOKrO4To+/+bj++Nw/1praNQUda23dWm3v3i7f+gXtFwCAmUSYAwAAgJI7reo07evfp/T+/RpsrJIkXXHaFQUfZ23tWg2mB3Ww/2DB+wYAYKYQ5gAAAKDkmquadbBnn9KHDqmnLiJJWlq5tODjnFF3hiTp9e7XC943AAAzhTAHAAAAJddc1axoe1zyfbXXSVWRKlVFqgo+zsqalXKNq9fjhDkAgOAizAEAAEDJNVU1aUW7lSS9sdDT0orCr8qRpFgoptMXnK7t8e1F6R8AgJlAmAMAAICSa4g1aMUhKxuN6LXyeFEusRqxtm4tK3MAAIFGmAMAAICSayhrUFOXlGhu1J7BfVpdu7poY51Re4YODx1WT6KnaGMAAFBMhDkAAAAouYayBpUnreLhpHzra23t2qKNtaYu+3Xn27u51AoAEEyEOQAAACi5inCFylNGh9QrKXspVLGMfKPVtq5tRRsDAIBiIswBAABAyRljVJ5x1B/KqKGsQc1VzUUbqy5Wp6UVS7W5a3PRxgAAoJgIcwAAADArlCWl4Yj0zuZ3yjHF/TV1XcM6bencUtQxAAAoFsIcAAAAlJy1VrGUVV1dkz667qNFH+/shrN1YOCAOoc7iz4WAACFRpgDAACAkrOplIzn67fX3aTm6uJdYjVi4+KNkqQXD71Y9LEAACg0whwAAACUnD84KElyKipmZLwz685UVaRKz7Y9OyPjAQBQSIQ5AAAAKLmZDnNcx9VlTZfpqf1PKe2nZ2RMAAAKhTAHAAAAJecPDUmauTBHkq49/Vr1JHv0y/2/nLExAQAoBMIcAAAAlNxMr8yRpMuaLlNzVbPuevUuWWtnbFwAAKaLMAcAAAAlNxrmlJfP2JghJ6SPn/NxbYtv05P7n5yxcQEAmC7CHAAAAJRcKVbmSNJ1K65TS3WLvrXpW0p5qRkdGwCAqSLMAQAAQMllurokSW5tzYyOG3JC+suNf6k3+97U97d+f0bHBgBgqghzAAAAUHLpg20ykYhCDQ0zPvZlTZfpiuYrdNerd+nQ4KEZHx8AgHwR5gAAAKDk0m1tCi9dKuOU5tfT2zbeJt/6+kbrN0oyPgAA+SDMAQAAc4q1Vof/9usa3rKl1KUgD+mDBxVuairZ+E2VTbpl/S16dO+juu/1+0pWBwAAk0GYAwAA5pRMW5t6H3xQe993kw7eepv6f/ELZbq7S10WTmFkZU4p/cH6P9BlTZfpjufv0G2/vE1tA20lrQcAgBMJlboAAACAQgo3NWnlY4+q6+5/Uvz731ffww9LkkKLFim6Zo2iq1cruma1oqtXK3LaaXJiMSkUkjGmxJXPX0MvvSSvq0vRM88oaR1hJ6w7r7hTd792t+5+9W499uZjWl69XCsWrNCKmhVauWClVtas1PLq5YqFYiWtFQAwvxlr7aQbb9iwwba2thaxHAAAgMLxh4Y0vHmzEq++qsSOHUq+sVOpnTtl0+nxDV1X4WVNiixfrlBtndy6Orl1tQrV1cmtrVOorlZuba3cujo5lZUEP6dgPU+Zw4eVPnhQqYMH5XV2KtPRKT+RkFNZIScalYlE5A8MKLlrt4ZaW2XCYa36+eNyystLXb4k6dDgIT3wxgPaEd+h3b27ta9/n3zrS5KMjJZULFHEjUiSYqGYaqO1qo3Vqi5WpwXRBYq4EYVMSI5xFE/E1TbYps2dm9Wf6h8dY+T3cNdxVRWp0uLyxaoIVygWimUfbkzl4XJVhitVEa5QVaRKq2pWKepG1Xq4VYvLF+vSpktn/ocDACg4Y8wma+2GSbcnzAEAAHNJJp3SG8/85OiO0eAl9+z5Ukdctu2w1NUjZTwpmZIOd0nxHql/SBoYlEmlj+tbkmzIlSorpKqK7HMsIoXDUigkRcJSOCS5ruQ6uWc3W8NIHcZIRrlAKLutMdtWZrSNjJExTq70sW2PeT62L2slK8laWWWfs8X7o/slSb6VZCd4nWtjs6+NP3K+zbZJJqXEyCMxZjspDSekvv7sz3msWDT7c0okpHQmu891pcWNUtNi6forpWVLTv6Hm8fvrdk3MXnmFO3TfkZt6U4dTB3RgeQRHUp3yVP2PSb9lPq8IfV5g+rzBjVsk8f0bVQXqtKKaJNq3KpcbWZkRsqTpwFvWPFMnxI2paSfVtKmlfRTStq07Alqu7LhMn3ruu/m9T4BALNTvmEOl1kBAIA5JTE8qDN/+fHJNQ7nHmWSasYf8jNGmYQjL5l9ZJJjthN98pKuvCOOfM/Ieka+J9nctrVG1pdk81/BU+g1P0VZQ+RYuSErJ+TLCVs5ISsn7Gefa6xCiz2FKz2FKzxFKjIKlWWPjeV7uRzK2Z/dseURaZbfs3r9JNulJaWNkSfJM0ZVvi9XkrQ57zF9SQljNOA46nYcvREJK2WM1idTivf05t0fAGBuIMwBAABzSqysUq9d91DuVTZAMKMrOo5Z4XDcfjvx/pOtCBlzbGwrIyv5fm6FypjVLsqtbrHH9D2y6mWkrWyueXY1jdExq2rGrLaxvmTMmDFGV+vYMat2jlnZ44xZzSOTe62j7Z1jVgC5ztF+Qq68E/9ElG+EZPNpn9clbnlGWXn0nVfN+TpJHaflnoclLW44xUomAMCcRZgDAADmlFA4rPUXXl7qMgAAAIqGryYHAAAAAAAIEMIcAAAAAACAACHMAQAAAAAACBDCHAAAAAAAgAAhzAEAAAAAAAgQwhwAAAAAAIAAIcwBAAAAAAAIEMIcAAAAAACAADHW2sk3NqZf0vbilQPMCg2SOktdBFBkzHPMdcxxzAfMc8wHzHPMBw2SKqy1jZM9IZTnANuttRvyPAcIFGNMK/Mccx3zHHMdcxzzAfMc8wHzHPNBbp635HMOl1kBAAAAAAAECGEOAAAAAABAgOQb5txVlCqA2YV5jvmAeY65jjmO+YB5jvmAeY75IO95ntcNkAEAAAAAAFBaXGYFAAAAAAAQIJMOc4wxVxtjthtjdhpjPlvMooBSMMbsNca8Zox52RjTWup6gEIwxtxrjDlijNk8Zl+dMeZxY8wbuefaUtYITNcJ5vntxpiDuc/0l40x15ayRmC6jDHNxpinjDFbjTFbjDF/ntvPZzrmhJPMcT7PMWcYY2LGmBeMMa/k5vkXc/tPN8Y8n8tb/s0YEzllX5O5zMoY40raIem3JB2Q9KKk37XWbp3eWwFmD2PMXkkbrLWdpa4FKBRjzNslDUj6vrX27Ny+r0uKW2u/lgvna621f1nKOoHpOME8v13SgLX2G6WsDSgUY8wSSUustS8ZY6okbZL0O5I+Ij7TMQecZI7fLD7PMUcYY4ykCmvtgDEmLOkZSX8u6dOSfmKtvc8Y84+SXrHWfvdkfU12Zc5GSTuttbuttSlJ90l679TfAgBgJlhrn5YUP2b3eyV9L7f9PWV/UQIC6wTzHJhTrLXt1tqXctv9krZJahKf6ZgjTjLHgTnDZg3kXoZzDyvpCkn35/ZP6rN8smFOk6T9Y14fEP9hYe6xkh4zxmwyxvxhqYsBimiRtbY9t31I0qJSFgMU0SeMMa/mLsPi0hPMGcaYFknnS3pefKZjDjpmjkt8nmMOMca4xpiXJR2R9LikXZJ6rLWZXJNJ5S3cABk46jJr7VskXSPpT3PL9oE5zWavteVrDTEXfVfSSknnSWqX9M3SlgMUhjGmUtIDkj5lre0be4zPdMwFE8xxPs8xp1hrPWvteZKWKXsV1BlT6WeyYc5BSc1jXi/L7QPmDGvtwdzzEUkPKvsfFjAXHc5dlz5yffqREtcDFJy19nDulyVf0t3iMx1zQO7+Cg9I+mdr7U9yu/lMx5wx0Rzn8xxzlbW2R9JTki6RVGOMCeUOTSpvmWyY86Kk1bk7LEckfVDSQ1OoF5iVjDEVuRutyRhTIendkjaf/CwgsB6S9Pu57d+X9O8lrAUoipG/3ObcID7TEXC5m2beI2mbtfZ/jznEZzrmhBPNcT7PMZcYYxqNMTW57TJlv2Rqm7Khzk25ZpP6LJ/Ut1nlBrpW0rcluZLutdbekX/pwOxkjFmh7GocSQpJ+hfmOOYCY8y/SnqHpAZJhyV9QdJPJf1I0mmS3pR0s7WWm8cisE4wz9+h7JJ8K2mvpI+Pua8IEDjGmMsk/bek1yT5ud3/S9l7ivCZjsA7yRz/XfF5jjnCGHOOsjc4dpVdXPMja+2Xcn8fvU9SnaTfSPo9a23ypH1NNswBAAAAAABA6XEDZAAAAAAAgAAhzAEAAAAAAAgQwhwAAAAAAIAAIcwBAAAAAAAIEMIcAAAAAACAACHMAQAAs54xpt4Y83LuccgYczC3PWCM+YdS1wcAADCT+GpyAAAQKMaY2yUNWGu/UepaAAAASoGVOQAAILCMMe8wxvxHbvt2Y8z3jDH/bYx50xhzozHm68aY14wx/2WMCefaXWCM+aUxZpMx5lFjzJLSvgsAAID8EOYAAIC5ZKWkKyS9R9IPJT1lrV0vaVjSdblA505JN1lrL5B0r6Q7SlUsAADAVIRKXQAAAEAB/cxamzbGvCbJlfRfuf2vSWqRtFbS2ZIeN8Yo16a9BHUCAABMGWEOAACYS5KSZK31jTFpe/TmgL6yv/cYSVustZeUqkAAAIDp4jIrAAAwn2yX1GiMuUSSjDFhY8y6EtcEAACQF8IcAAAwb1hrU5JukvS3xphXJL0s6dLSVgUAAJAfvpocAAAAAAAgQFiZAwAAAAAAECCEOQAAAAAAAAFCmAMAAAAAABAghDkAAAAAAAABQpgDAAAAAAAQIIQ5AAAAAAAAAUKYAwAAAAAAECCEOQAAAAAAAAHy/wFPzcqz/HzALAAAAABJRU5ErkJggg==", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -343,25 +359,10 @@ } ], "metadata": { - "interpreter": { - "hash": "41379f2c2a4eb17f5ac9a1f5014f4b793a0ead0b6469d8877f81a91eb030f53e" - }, "kernelspec": { - "display_name": "Python 3.8.2 64-bit ('pyannote': conda)", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.2" } }, "nbformat": 4, diff --git a/tutorials/applying_a_pipeline.ipynb b/tutorials/applying_a_pipeline.ipynb index e3e8b063..e436c732 100644 --- a/tutorials/applying_a_pipeline.ipynb +++ b/tutorials/applying_a_pipeline.ipynb @@ -24,18 +24,20 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['pyannote/overlapped-speech-detection',\n", - " 'pyannote/speaker-diarization',\n", - " 'pyannote/voice-activity-detection']" + "['pyannote/speaker-diarization',\n", + " 'pyannote/speaker-segmentation',\n", + " 'pyannote/voice-activity-detection',\n", + " 'pyannote/overlapped-speech-detection',\n", + " 'philschmid/pyannote-speaker-diarization-endpoint']" ] }, - "execution_count": 1, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -50,17 +52,43 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's load the speaker diarization pipeline..." + "To load the speaker diarization pipeline,\n", + "\n", + "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization).\n", + "* login using `notebook_login` below" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Login successful\n", + "Your token has been saved to /Users/hbredin/.huggingface/token\n", + "\u001b[1m\u001b[31mAuthenticated through git-credential store but this isn't the helper defined on your machine.\n", + "You might have to re-authenticate when pushing to the Hugging Face Hub. Run the following command in your terminal in case you want to set this credential helper as the default\n", + "\n", + "git config --global credential.helper store\u001b[0m\n" + ] + } + ], + "source": [ + "from huggingface_hub import notebook_login\n", + "notebook_login()" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from pyannote.audio import Pipeline\n", - "pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization\")" + "pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization@develop\", use_auth_token=True)" ] }, { @@ -82,11 +110,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "ROOT_DIR = \"/Users/bredin/Development/pyannote/pyannote-audio\"\n", + "ROOT_DIR = \"/Users/hbredin/Development/pyannote/pyannote-audio\"\n", "AUDIO_FILE = f\"{ROOT_DIR}/tutorials/assets/sample.wav\"\n", "dia = pipeline(AUDIO_FILE)" ] @@ -102,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -119,23 +147,21 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " 6.7 7.1 SPEAKER_01\n", - " 7.5 8.2 SPEAKER_00\n", - " 8.2 10.0 SPEAKER_01\n", - " 9.9 11.0 SPEAKER_00\n", - "10.6 14.7 SPEAKER_01\n", - "14.3 17.9 SPEAKER_00\n", - "18.0 21.5 SPEAKER_01\n", - "18.1 18.6 SPEAKER_00\n", - "21.7 28.5 SPEAKER_00\n", - "27.8 29.7 SPEAKER_01\n" + " 6.7 7.1 SPEAKER_02\n", + " 6.9 8.3 SPEAKER_00\n", + " 8.3 14.8 SPEAKER_02\n", + " 9.8 11.0 SPEAKER_00\n", + "14.3 18.5 SPEAKER_01\n", + "17.9 21.5 SPEAKER_02\n", + "21.7 28.6 SPEAKER_01\n", + "27.8 29.5 SPEAKER_02\n" ] } ], @@ -153,17 +179,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 6, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -184,17 +210,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -219,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -245,17 +271,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAACsCAYAAAAaLvvnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAMU0lEQVR4nO3dbaxlV1kH8P/jTBu1NCk4tWmgZhTJmFhMoRNIDWolapRqqaSBIiTlU/kABvGLRD8wmJAo1JcEAsaXJjW2tliwNBIr/dChaAwyA1OG0gxWM42Mpc2EEJmElJd5/HD3lMtkZnrOvXd67jrn90tu5px19tp7nclz1z73n732qe4OAAAAAOP4gUUPAAAAAID5CHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYzXKBTVX9QVY9U1Req6lBVvbKq9lfVkap6uKr+rar2TNueaj80/dwzte+rqmPr2g9V1SXTa6+oqoemfp+vqr+uqh+uqrdU1QdPG8v+qtr73P8vAAAAAKts56IHMI+quibJryd5eXc/XVW7klw4vfym7j5QVbckeX+S69e3n2F3f9bdt562/8uS/EOSm7r736e2G5NcfB7eDgAAAMCGjHaFzuVJjnf300nS3ce7+39P2+ahJD+5wf2/Lcntp8Kc6Rj3dPeTG9wfAAAAwJYbLdD5ZJIrqurLVfWhqvqFM2zzG0kOr3t+x7plVe9f1/7Ode0PTm1XJjl4juO/Yf0yrSSWWwEAAADPuU0tubr+3uv2JXn31gwlSfKe+274xL6zvdjdJ6rq6iQ/l+QXk9xdVe+aXr6jqr6Z5GiS317XbeYlVzO4u7vffupJVe2fsz8AAADApg11D50k6e7vJtmfZH9VHU5y8/TS2YKbeTyS5OokH9/kfgAAAADOm6GWXFXVnqp6ybqmq5I8voWH+GCSm6vqleuO+brpZskAAAAA28KmrtCZlkft25KRzOZ5ST4wfcX4d5I8luSWJPeco8+ppVjJ2g2Vf2l6/M6qevO67W7o7qNVdVOSW6vqR5OczNpNlu/f0ncBAAAAsAnV3YseAwAAAABzGGrJFQAAAAACHQAAAIDhCHQAAAAABiPQAQAAABiMQAcAAABgMHN9bfmuXbt69+7d52koAAAAAKvn4MGDx7v70nn6zBXo7N69OwcOHJhvVAAAAACcVVU9Pm8fS64AAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHeAZdz56x0L6bkV/AMZ1pnOA8wLJbHWgVoCRbWYOE+gAz7jryJ0L6bsV/QEY15nOAc4LJLPVgVoBRraZOUygAwAAADAYgQ4AAADAYHYuegDA9nL9vdet5LEB2H6cF5iVWgFWkSt0AAAAAAYj0AEAAAAYjCVXwPe574ZPbKjfVlzqvNFjAzC2s51DnBeY9fOFWgFGtZm/o1yhAwAAADAYgQ4AAADAYAQ6AAAAAIMR6ADPuGnPby2k71b0B2BcZzoHOC+QzFYHagUY2WbmsOrumTfeu3dvHzhwYMMHAwAAAOD7VdXB7t47Tx9X6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYKq7Z9+46htJjpy/4cC2sCvJ8UUPAs4zdc4qUOesAnXOKlDnrII93X3xPB12znmAI929d84+MJSqOqDOWXbqnFWgzlkF6pxVoM5ZBVV1YN4+llwBAAAADEagAwAAADCYeQOdvzwvo4DtRZ2zCtQ5q0CdswrUOatAnbMK5q7zuW6KDAAAAMDiWXIFAAAAMJiZAp2q+tWqOlJVj1XVu873oGARqupoVR2uqkMbucM4bFdVdVtVPVVVX1zX9oKqeqCq/nP69/mLHCNsxllqfF9VHZvm9ENV9ZpFjhE2q6quqKoHq+pLVfVIVb1jajefszTOUefmdJZGVf1gVf1HVT081fl7pvYfr6rPTLnL3VV14bPu69mWXFXVjiRfTvLLSb6S5LNJ3tjdX9r8W4Hto6qOJtnb3ccXPRbYSlX180lOJPnb7r5yantfkq919x9NQf3zu/v3FjlO2Kiz1Pi+JCe6+9ZFjg22SlVdnuTy7v5cVV2c5GCSG5K8JeZzlsQ56vz1MaezJKqqklzU3Seq6oIk/5rkHUl+N8nHuvuuqvqLJA9394fPta9ZrtB5RZLHuvu/u/tbSe5K8trNvQUAnivd/VCSr53W/Nokt0+Pb8/ahyUY0llqHJZKdz/R3Z+bHn8jyaNJXhjzOUvkHHUOS6PXnJieXjD9dJJXJ7lnap9pPp8l0Hlhkv9Z9/wr8UvFcuokn6yqg1V1y6IHA+fZZd39xPT4q0kuW+Rg4Dx5e1V9YVqSZRkKS6Oqdid5WZLPxHzOkjqtzhNzOkukqnZU1aEkTyV5IMl/Jfl6d39n2mSm3MVNkeF7XtXdL0/ya0neNl3CD0uv19be+spDls2Hk7w4yVVJnkjyJ4sdDmyNqnpeko8m+Z3u/r/1r5nPWRZnqHNzOkulu7/b3VcleVHWVkX91Eb2M0ugcyzJFeuev2hqg6XS3cemf59K8o9Z+8WCZfXktE791Hr1pxY8HthS3f3k9GHpZJK/ijmdJTDda+GjSe7o7o9NzeZzlsqZ6tyczrLq7q8neTDJNUkuqaqd00sz5S6zBDqfTfKS6Y7LFya5Kcl9GxwvbEtVddF047VU1UVJfiXJF8/dC4Z2X5Kbp8c3J/n4AscCW+7UH7iT34w5ncFNN9H8mySPdvefrnvJfM7SOFudm9NZJlV1aVVdMj3+oax9AdWjWQt2bpw2m2k+f9ZvuZoO8pokf55kR5Lbuvu9Gxs6bE9V9RNZuyonSXYmuVOdsyyq6u+TXJtkV5Ink7w7yb1JPpLkx5I8nuT13e2msgzpLDV+bdYuze8kR5O8dd19RmA4VfWqJJ9OcjjJyan597N2fxHzOUvhHHX+xpjTWRJV9TNZu+nxjqxdZPOR7v7D6W/Su5K8IMnnk7y5u58+575mCXQAAAAA2D7cFBkAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AYNurqh+pqkPTz1er6tj0+ERVfWjR4wMAeK752nIAYChVtS/Jie6+ddFjAQBYFFfoAADDqqprq+qfpsf7qur2qvp0VT1eVa+rqvdV1eGqur+qLpi2u7qqPlVVB6vqX6rq8sW+CwCA+Ql0AIBl8uIkr05yfZK/S/Jgd780yTeTXDeFOh9IcmN3X53ktiTvXdRgAQA2aueiBwAAsIX+ubu/XVWHk+xIcv/UfjjJ7iR7klyZ5IGqyrTNEwsYJwDApgh0AIBl8nSSdPfJqvp2f+9mgSez9rmnkjzS3dcsaoAAAFvBkisAYJUcSXJpVV2TJFV1QVX99ILHBAAwN4EOALAyuvtbSW5M8sdV9XCSQ0l+drGjAgCYn68tBwAAABiMK3QAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwfw/irrb9ZlMvS0AAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABi8AAADyCAYAAAA1MlYeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAXJElEQVR4nO3dfZDVdd3/8ddB4k52F1eEhWEh8oZQ1EYtxG4UGxAqg+RyKL28ICZGJq0YJ3WiUjJHiiabGiemchKdsR/Yr6TGDHMybkxtxOQn06Sp6YAJEiisgq135/eH416tmLpw1v3s7uMxszN7vufs93wOc+bDe/a555xKtVqtBgAAAAAAoBB9unoBAAAAAAAA/068AAAAAAAAiiJeAAAAAAAARREvAAAAAACAoogXAAAAAABAUcQLAAAAAACgKOIFAAAAAABQFPECAAAAAAAoingBAAAAAAAURbwAAAAAAACKIl4AAAAAAABFES8AAAAAAICiiBcAAAAAAEBRxAsAAAAAAKAo4gUAAAAAAFAU8QIAAAAAAChKr4wX27dvz/nnn5/Ro0enf//+aWpqyhlnnJG77747SfLud787lUollUolgwYNyoQJE/KjH/2o7eeXL1/edv2/fw0YMKDtNnPnzn3D20ybNq3dWu6///6cffbZGT58eAYMGJCjjjoq8+fPz9/+9rckyeOPP55KpZKNGzfu8zhOO+20LFy4sPb/QAAAAAAA0IX61vqEz+/+V61P+aYGNgx46xu9zqxZs/Liiy/m+uuvz3ve85489dRT+f3vf5+nn3667TZXXHFF5s+fn+eeey7Lly/PggULMmTIkMyePTtJUl9fn4ceeqjdeSuVSrvL06ZNy3XXXdfuWP/+/du+v+WWWzJr1qycccYZufHGG3P44Ydn+/bt+fnPf56vf/3rWblyZYcfGwAAAAAAdHc1jxc3/M//rfUp39T5v/rvDt1+165dufPOO7NmzZqceuqpSZIxY8bkAx/4QLvb1dXVpampKUly5ZVX5qabbsqqVava4kWlUmm7/j957VUdb2Tv3r357Gc/m4997GO5+eab246PHTs2EydOzK5duzr0uAAAAAAAoKfodW8bNXjw4AwePDirVq1Ka2vr2/65AQMG5MUXX6zZOm677bbs2LEjl1xyyRteP2TIkJrdFwAAAAAAdCe9Ll707ds3y5cvz/XXX58hQ4bkgx/8YBYtWpQHHnjgDW//0ksvZfny5dm0aVM++tGPth3fvXt3Wwh57Wvq1KntfvaWW27Z5zbf/OY3kyQPP/xwkuS9733v21r3Kaecss+51q9fvz//BAAAAAAAULSav21UdzBr1qx8/OMfz/r163P33Xdn9erVWbp0aa699trMnTs3SXLppZfma1/7WlpbW9OvX79cfPHFOf/889vOUVdXlz//+c/tzjtw4MB2lydPnpxly5a1O9bY2JgkqVarHVrzypUrM378+HbHzj333A6dAwAAAAAAuoOax4v/ueG/an3KTjFgwIBMmTIlU6ZMyWWXXZbPfe5zufzyy9vixcUXX5y5c+dm0KBBGTFixD4fxt2nT58cccQRb3ofBx988H+8zVFHHZUkefDBBzNp0qS3XG9zc/M+53p9LAEAAAAAgJ6g5vFiYMOAWp/yHXH00Udn1apVbZeHDh36lnHiQEydOjVDhw7N0qVL231g92t27drlcy8AAAAAAOiVet3bRu3cuTNnn3125s2bl+OOOy51dXXZsGFDli5dmhkzZrzt81Sr1Wzbtm2f48OGDUufPq9+lEhra+s+t+nbt2+GDh2agw8+ONdee23OPvvsfPKTn8wXv/jFHHHEEdmxY0duuummbN68OStWrDiwBwsAAAAAAN1Qr4sXgwcPzsSJE/O9730vjz76aF588cU0Nzdn/vz5WbRo0ds+T0tLS0aMGLHP8a1bt6apqSlJsnr16n1uM27cuDz44INJkhkzZuSuu+7KkiVLcs4556SlpSXNzc05/fTTc+WVVx7AowQAAAAAgO6rUu3oJ0cDAAAAAAB0oj5dvQAAAAAAAIB/J14AAAAAAABFES8AAAAAAICiiBcAAAAAAEBRxAsAAAAAAKAo4gUAAAAAAFCUvvv7g6+88kqefPLJ1NXVpVKp1HJNAAAAAABAN1OtVvPss89m5MiR6dPnwF47sd/x4sknn0xzc/MB3TkAAAAAANCzbNmyJaNGjTqgc+x3vKirq2tbRH19/QEtAgAAAAAA6N5aWlrS3Nzc1g8OxH7Hi9feKqq+vl68AAAAAAAAkqQmHzXhA7sBAAAAAICiiBcAAAAAAEBRxAsAAAAAAKAo4gUAAAAAAFAU8QIAAAAAACiKeAEAAAAAABRFvAAAAAAAAIoiXgAAAAAAAEURLwAAAAAAgKKIFwAAAAAAQFHECwAAAAAAoCjiBQAAAAAAUBTxAgAAAAAAKIp4AQAAAAAAFEW8AAAAAAAAiiJeAAAAAAAARREvAAAAAACAoogXAAAAAABAUcQLAAAAAACgKOIFAAAAAABQFPECAAAAAAAoingBAAAAAAAURbwAAAAAAACKIl4AAAAAAABFES8AAAAAAICiiBcAAAAAAEBRxAsAAAAAAKAo4gUAAAAAAFAU8QIAAAAAACiKeAEAAAAAABRFvAAAAAAAAIoiXgAAAAAAAEURLwAAAAAAgKKIFwAAAAAAQFHECwAAAAAAoCjiBQAAAAAAUBTxAgAAAAAAKIp4AQAAAAAAFEW8AAAAAAAAiiJeAAAAAAAARREvAAAAAACAoogXAAAAAABAUcQLAAAAAACgKOIFAAAAAABQFPECAAAAAAAoingBAAAAAAAURbwAAAAAAACKIl4AAAAAAABFES8AAAAAAICiiBcAAAAAAEBRxAsAAAAAAKAo4gUAAAAAAFAU8QIAAAAAACiKeAEAAAAAABRFvAAAAAAAAIoiXgAAAAAAAEURLwAAAAAAgKKIFwAAAAAAQFHECwAAAAAAoCjiBQAAAAAAUBTxAgAAAAAAKIp4AQAAAAAAFEW8AAAAAAAAiiJeAAAAAAAARREvAAAAAACAoogXAAAAAABAUcQLgELteXpvNvyf/5c9T+8t+pydeV4AoHd6s9nC3EFP0tHns+c/ACXqrP+fxAuAQu195vnct2JT9j7zfNHn7MzzAgC905vNFuYOepKOPp89/wEoUWf9/yReAAAAAAAARREvAAAAAACAoogXAAAAAABAUfp29QIAeHOtz72Q53f/q2bn6ky1XCsA0Hu9nZnF3EFPsL/zuec/ACXprN83iRcAhfvNZb/v6iW8bd1prQBA92buoDfz/AegN/C2UQAAAAAAQFHECwAAAAAAoCjiBQAAAAAAUBSfeQFQuI9f8dEc+u5DanKunY8/06nvj1vLtQIAvdfbmVnMHfQE+zufe/4DUJLO+n2TeAFQuP6D+2Vgw4Canasz1XKtAEDv9XZmFnMHPcH+zuee/wCUpLN+3+RtowAAAAAAgKKIFwAAAAAAQFHECwAAAAAAoCjiBUChBh0yMCd++tgMOmRg0efszPMCAL3Tm80W5g56ko4+nz3/AShRZ/3/VKlWq9X9+cGWlpY0NDRk9+7dqa+vr+miAAAAAACA7qWW3cArLwAAAAAAgKKIFwAAAAAAQFHECwAAAAAAoCjiBQAAAAAAUBTxAgAAAAAAKIp4AQAAAAAAFEW8AAAAAAAAiiJeAAAAAAAARREvAAAAAACAoogXAAAAAABAUcQLAAAAAACgKOIFAAAAAABQFPECAAAAAAAoingBAAAAAAAURbwAAAAAAACKIl4AAAAAAABFES8AAAAAAICiiBcAAAAAAEBRxAsAAAAAAKAo4gUAAAAAAFAU8QIAAAAAACiKeAEAAAAAABRFvAAAAAAAAIoiXgAAAAAAAEURLwAAAAAAgKKIFwAAAAAAQFHECwAAAAAAoCjiBQAAAAAAUBTxAgAAAAAAKIp4AQAAAAAAFEW8AAAAAAAAiiJeAAAAAAAARREvAAAAAACAoogXAAAAAABAUcQLAAAAAACgKOIFAAAAAABQFPECAAAAAAAoingBAAAAAAAURbwAAAAAAACKIl4AAAAAAABFES8AAAAAAICiiBcAAAAAAEBRxAsAAAAAAKAo4gUAAAAAAFAU8QIAAAAAACiKeAEAAAAAABRFvAAAAAAAAIoiXgAAAAAAAEURLwAAAAAAgKKIFwAAAAAAQFHECwAAAAAAoCjiBQAAAAAAUBTxAgAAAAAAKIp4AQAAAAAAFEW8AAAAAAAAiiJeAAAAAAAARREvAAAAAACAoogXAAAAAABAUcQLAAAAAACgKOIFAAAAAABQFPECAAAAAAAoingBAAAAAAAURbwAAAAAAACKIl4AAAAAAABFES8AAAAAAICiiBcAAAAAAEBRxAsAAAAAAKAofff3B6vVapKkpaWlZosBAAAAAAC6p9d6wWv94EDsd7zYuXNnkqS5ufmAFwEAAAAAAPQMO3fuTENDwwGdY7/jRWNjY5Jk8+bNB7wIoHtqaWlJc3NztmzZkvr6+q5eDtBF7AWAfQCwDwCJvQBIdu/endGjR7f1gwOx3/GiT59XPy6joaHBZgS9XH19vX0AsBcA9gHAPgAksRcA/9sPDugcNVgHAAAAAABAzYgXAAAAAABAUfY7XvTv3z+XX355+vfvX8v1AN2IfQBI7AWAfQCwDwCvshcAtdwHKtVqtVqDNQEAAAAAANSEt40CAAAAAACKIl4AAAAAAABFES8AAAAAAICiiBcAAAAAAEBR9ite/PCHP8zYsWMzYMCAnHjiiVm/fn2t1wUUbPHixalUKu2+mpqaunpZQCdat25dzjzzzIwcOTKVSiWrVq1qd321Ws3ixYszcuTIDBw4MKeddlr+8pe/dM1igU7zVnvB3Llz95kRTj755K5ZLFBzS5Ysyfvf//7U1dVl2LBhmTlzZh566KF2tzETQM/3dvYCMwH0bMuWLctxxx2X+vr61NfXZ9KkSfntb3/bdn2t5oEOx4uVK1dm4cKF+epXv5r7778/H/7whzN9+vRs3ry5w3cOdF/HHHNMtm7d2va1adOmrl4S0In27NmT448/Ptdcc80bXr906dJcffXVueaaa3LvvfemqakpU6ZMybPPPvsOrxToTG+1FyTJtGnT2s0It9566zu4QqAzrV27NhdccEHuueee3H777XnppZcyderU7Nmzp+02ZgLo+d7OXpCYCaAnGzVqVL71rW9lw4YN2bBhQ04//fTMmDGjLVDUah6oVKvVakd+YOLEiTnhhBOybNmytmPjx4/PzJkzs2TJkg7dOdA9LV68OKtWrcrGjRu7eilAF6hUKrn55pszc+bMJK/+RcXIkSOzcOHCXHrppUmS1tbWDB8+PN/+9rdz/vnnd+Fqgc7y+r0gefWvLHft2rXPKzKAnumf//xnhg0blrVr1+YjH/mImQB6qdfvBYmZAHqjxsbGfOc738m8efNqNg906JUXL7zwQu67775MnTq13fGpU6fmrrvu6sipgG7u4YcfzsiRIzN27Nh8+tOfzt///veuXhLQRR577LFs27at3XzQv3//nHrqqeYD6IXWrFmTYcOG5aijjsr8+fOzffv2rl4S0El2796d5NVfViRmAuitXr8XvMZMAL3Dyy+/nBUrVmTPnj2ZNGlSTeeBDsWLHTt25OWXX87w4cPbHR8+fHi2bdvWoTsGuq+JEyfmhhtuyG233Zaf/OQn2bZtW0455ZTs3Lmzq5cGdIHXZgDzATB9+vTceOONueOOO/Ld73439957b04//fS0trZ29dKAGqtWq7nooovyoQ99KBMmTEhiJoDe6I32gsRMAL3Bpk2bMnjw4PTv3z8LFizIzTffnKOPPrqm80Df/VlYpVJpd7lare5zDOi5pk+f3vb9sccem0mTJuXwww/P9ddfn4suuqgLVwZ0JfMBMHv27LbvJ0yYkJNOOiljxozJb37zm5x11llduDKg1i688MI88MADufPOO/e5zkwAvcd/2gvMBNDzjRs3Lhs3bsyuXbvyi1/8InPmzMnatWvbrq/FPNChV14MHTo0Bx100D6FZPv27fuUFKD3OPjgg3Psscfm4Ycf7uqlAF2gqakpScwHwD5GjBiRMWPGmBGgh/nCF76QX//61/nDH/6QUaNGtR03E0Dv8p/2gjdiJoCep1+/fjniiCNy0kknZcmSJTn++OPz/e9/v6bzQIfiRb9+/XLiiSfm9ttvb3f89ttvzymnnNKhOwZ6jtbW1vz1r3/NiBEjunopQBcYO3Zsmpqa2s0HL7zwQtauXWs+gF5u586d2bJlixkBeohqtZoLL7wwv/zlL3PHHXdk7Nix7a43E0Dv8FZ7wRsxE0DPV61W09raWtN5oMNvG3XRRRflvPPOy0knnZRJkyblxz/+cTZv3pwFCxZ09FRAN/XlL385Z555ZkaPHp3t27fnyiuvTEtLS+bMmdPVSwM6yXPPPZdHHnmk7fJjjz2WjRs3prGxMaNHj87ChQtz1VVX5cgjj8yRRx6Zq666KoMGDco555zThasGau3N9oLGxsYsXrw4s2bNyogRI/L4449n0aJFGTp0aD71qU914aqBWrngggvys5/9LL/61a9SV1fX9heVDQ0NGThwYCqVipkAeoG32guee+45MwH0cIsWLcr06dPT3NycZ599NitWrMiaNWuyevXqms4DHY4Xs2fPzs6dO3PFFVdk69atmTBhQm699daMGTOmo6cCuqknnngin/nMZ7Jjx44cdthhOfnkk3PPPffYB6AH27BhQyZPntx2+bXPt5kzZ06WL1+eSy65JM8//3w+//nP55lnnsnEiRPzu9/9LnV1dV21ZKATvNlesGzZsmzatCk33HBDdu3alREjRmTy5MlZuXKlvQB6iGXLliVJTjvttHbHr7vuusydOzdJzATQC7zVXnDQQQeZCaCHe+qpp3Leeedl69ataWhoyHHHHZfVq1dnypQpSWo3D1Sq1Wq1Mx4AAAAAAADA/ujQZ14AAAAAAAB0NvECAAAAAAAoingBAAAAAAAURbwAAAAAAACKIl4AAAAAAABFES8AAAAAAICiiBcAAAAAAEBRxAsAAOAtLV68OO973/u6ehkAAEAvUalWq9WuXgQAANB1KpXKm14/Z86cXHPNNWltbc2hhx76Dq0KAADozcQLAADo5bZt29b2/cqVK3PZZZfloYceajs2cODANDQ0dMXSAACAXsrbRgEAQC/X1NTU9tXQ0JBKpbLPsde/bdTcuXMzc+bMXHXVVRk+fHiGDBmSb3zjG3nppZdy8cUXp7GxMaNGjcpPf/rTdvf1j3/8I7Nnz84hhxySQw89NDNmzMjjjz/+zj5gAACgeOIFAACwX+644448+eSTWbduXa6++uosXrw4n/jEJ3LIIYfkT3/6UxYsWJAFCxZky5YtSZK9e/dm8uTJGTx4cNatW5c777wzgwcPzrRp0/LCCy908aMBAABKIl4AAAD7pbGxMT/4wQ8ybty4zJs3L+PGjcvevXuzaNGiHHnkkfnKV76Sfv365Y9//GOSZMWKFenTp0+uvfbaHHvssRk/fnyuu+66bN68OWvWrOnaBwMAABSlb1cvAAAA6J6OOeaY9Onzv38PNXz48EyYMKHt8kEHHZRDDz0027dvT5Lcd999eeSRR1JXV9fuPP/617/y6KOPvjOLBgAAugXxAgAA2C/vete72l2uVCpveOyVV15Jkrzyyis58cQTc+ONN+5zrsMOO6zzFgoAAHQ74gUAAPCOOOGEE7Jy5coMGzYs9fX1Xb0cAACgYD7zAgAAeEece+65GTp0aGbMmJH169fnsccey9q1a/OlL30pTzzxRFcvDwAAKIh4AQAAvCMGDRqUdevWZfTo0TnrrLMyfvz4zJs3L88//7xXYgAAAO1UqtVqtasXAQAAAAAA8BqvvAAAAAAAAIoiXgAAAAAAAEURLwAAAAAAgKKIFwAAAAAAQFHECwAAAAAAoCjiBQAAAAAAUBTxAgAAAAAAKIp4AQAAAAAAFEW8AAAAAAAAiiJeAAAAAAAARREvAAAAAACAoogXAAAAAABAUf4/or9ACDkjvhcAAAAASUVORK5CYII=\n", "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -267,25 +293,10 @@ } ], "metadata": { - "interpreter": { - "hash": "41379f2c2a4eb17f5ac9a1f5014f4b793a0ead0b6469d8877f81a91eb030f53e" - }, "kernelspec": { - "display_name": "Python 3.8.2 64-bit ('pyannote': conda)", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.2" } }, "nbformat": 4, diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index aaafe76d..26bba3af 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -1,2764 +1,4 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "Introduction to pyannote.audio speaker diarization toolkit", - "provenance": [], - "collapsed_sections": [ - "xD7QfHCHEIgE", - "CKsR0OZqLj1d", - "numGt3msL39D" - ], - "toc_visible": true, - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "accelerator": "GPU", - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "5da54fdb45e1485badd323232321bc96": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e6f461cb90cc498da90a20f2a6c610e0", - "IPY_MODEL_3e8a884bd6c94a86a324cfa7b9580ea7", - "IPY_MODEL_0b03a220e59848dfafb6411b24c3b37f" - ], - "layout": "IPY_MODEL_001a4d8dd8954706802b3add70f34d4b" - } - }, - "e6f461cb90cc498da90a20f2a6c610e0": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b950f7fe8ea34776bde01ed2f4244f5f", - "placeholder": "​", - "style": "IPY_MODEL_f7b175bb312c4f43809c97f98e6e84a3", - "value": "Downloading: 100%" - } - }, - "3e8a884bd6c94a86a324cfa7b9580ea7": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_e0c6b8aff2ad4849b3dac392ee388112", - "max": 598, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_8ddd76365cfd4408b8ca12309b183967", - "value": 598 - } - }, - "0b03a220e59848dfafb6411b24c3b37f": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_df8dc69ca1cf4e57bfebf4762c0460f0", - "placeholder": "​", - "style": "IPY_MODEL_799487c4c6de471c827f120f1c11d9e2", - "value": " 598/598 [00:00<00:00, 16.5kB/s]" - } - }, - "001a4d8dd8954706802b3add70f34d4b": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b950f7fe8ea34776bde01ed2f4244f5f": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f7b175bb312c4f43809c97f98e6e84a3": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "e0c6b8aff2ad4849b3dac392ee388112": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8ddd76365cfd4408b8ca12309b183967": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "df8dc69ca1cf4e57bfebf4762c0460f0": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "799487c4c6de471c827f120f1c11d9e2": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "9d713ac6d10949fb8d277286d969ad3b": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e2be4344fe8e4a36be35513041ea74a3", - "IPY_MODEL_2ed58d60a46d4f8491de7ad61d7cc589", - "IPY_MODEL_4ea0432a604e4ac197999debb131c557" - ], - "layout": "IPY_MODEL_21cd4080794342dbb3209df737d4f835" - } - }, - "e2be4344fe8e4a36be35513041ea74a3": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5cdd23be0a804fd192b6ccaddcb52964", - "placeholder": "​", - "style": "IPY_MODEL_889aca71e695487d9cd31c2dae585a64", - "value": "Downloading: 100%" - } - }, - "2ed58d60a46d4f8491de7ad61d7cc589": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b9fc636fcc6f4a2785999385cd340ab9", - "max": 17719103, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_ebf9284b6e514698b8c7389c758f7520", - "value": 17719103 - } - }, - "4ea0432a604e4ac197999debb131c557": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5749dba1be9b4eaaad17928a90ea411c", - "placeholder": "​", - "style": "IPY_MODEL_f0f3451d91bf4c5a9a8e20623a7b528d", - "value": " 17.7M/17.7M [00:00<00:00, 50.2MB/s]" - } - }, - "21cd4080794342dbb3209df737d4f835": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5cdd23be0a804fd192b6ccaddcb52964": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "889aca71e695487d9cd31c2dae585a64": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "b9fc636fcc6f4a2785999385cd340ab9": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ebf9284b6e514698b8c7389c758f7520": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "5749dba1be9b4eaaad17928a90ea411c": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f0f3451d91bf4c5a9a8e20623a7b528d": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0f8ee54b3031408da0281f7aa98eff25": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_ff89e65846414100b84b1f9cf8b70fd9", - "IPY_MODEL_a950bac54c5742e79cd2de4fda29c2e0", - "IPY_MODEL_3f5459fa25654a76bfec64d1dcb542b6" - ], - "layout": "IPY_MODEL_fa10eb9e43fd43a49934cdb4301aefff" - } - }, - "ff89e65846414100b84b1f9cf8b70fd9": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_547cbb166dba40d1b626bd204ff3cf96", - "placeholder": "​", - "style": "IPY_MODEL_a2aba4e8152c4fbda91bf59a42f25604", - "value": "Downloading: 100%" - } - }, - "a950bac54c5742e79cd2de4fda29c2e0": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_69a8212dded54f79adf3f8b60b9eb000", - "max": 318, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_25142cfd61084c128fe39adad5016109", - "value": 318 - } - }, - "3f5459fa25654a76bfec64d1dcb542b6": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7e64327fa6e948edae034c8d52bb96b4", - "placeholder": "​", - "style": "IPY_MODEL_32895abb57a7426aa089230aa49cfff2", - "value": " 318/318 [00:00<00:00, 9.69kB/s]" - } - }, - "fa10eb9e43fd43a49934cdb4301aefff": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "547cbb166dba40d1b626bd204ff3cf96": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a2aba4e8152c4fbda91bf59a42f25604": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "69a8212dded54f79adf3f8b60b9eb000": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "25142cfd61084c128fe39adad5016109": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "7e64327fa6e948edae034c8d52bb96b4": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "32895abb57a7426aa089230aa49cfff2": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "747aa6596d1a4b04a6f77e38179776ad": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e65942656e2347eba0a3fe3ae872159b", - "IPY_MODEL_6e5c84bfa614482b960be701f92ee22c", - "IPY_MODEL_def1205f95274d3db0fafc9c8dd1c913" - ], - "layout": "IPY_MODEL_46a04e196f9e461bb43e541270022b8d" - } - }, - "e65942656e2347eba0a3fe3ae872159b": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_18a02eecf49746cc972882c2cca9ded2", - "placeholder": "​", - "style": "IPY_MODEL_31e65957ea204c1084119e3e39528832", - "value": "Downloading: 100%" - } - }, - "6e5c84bfa614482b960be701f92ee22c": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_aa6ccf1390cc4139b7ba23ea7129b273", - "max": 1920, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_264cde3fae9d442abdb74b4d45288be3", - "value": 1920 - } - }, - "def1205f95274d3db0fafc9c8dd1c913": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2c28a61cfa474c7498a8381e74639530", - "placeholder": "​", - "style": "IPY_MODEL_5895a4011e3143a1931566822a65fd50", - "value": " 1.92k/1.92k [00:00<00:00, 61.7kB/s]" - } - }, - "46a04e196f9e461bb43e541270022b8d": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "18a02eecf49746cc972882c2cca9ded2": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "31e65957ea204c1084119e3e39528832": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "aa6ccf1390cc4139b7ba23ea7129b273": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "264cde3fae9d442abdb74b4d45288be3": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "2c28a61cfa474c7498a8381e74639530": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5895a4011e3143a1931566822a65fd50": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "43ada2ceb8ad44d7b8c1a3a1d0aefe2d": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_42b71601aeef4271ac150288a78bf66a", - "IPY_MODEL_300b503e606147bb8bc9ff7a98be0bac", - "IPY_MODEL_dcce36fe0b0946aaa484ae1f5f7eb6da" - ], - "layout": "IPY_MODEL_5beb3def5ae64f05b3ceb26c611dcb79" - } - }, - "42b71601aeef4271ac150288a78bf66a": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_030181ab29c149dfaf4940ea2c713190", - "placeholder": "​", - "style": "IPY_MODEL_cdec3493e32e49a1abc5f3c6783a49d9", - "value": "Downloading: 100%" - } - }, - "300b503e606147bb8bc9ff7a98be0bac": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b0efbf56235f4f9f866137c85ea2e189", - "max": 83316686, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_12bee4747bc74073bf4cbfd36f0445cb", - "value": 83316686 - } - }, - "dcce36fe0b0946aaa484ae1f5f7eb6da": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cb0fc23346fa4b638c3cce496ac6cd70", - "placeholder": "​", - "style": "IPY_MODEL_0200715daa5e4f4e8f7839d2ea579f19", - "value": " 83.3M/83.3M [00:03<00:00, 35.1MB/s]" - } - }, - "5beb3def5ae64f05b3ceb26c611dcb79": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "030181ab29c149dfaf4940ea2c713190": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cdec3493e32e49a1abc5f3c6783a49d9": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "b0efbf56235f4f9f866137c85ea2e189": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "12bee4747bc74073bf4cbfd36f0445cb": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "cb0fc23346fa4b638c3cce496ac6cd70": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0200715daa5e4f4e8f7839d2ea579f19": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "892182c8c97d426d9acf5467d1354d32": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_32acc8ab3c5643d7a4c3595fd67da269", - "IPY_MODEL_3c3189d90a404112ac7f6081acab7e61", - "IPY_MODEL_34e0fb65b69d470099506bd24362c52c" - ], - "layout": "IPY_MODEL_c697909d569d40918acd835108e29ae7" - } - }, - "32acc8ab3c5643d7a4c3595fd67da269": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d690ed1451e74799a2c4c265cd562ed9", - "placeholder": "​", - "style": "IPY_MODEL_f89679f445424ec1ba2203fb8f7753de", - "value": "Downloading: 100%" - } - }, - "3c3189d90a404112ac7f6081acab7e61": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_735b5f02606d4c0288f70469a8ab2902", - "max": 1921, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_0308a7a44b8b4a9cae7bda21fbad99f5", - "value": 1921 - } - }, - "34e0fb65b69d470099506bd24362c52c": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_967a5451e89049b4ac4688338495b50e", - "placeholder": "​", - "style": "IPY_MODEL_bb655ffda271431892bba5ebab9fd93b", - "value": " 1.92k/1.92k [00:00<00:00, 50.8kB/s]" - } - }, - "c697909d569d40918acd835108e29ae7": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d690ed1451e74799a2c4c265cd562ed9": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f89679f445424ec1ba2203fb8f7753de": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "735b5f02606d4c0288f70469a8ab2902": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0308a7a44b8b4a9cae7bda21fbad99f5": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "967a5451e89049b4ac4688338495b50e": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "bb655ffda271431892bba5ebab9fd93b": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f7626a7dae2a421ba31a578746be491d": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_97d03beea7cb4e479e1ee67edfa5f883", - "IPY_MODEL_00751b0ca24b47c1b7d337a5b17fc6c1", - "IPY_MODEL_9fc668b6710c449e898d4b8401fe974c" - ], - "layout": "IPY_MODEL_d0ea1fb45fe24bc3b549acc4e05860cd" - } - }, - "97d03beea7cb4e479e1ee67edfa5f883": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c15d7b4b314b4fb1beb5e8b001114392", - "placeholder": "​", - "style": "IPY_MODEL_6f73694403ae46538b7280ab31657ebc", - "value": "Downloading: 100%" - } - }, - "00751b0ca24b47c1b7d337a5b17fc6c1": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_f33d2ce982144ced87a7a834fe83bdb8", - "max": 5534328, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_7693042eb27e4994b86ed1afb293be56", - "value": 5534328 - } - }, - "9fc668b6710c449e898d4b8401fe974c": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_fd6ccdba0a2746419e744035e1096bf2", - "placeholder": "​", - "style": "IPY_MODEL_2dc0b625a4ff4a60abc4fa3c6671c9ab", - "value": " 5.53M/5.53M [00:00<00:00, 28.0MB/s]" - } - }, - "d0ea1fb45fe24bc3b549acc4e05860cd": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c15d7b4b314b4fb1beb5e8b001114392": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6f73694403ae46538b7280ab31657ebc": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f33d2ce982144ced87a7a834fe83bdb8": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "7693042eb27e4994b86ed1afb293be56": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "fd6ccdba0a2746419e744035e1096bf2": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2dc0b625a4ff4a60abc4fa3c6671c9ab": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0552df02d084406da5b7c51e18fd2cb0": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f61c385e5fa542a98652a434ad4cd324", - "IPY_MODEL_923af70854ad4651bd2d2a8556ab59f6", - "IPY_MODEL_170805a3d7ec457aaacd4d9a0acd09d0" - ], - "layout": "IPY_MODEL_14713e02e5734e46bfb9f9f815699e39" - } - }, - "f61c385e5fa542a98652a434ad4cd324": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_bea9fb28848d4c3da10df4fec3dfdb6b", - "placeholder": "​", - "style": "IPY_MODEL_a296598d7d3040e8b8b4dab4f7819e91", - "value": "Downloading: 100%" - } - }, - "923af70854ad4651bd2d2a8556ab59f6": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ab878626da504834b827f1762bcd2c20", - "max": 128619, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_f5a6de62a96340f4ab3094f08e8d54ef", - "value": 128619 - } - }, - "170805a3d7ec457aaacd4d9a0acd09d0": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_af1e4e3e52304c51a46eab4b989a3f0b", - "placeholder": "​", - "style": "IPY_MODEL_b0b8bb8fe0bc47908273136304cf4870", - "value": " 129k/129k [00:00<00:00, 210kB/s]" - } - }, - "14713e02e5734e46bfb9f9f815699e39": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "bea9fb28848d4c3da10df4fec3dfdb6b": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a296598d7d3040e8b8b4dab4f7819e91": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "ab878626da504834b827f1762bcd2c20": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f5a6de62a96340f4ab3094f08e8d54ef": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "af1e4e3e52304c51a46eab4b989a3f0b": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b0b8bb8fe0bc47908273136304cf4870": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - } - } - } - }, "cells": [ { "cell_type": "markdown", @@ -2766,6 +6,15 @@ "id": "view-in-github", "colab_type": "text" }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9-KmdPlBYnp6" + }, "source": [ "\"Open" ] @@ -2773,7 +22,7 @@ { "cell_type": "markdown", "metadata": { - "id": "nxNf1l8Ye_U9" + "id": "1Fs2d8otYnp7" }, "source": [ "[`pyannote.audio`](https://github.com/pyannote/pyannote-audio) is an open-source toolkit written in Python for **speaker diarization**. \n", @@ -2790,7 +39,7 @@ { "cell_type": "markdown", "metadata": { - "id": "42nBTa_QgooG" + "id": "tckHJKZnYnp7" }, "source": [ "## Installation" @@ -2798,13 +47,47 @@ }, { "cell_type": "code", + "execution_count": 5, "metadata": { - "id": "vJGyKTQJqdzq", - "outputId": "28eabcb6-b64b-4e78-9dc0-a181797c3e84", + "id": "ai082p4HYnp7", + "outputId": "42816e76-2ab7-4283-82e2-2a60ae199af5", "colab": { "base_uri": "https://localhost:8080/" } }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[K / 15.0 MB 349 kB/s\n", + "\u001b[K |████████████████████████████████| 217 kB 25.8 MB/s \n", + "\u001b[K |████████████████████████████████| 79 kB 8.4 MB/s \n", + "\u001b[K |████████████████████████████████| 60 kB 6.9 MB/s \n", + "\u001b[K |████████████████████████████████| 41 kB 461 kB/s \n", + "\u001b[K |████████████████████████████████| 51 kB 165 kB/s \n", + "\u001b[K |████████████████████████████████| 585 kB 43.1 MB/s \n", + "\u001b[K |████████████████████████████████| 111 kB 63.2 MB/s \n", + "\u001b[K |████████████████████████████████| 47 kB 5.4 MB/s \n", + "\u001b[K |████████████████████████████████| 529 kB 64.4 MB/s \n", + "\u001b[K |████████████████████████████████| 117 kB 71.1 MB/s \n", + "\u001b[K |████████████████████████████████| 130 kB 67.2 MB/s \n", + "\u001b[K |████████████████████████████████| 348 kB 63.5 MB/s \n", + "\u001b[K |████████████████████████████████| 209 kB 70.7 MB/s \n", + "\u001b[K |████████████████████████████████| 81 kB 11.5 MB/s \n", + "\u001b[K |████████████████████████████████| 78 kB 8.1 MB/s \n", + "\u001b[K |████████████████████████████████| 59 kB 6.9 MB/s \n", + "\u001b[K |████████████████████████████████| 147 kB 60.6 MB/s \n", + "\u001b[K |████████████████████████████████| 112 kB 53.7 MB/s \n", + "\u001b[K |████████████████████████████████| 50 kB 6.0 MB/s \n", + "\u001b[?25h Building wheel for pyannote.audio (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for antlr4-python3-runtime (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for docopt (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for julius (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for pyperclip (setup.py) ... \u001b[?25l\u001b[?25hdone\n" + ] + } + ], "source": [ "# for speechbrain\n", "!pip install -qq torch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 torchtext==0.12.0\n", @@ -2815,66 +98,12 @@ "\n", "# for visualization purposes\n", "!pip install -qq moviepy ipython==7.34.0" - ], - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[K |████████████████████████████████| 750.6 MB 12 kB/s \n", - "\u001b[K |████████████████████████████████| 21.0 MB 1.4 MB/s \n", - "\u001b[K |████████████████████████████████| 2.9 MB 49.5 MB/s \n", - "\u001b[K |████████████████████████████████| 10.4 MB 56.5 MB/s \n", - "\u001b[K |████████████████████████████████| 496 kB 34.8 MB/s \n", - "\u001b[K |████████████████████████████████| 101 kB 13.2 MB/s \n", - "\u001b[K |████████████████████████████████| 1.2 MB 58.4 MB/s \n", - "\u001b[K |████████████████████████████████| 596 kB 56.7 MB/s \n", - "\u001b[K |████████████████████████████████| 109 kB 75.9 MB/s \n", - "\u001b[K |████████████████████████████████| 546 kB 74.2 MB/s \n", - "\u001b[?25h Building wheel for hyperpyyaml (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "\u001b[K |████████████████████████████████| 385 kB 30.0 MB/s \n", - "\u001b[K |████████████████████████████████| 110 kB 66.8 MB/s \n", - "\u001b[K |████████████████████████████████| 79 kB 9.1 MB/s \n", - "\u001b[K |████████████████████████████████| 47 kB 5.7 MB/s \n", - "\u001b[K |████████████████████████████████| 41 kB 537 kB/s \n", - "\u001b[K |████████████████████████████████| 129 kB 63.0 MB/s \n", - "\u001b[K |████████████████████████████████| 419 kB 65.9 MB/s \n", - "\u001b[K |████████████████████████████████| 51 kB 201 kB/s \n", - "\u001b[K |████████████████████████████████| 65 kB 5.4 MB/s \n", - "\u001b[K |████████████████████████████████| 585 kB 71.6 MB/s \n", - "\u001b[K |████████████████████████████████| 117 kB 74.6 MB/s \n", - "\u001b[K |████████████████████████████████| 130 kB 64.6 MB/s \n", - "\u001b[K |████████████████████████████████| 308 kB 77.2 MB/s \n", - "\u001b[K |████████████████████████████████| 81 kB 11.4 MB/s \n", - "\u001b[K |████████████████████████████████| 209 kB 75.5 MB/s \n", - "\u001b[K |████████████████████████████████| 140 kB 74.8 MB/s \n", - "\u001b[K |████████████████████████████████| 1.1 MB 64.1 MB/s \n", - "\u001b[K |████████████████████████████████| 58 kB 7.2 MB/s \n", - "\u001b[K |████████████████████████████████| 144 kB 68.4 MB/s \n", - "\u001b[K |████████████████████████████████| 271 kB 68.2 MB/s \n", - "\u001b[K |████████████████████████████████| 94 kB 4.3 MB/s \n", - "\u001b[K |████████████████████████████████| 78 kB 8.5 MB/s \n", - "\u001b[K |████████████████████████████████| 112 kB 68.5 MB/s \n", - "\u001b[K |████████████████████████████████| 147 kB 73.3 MB/s \n", - "\u001b[K |████████████████████████████████| 49 kB 6.3 MB/s \n", - "\u001b[?25h Building wheel for antlr4-python3-runtime (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Building wheel for julius (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Building wheel for pyperclip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "\u001b[K |████████████████████████████████| 793 kB 22.7 MB/s \n", - "\u001b[K |████████████████████████████████| 381 kB 72.2 MB/s \n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "jupyter-console 5.2.0 requires prompt-toolkit<2.0.0,>=1.0.0, but you have prompt-toolkit 3.0.30 which is incompatible.\n", - "google-colab 1.0.0 requires ipython~=5.5.0, but you have ipython 7.34.0 which is incompatible.\u001b[0m\n", - "\u001b[?25h" - ] - } ] }, { "cell_type": "markdown", "metadata": { - "id": "5pSYhjbMhTwT" + "id": "qggK-7VBYnp8" }, "source": [ "# Visualization with `pyannote.core`\n", @@ -2884,20 +113,20 @@ }, { "cell_type": "code", + "execution_count": 6, "metadata": { - "id": "w7YuPI28qlwZ" + "id": "uJWoQiJgYnp8" }, + "outputs": [], "source": [ "!wget -q http://groups.inf.ed.ac.uk/ami/AMICorpusMirror/amicorpus/ES2004a/audio/ES2004a.Mix-Headset.wav\n", "DEMO_FILE = {'uri': 'ES2004a.Mix-Headset', 'audio': 'ES2004a.Mix-Headset.wav'}" - ], - "execution_count": 2, - "outputs": [] + ] }, { "cell_type": "markdown", "metadata": { - "id": "W0_wwm3dj_bO" + "id": "EPIapoCJYnp8" }, "source": [ "Because AMI is a benchmarking dataset, it comes with manual annotations (a.k.a *groundtruth*). \n", @@ -2906,25 +135,39 @@ }, { "cell_type": "code", + "execution_count": 7, "metadata": { - "id": "1pra1iVnrp5D" + "id": "Mmm0Q22JYnp8" }, + "outputs": [], "source": [ "!wget -q https://raw.githubusercontent.com/pyannote/AMI-diarization-setup/main/only_words/rttms/test/ES2004a.rttm" - ], - "execution_count": 5, - "outputs": [] + ] }, { "cell_type": "code", + "execution_count": 8, "metadata": { - "id": "aj1obYqhr3Qk", - "outputId": "2b1e6b24-c355-4edb-bf8f-46c1bd7f92d2", + "id": "ToqCwl_FYnp9", + "outputId": "f1487da9-785d-4967-dad1-a2a7f5ef5e9f", "colab": { "base_uri": "https://localhost:8080/", - "height": 118 + "height": 189 } }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 8 + } + ], "source": [ "# load groundtruth\n", "from pyannote.database.util import load_rttm\n", @@ -2932,26 +175,12 @@ "\n", "# visualize groundtruth\n", "groundtruth" - ], - "execution_count": 6, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {}, - "execution_count": 6 - } ] }, { "cell_type": "markdown", "metadata": { - "id": "JDhKjfUBlsjH" + "id": "p_R9T9Y5Ynp9" }, "source": [ "For the rest of this notebook, we will only listen to and visualize a one-minute long excerpt of the file (but will process the whole file anyway)." @@ -2959,14 +188,28 @@ }, { "cell_type": "code", + "execution_count": 9, "metadata": { - "id": "YAa_HoA9mnTZ", - "outputId": "6ff35b05-9b2c-49fa-bd4b-b674a44c7118", + "id": "bAHza4Y1Ynp-", + "outputId": "a24b6611-6fb4-43f9-e5c8-02e00a6479f1", "colab": { "base_uri": "https://localhost:8080/", - "height": 117 + "height": 189 } }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 9 + } + ], "source": [ "from pyannote.core import Segment, notebook\n", "# make notebook visualization zoom on 600s < t < 660s time range\n", @@ -2975,26 +218,12 @@ "\n", "# visualize excerpt groundtruth\n", "groundtruth" - ], - "execution_count": 7, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {}, - "execution_count": 7 - } ] }, { "cell_type": "markdown", "metadata": { - "id": "TpqTxB12F9Do" + "id": "L3FQXT5FYnp-" }, "source": [ "This nice visualization is brought to you by [`pyannote.core`](http://pyannote.github.io/pyannote-core/) and basically indicates when each speaker speaks. " @@ -3002,30 +231,16 @@ }, { "cell_type": "code", + "execution_count": 10, "metadata": { - "id": "62flXtNIsA9q", - "outputId": "7fe6edc9-194b-45c5-d3fb-973bf0553282", + "id": "rDhZ3bXEYnp-", + "outputId": "e94fac2e-5370-419e-9f76-a85cda9702ae", "colab": { "base_uri": "https://localhost:8080/", - "height": 119 + "height": 62 } }, - "source": [ - "from pyannote.audio import Audio \n", - "from IPython.display import Audio as IPythonAudio\n", - "waveform, sr = Audio().crop(DEMO_FILE, EXCERPT)\n", - "IPythonAudio(waveform.flatten(), rate=sr)" - ], - "execution_count": 8, "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.7/dist-packages/resampy/interpn.py:114: NumbaWarning: \u001b[1m\u001b[1mThe TBB threading layer requires TBB version 2019.5 or later i.e., TBB_INTERFACE_VERSION >= 11005. Found TBB_INTERFACE_VERSION = 9107. The TBB threading layer is disabled.\u001b[0m\u001b[0m\n", - " _resample_loop_p(x, t_out, interp_win, interp_delta, num_table, scale, y)\n" - ] - }, { "output_type": "execute_result", "data": { @@ -3034,7 +249,7 @@ ], "text/html": [ "\n", - "