From ad0df4c7ff87d1790a5ed906ea341d60e0a09c56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 25 Oct 2022 15:15:24 +0200 Subject: [PATCH 001/112] feat: add support for {min|max}_clusters to AgglomerativeClustering (#1113) --- pyannote/audio/pipelines/clustering.py | 102 ++++++++++++++++--------- 1 file changed, 68 insertions(+), 34 deletions(-) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index 53dc0ab23..07fbc1eaa 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -451,70 +451,104 @@ def cluster( """ num_embeddings, _ = embeddings.shape + + # linkage function will complain when there is just one embedding to cluster if num_embeddings == 1: return np.zeros((1,), dtype=np.uint8) + # centroid, median, and Ward method only support "euclidean" metric + # therefore we unit-normalize embeddings to somehow make them "euclidean" if self.metric == "cosine" and self.method in ["centroid", "median", "ward"]: - # unit-normalize embeddings to somehow make them "euclidean" with np.errstate(divide="ignore", invalid="ignore"): embeddings /= np.linalg.norm(embeddings, axis=-1, keepdims=True) dendrogram: np.ndarray = linkage( embeddings, method=self.method, metric="euclidean" ) + # other methods work just fine with any metric else: dendrogram: np.ndarray = linkage( embeddings, method=self.method, metric=self.metric ) - if num_clusters is None: + # apply the predefined threshold + clusters = fcluster(dendrogram, self.threshold, criterion="distance") - 1 - # FIXME: revise this to account for "min_cluster_size" as there is no longer - # a direct correlation between iteration index and final number of clusters - - # FIXME: revise the assumption that threshold is increasing monotonically - # as this is not the case for centroid linkage, for instance... + # split clusters into two categories based on their number of items: + # large clusters vs. small clusters + cluster_unique, cluster_counts = np.unique( + clusters, + return_counts=True, + ) + large_clusters = cluster_unique[cluster_counts >= self.min_cluster_size] + num_large_clusters = len(large_clusters) - max_threshold: float = ( - dendrogram[-min_clusters, 2] - if min_clusters < num_embeddings - else -np.inf - ) - min_threshold: float = ( - dendrogram[-max_clusters, 2] - if max_clusters < num_embeddings - else -np.inf - ) + # force num_clusters to min_clusters in case the actual number is too small + if num_large_clusters < min_clusters: + num_clusters = min_clusters - threshold = min(max(self.threshold, min_threshold), max_threshold) + # force num_clusters to max_clusters in case the actual number is too large + elif num_large_clusters > max_clusters: + num_clusters = max_clusters else: + num_clusters = num_large_clusters - threshold = ( - dendrogram[-num_clusters, 2] - if num_clusters < num_embeddings - else -np.inf - ) + # re-run the clustering with the newly defined target num_clusters + # and go as far as possible in the merging process. - clusters = fcluster(dendrogram, threshold, criterion="distance") - 1 + # switch stopping criterion from "inter-cluster distance" stopping to "iteration index" + _dendrogram = np.copy(dendrogram) + _dendrogram[:, 2] = np.arange(num_embeddings - 1) - # split clusters into two categories based on their number of items: - # large clusters vs. small clusters - cluster_unique, cluster_counts = np.unique( - clusters, - return_counts=True, - ) + best_iteration = num_embeddings - 1 + best_num_large_clusters = 1 - large_clusters = cluster_unique[cluster_counts >= self.min_cluster_size] - if large_clusters.size == 0: + # traverse the dendrogram in reverse order (from one big cluster to plenty of small clusters) + for iteration in range(num_embeddings - 2, 0, -1): + + # only consider iterations that might have resulted in changing the number of large clusters + new_cluster_size = _dendrogram[iteration, 3] + if new_cluster_size < self.min_cluster_size: + continue + + # estimate number of large clusters at considered iteration + clusters = fcluster(_dendrogram, iteration, criterion="distance") - 1 + cluster_unique, cluster_counts = np.unique(clusters, return_counts=True) + large_clusters = cluster_unique[cluster_counts >= self.min_cluster_size] + num_large_clusters = len(large_clusters) + + # keep track of iteration that leads to the number of large clusters + # as close as possible to the target number of clusters + if abs(num_large_clusters - num_clusters) < abs( + best_num_large_clusters - num_clusters + ): + best_iteration = iteration + best_num_large_clusters = num_large_clusters + + # stop traversing the dendrogram as soon as we found a good candidate + if num_large_clusters == num_clusters: + break + + # re-apply best iteration in case we did not find a perfect candidate + if best_num_large_clusters != num_clusters: + clusters = fcluster(_dendrogram, best_iteration, criterion="distance") - 1 + cluster_unique, cluster_counts = np.unique(clusters, return_counts=True) + large_clusters = cluster_unique[cluster_counts >= self.min_cluster_size] + num_large_clusters = len(large_clusters) + print( + f"Found only {num_large_clusters} clusters. Using a smaller value than {self.min_cluster_size} for `min_cluster_size` might help." + ) + + if num_large_clusters == 0: clusters[:] = 0 return clusters small_clusters = cluster_unique[cluster_counts < self.min_cluster_size] - if small_clusters.size == 0: + if len(small_clusters) == 0: return clusters - # re-assign each small cluster to the most similar large cluster + # re-assign each small cluster to the most similar large cluster based on their respective centroids large_centroids = np.vstack( [ np.mean(embeddings[clusters == large_k], axis=0) From 0dd2842d176098b0f0dbe9324cc8e12941ace1fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 25 Oct 2022 15:22:53 +0200 Subject: [PATCH 002/112] setup: switch to latest hugginface_hub API (#1114) Fixes #1065 --- pyannote/audio/core/model.py | 36 +++++++++++++++++++++++---------- pyannote/audio/core/pipeline.py | 22 +++++++++++++------- requirements.txt | 2 +- 3 files changed, 41 insertions(+), 19 deletions(-) diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index ddf4b2795..c12edb26e 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -33,7 +33,7 @@ import torch import torch.nn as nn import torch.optim -from huggingface_hub import cached_download, hf_hub_url +from huggingface_hub import hf_hub_download from pyannote.core import SlidingWindow from pytorch_lightning.utilities.cloud_io import load as pl_load from pytorch_lightning.utilities.model_summary import ModelSummary @@ -777,15 +777,21 @@ def from_pretrained( model_id = checkpoint revision = None - url = hf_hub_url( - model_id, filename=HF_PYTORCH_WEIGHTS_NAME, revision=revision - ) - path_for_pl = cached_download( - url=url, + 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, ) # HACK Huggingface download counters rely on config.yaml @@ -793,16 +799,24 @@ def from_pretrained( # HACK do not use it. Fails silently in case model does not # HACK have a config.yaml file. try: - config_url = hf_hub_url( - model_id, filename=HF_LIGHTNING_CONFIG_NAME, revision=revision - ) - _ = cached_download( - url=config_url, + + _ = hf_hub_download( + model_id, + HF_LIGHTNING_CONFIG_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 Exception: pass diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index 90daf297c..6d19453eb 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -28,14 +28,14 @@ from typing import Callable, List, Optional, Text, Union import yaml -from huggingface_hub import cached_download, hf_hub_url +from huggingface_hub import hf_hub_download +from pyannote.core.utils.helper import get_class_by_name +from pyannote.database import FileFinder, ProtocolFile +from pyannote.pipeline import Pipeline as _Pipeline from pyannote.audio import Audio, __version__ from pyannote.audio.core.io import AudioFile from pyannote.audio.core.model import CACHE_DIR -from pyannote.core.utils.helper import get_class_by_name -from pyannote.database import FileFinder, ProtocolFile -from pyannote.pipeline import Pipeline as _Pipeline PIPELINE_PARAMS_NAME = "config.yaml" @@ -77,14 +77,22 @@ def from_pretrained( else: model_id = checkpoint_path revision = None - url = hf_hub_url(model_id, filename=PIPELINE_PARAMS_NAME, revision=revision) - config_yml = cached_download( - url=url, + 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, ) with open(config_yml, "r") as fp: diff --git a/requirements.txt b/requirements.txt index 28eeae31a..5c991ead4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,7 +2,7 @@ asteroid-filterbanks >=0.4,<0.5 backports.cached_property einops >=0.3,<0.4.0 hmmlearn >=0.2.7,<0.3 -huggingface_hub >= 0.7,<0.11 +huggingface_hub >= 0.8.1 networkx >= 2.6,<3.0 omegaconf >=2.1,<3.0 pyannote.core >=4.4,<5.0 From a463e5cf47e5acceadec01fa97f390deb7437552 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 09:21:50 +0200 Subject: [PATCH 003/112] * fix: prioritize threshold value when looking for best iteration (#1115) --- pyannote/audio/pipelines/clustering.py | 95 ++++++++++++++------------ 1 file changed, 51 insertions(+), 44 deletions(-) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index 07fbc1eaa..ffb51b483 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -452,6 +452,12 @@ def cluster( num_embeddings, _ = embeddings.shape + # heuristic to reduce self.min_cluster_size when num_embeddings is very small + # (0.1 value is kind of arbitrary, though) + min_cluster_size = min( + self.min_cluster_size, max(1, round(0.1 * num_embeddings)) + ) + # linkage function will complain when there is just one embedding to cluster if num_embeddings == 1: return np.zeros((1,), dtype=np.uint8) @@ -480,7 +486,7 @@ def cluster( clusters, return_counts=True, ) - large_clusters = cluster_unique[cluster_counts >= self.min_cluster_size] + large_clusters = cluster_unique[cluster_counts >= min_cluster_size] num_large_clusters = len(large_clusters) # force num_clusters to min_clusters in case the actual number is too small @@ -491,60 +497,61 @@ def cluster( elif num_large_clusters > max_clusters: num_clusters = max_clusters - else: - num_clusters = num_large_clusters - - # re-run the clustering with the newly defined target num_clusters - # and go as far as possible in the merging process. - - # switch stopping criterion from "inter-cluster distance" stopping to "iteration index" - _dendrogram = np.copy(dendrogram) - _dendrogram[:, 2] = np.arange(num_embeddings - 1) + if num_clusters is not None: - best_iteration = num_embeddings - 1 - best_num_large_clusters = 1 + # switch stopping criterion from "inter-cluster distance" stopping to "iteration index" + _dendrogram = np.copy(dendrogram) + _dendrogram[:, 2] = np.arange(num_embeddings - 1) - # traverse the dendrogram in reverse order (from one big cluster to plenty of small clusters) - for iteration in range(num_embeddings - 2, 0, -1): + best_iteration = num_embeddings - 1 + best_num_large_clusters = 1 - # only consider iterations that might have resulted in changing the number of large clusters - new_cluster_size = _dendrogram[iteration, 3] - if new_cluster_size < self.min_cluster_size: - continue + # traverse the dendrogram by going further and further away + # from the "optimal" threshold - # estimate number of large clusters at considered iteration - clusters = fcluster(_dendrogram, iteration, criterion="distance") - 1 - cluster_unique, cluster_counts = np.unique(clusters, return_counts=True) - large_clusters = cluster_unique[cluster_counts >= self.min_cluster_size] - num_large_clusters = len(large_clusters) + for iteration in np.argsort(np.abs(dendrogram[:, 2] - self.threshold)): - # keep track of iteration that leads to the number of large clusters - # as close as possible to the target number of clusters - if abs(num_large_clusters - num_clusters) < abs( - best_num_large_clusters - num_clusters - ): - best_iteration = iteration - best_num_large_clusters = num_large_clusters - - # stop traversing the dendrogram as soon as we found a good candidate - if num_large_clusters == num_clusters: - break + # only consider iterations that might have resulted + # in changing the number of (large) clusters + new_cluster_size = _dendrogram[iteration, 3] + if new_cluster_size < min_cluster_size: + continue - # re-apply best iteration in case we did not find a perfect candidate - if best_num_large_clusters != num_clusters: - clusters = fcluster(_dendrogram, best_iteration, criterion="distance") - 1 - cluster_unique, cluster_counts = np.unique(clusters, return_counts=True) - large_clusters = cluster_unique[cluster_counts >= self.min_cluster_size] - num_large_clusters = len(large_clusters) - print( - f"Found only {num_large_clusters} clusters. Using a smaller value than {self.min_cluster_size} for `min_cluster_size` might help." - ) + # estimate number of large clusters at considered iteration + clusters = fcluster(_dendrogram, iteration, criterion="distance") - 1 + cluster_unique, cluster_counts = np.unique(clusters, return_counts=True) + large_clusters = cluster_unique[cluster_counts >= min_cluster_size] + num_large_clusters = len(large_clusters) + + # keep track of iteration that leads to the number of large clusters + # as close as possible to the target number of clusters. + if abs(num_large_clusters - num_clusters) < abs( + best_num_large_clusters - num_clusters + ): + best_iteration = iteration + best_num_large_clusters = num_large_clusters + + # stop traversing the dendrogram as soon as we found a good candidate + if num_large_clusters == num_clusters: + break + + # re-apply best iteration in case we did not find a perfect candidate + if best_num_large_clusters != num_clusters: + clusters = ( + fcluster(_dendrogram, best_iteration, criterion="distance") - 1 + ) + cluster_unique, cluster_counts = np.unique(clusters, return_counts=True) + large_clusters = cluster_unique[cluster_counts >= min_cluster_size] + num_large_clusters = len(large_clusters) + print( + f"Found only {num_large_clusters} clusters. Using a smaller value than {min_cluster_size} for `min_cluster_size` might help." + ) if num_large_clusters == 0: clusters[:] = 0 return clusters - small_clusters = cluster_unique[cluster_counts < self.min_cluster_size] + small_clusters = cluster_unique[cluster_counts < min_cluster_size] if len(small_clusters) == 0: return clusters From f700d6ea8dedd42e7c822c3b44b46a952e62a585 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 21:21:17 +0200 Subject: [PATCH 004/112] feat: add support for private and gated hf.co models (#1064) --- README.md | 11 +- pyannote/audio/core/model.py | 53 +- pyannote/audio/core/pipeline.py | 54 +- pyannote/audio/interactive/pipeline/recipe.py | 2 +- pyannote/audio/pipelines/multilabel.py | 39 +- .../pipelines/overlapped_speech_detection.py | 17 +- pyannote/audio/pipelines/resegmentation.py | 9 +- pyannote/audio/pipelines/segmentation.py | 26 +- .../audio/pipelines/speaker_diarization.py | 11 +- .../audio/pipelines/speaker_verification.py | 46 +- pyannote/audio/pipelines/utils/getter.py | 14 +- .../pipelines/voice_activity_detection.py | 23 +- tutorials/applying_a_model.ipynb | 123 +- tutorials/applying_a_pipeline.ipynb | 113 +- tutorials/intro.ipynb | 3304 +++++++++-------- tutorials/training_a_model.ipynb | 118 +- 16 files changed, 2254 insertions(+), 1709 deletions(-) diff --git a/README.md b/README.md index fc779a2c9..035a03e93 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 c12edb26e..2a49360b9 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -34,6 +34,7 @@ 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 @@ def on_save_checkpoint(self, checkpoint): @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 @@ def from_pretrained( 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 6d19453eb..1c28e52f5 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -29,6 +29,7 @@ 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 @@ def from_pretrained( 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 @@ def from_pretrained( 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 271a678f7..df9cc06b7 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 16990df6d..0f6e3211d 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 @@ def __init__( 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 @@ def initialize(self): 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 @@ def apply(self, file: AudioFile, hook: Optional[Callable] = None) -> Annotation: 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 6d8a8e7f9..2d07a76c7 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 @@ def __init__( 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 @@ def __init__( 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 659a18fe5..7e3969a2a 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 @@ def __init__( segmentation: PipelineModel = "pyannote/segmentation", diarization: Text = "diarization", der_variant: dict = None, + use_auth_token: Union[Text, None] = None, ): super().__init__() @@ -89,7 +94,7 @@ def __init__( 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 31ff1848b..34eb207c9 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 @@ def __init__( 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 @@ def __init__( 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 @@ def default_parameters(self): 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 @@ def get_stitching_graph( 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 @@ def get_metric(self): ) 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 d93116bd6..348e1cf11 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 @@ def __init__( 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 @@ def __init__( 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 bbbf1f17e..1ebd40fdc 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -27,7 +27,7 @@ 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 @@ def __init__( 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 @@ def __init__( 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 @@ def __init__( 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 @@ def __call__( 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 @@ def __init__( 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 3550e4854..4c589ad05 100644 --- a/pyannote/audio/pipelines/utils/getter.py +++ b/pyannote/audio/pipelines/utils/getter.py @@ -32,7 +32,10 @@ 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 b14eab69c..b146758ae 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.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 @@ def __init__( self, segmentation: PipelineModel = "pyannote/segmentation", fscore: bool = False, + use_auth_token: Union[Text, None] = None, **inference_kwargs, ): super().__init__() @@ -115,7 +120,7 @@ def __init__( 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 3c10d82f5..2319ab064 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 e3e8b063e..e436c7327 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": "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", + "image/png": "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\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 aaafe76d0..26bba3afb 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -1,457 +1,1057 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "Introduction to pyannote.audio speaker diarization toolkit", - "provenance": [], - "collapsed_sections": [ - "xD7QfHCHEIgE", - "CKsR0OZqLj1d", - "numGt3msL39D" + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9-KmdPlBYnp6" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1Fs2d8otYnp7" + }, + "source": [ + "[`pyannote.audio`](https://github.com/pyannote/pyannote-audio) is an open-source toolkit written in Python for **speaker diarization**. \n", + "\n", + "Based on [`PyTorch`](https://pytorch.org) machine learning framework, it provides a set of trainable end-to-end neural building blocks that can be combined and jointly optimized to build speaker diarization pipelines. \n", + "\n", + "`pyannote.audio` also comes with pretrained [models](https://huggingface.co/models?other=pyannote-audio-model) and [pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) covering a wide range of domains for voice activity detection, speaker segmentation, overlapped speech detection, speaker embedding reaching state-of-the-art performance for most of them. \n", + "\n", + "**This notebook will teach you how to apply those pretrained pipelines on your own data.**\n", + "\n", + "Make sure you run it using a GPU (or it might otherwise be slow...)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tckHJKZnYnp7" + }, + "source": [ + "## Installation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "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" + ] + } ], - "toc_visible": true, - "include_colab_link": true + "source": [ + "# for speechbrain\n", + "!pip install -qq torch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 torchtext==0.12.0\n", + "!pip install -qq speechbrain==0.5.12\n", + "\n", + "# pyannote.audio\n", + "!pip install -qq pyannote.audio\n", + "\n", + "# for visualization purposes\n", + "!pip install -qq moviepy ipython==7.34.0" + ] }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" + { + "cell_type": "markdown", + "metadata": { + "id": "qggK-7VBYnp8" + }, + "source": [ + "# Visualization with `pyannote.core`\n", + "\n", + "For the purpose of this notebook, we will download and use an audio file coming from the [AMI corpus](http://groups.inf.ed.ac.uk/ami/corpus/), which contains a conversation between 4 people in a meeting room." + ] }, - "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" + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "uJWoQiJgYnp8" + }, + "outputs": [], + "source": [ + "!wget -q http://groups.inf.ed.ac.uk/ami/AMICorpusMirror/amicorpus/ES2004a/audio/ES2004a.Mix-Headset.wav\n", + "DEMO_FILE = {'uri': 'ES2004a.Mix-Headset', 'audio': 'ES2004a.Mix-Headset.wav'}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EPIapoCJYnp8" + }, + "source": [ + "Because AMI is a benchmarking dataset, it comes with manual annotations (a.k.a *groundtruth*). \n", + "Let us load and visualize the expected output of the speaker diarization pipeline.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "Mmm0Q22JYnp8" + }, + "outputs": [], + "source": [ + "!wget -q https://raw.githubusercontent.com/pyannote/AMI-diarization-setup/main/only_words/rttms/test/ES2004a.rttm" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "ToqCwl_FYnp9", + "outputId": "f1487da9-785d-4967-dad1-a2a7f5ef5e9f", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 189 + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" ], - "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": "" - } + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "# load groundtruth\n", + "from pyannote.database.util import load_rttm\n", + "_, groundtruth = load_rttm('ES2004a.rttm').popitem()\n", + "\n", + "# visualize groundtruth\n", + "groundtruth" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p_R9T9Y5Ynp9" + }, + "source": [ + "For the rest of this notebook, we will only listen to and visualize a one-minute long excerpt of the file (but will process the whole file anyway)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "bAHza4Y1Ynp-", + "outputId": "a24b6611-6fb4-43f9-e5c8-02e00a6479f1", + "colab": { + "base_uri": "https://localhost:8080/", + "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", + "EXCERPT = Segment(600, 660)\n", + "notebook.crop = EXCERPT\n", + "\n", + "# visualize excerpt groundtruth\n", + "groundtruth" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L3FQXT5FYnp-" + }, + "source": [ + "This nice visualization is brought to you by [`pyannote.core`](http://pyannote.github.io/pyannote-core/) and basically indicates when each speaker speaks. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "rDhZ3bXEYnp-", + "outputId": "e94fac2e-5370-419e-9f76-a85cda9702ae", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 62 + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " " + ] + }, + "metadata": {}, + "execution_count": 10 + } + ], + "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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hkzox7QIYnp_" + }, + "source": [ + "# Processing your own audio file (optional)\n", + "\n", + "In case you just want to go ahead with the demo file, skip this section entirely.\n", + "\n", + "In case you want to try processing your own audio file, proceed with running this section. It will offer you to upload an audio file (preferably a `wav` file but all formats supported by [`SoundFile`](https://pysoundfile.readthedocs.io/en/latest/) should work just fine)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3hmFmLzFYnp_" + }, + "source": [ + "## Upload audio file" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xC05jFO_Ynp_", + "outputId": "c5502632-56ae-4adb-8bdc-112deedc8893" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" }, - "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 - } + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving sample.wav to sample.wav\n" + ] }, - "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": "" - } + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import google.colab\n", + "own_file, _ = google.colab.files.upload().popitem()\n", + "OWN_FILE = {'audio': own_file}\n", + "notebook.reset()\n", + "\n", + "# load audio waveform and play it\n", + "waveform, sample_rate = Audio()(OWN_FILE)\n", + "IPythonAudio(data=waveform.squeeze(), rate=sample_rate, autoplay=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ctw4nLaPYnp_" + }, + "source": [ + "Simply replace `DEMO_FILE` by `OWN_FILE` in the rest of the notebook.\n", + "\n", + "Note, however, that unless you provide a groundtruth annotation in the next cell, you will (obviously) not be able to visualize groundtruth annotation nor evaluate the performance of the diarization pipeline quantitatively" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x9AQgDzFYnp_" + }, + "source": [ + "## Upload groundtruth (optional)\n", + "\n", + "The groundtruth file is expected to use the RTTM format, with one line per speech turn with the following convention:\n", + "\n", + "```\n", + "SPEAKER {file_name} 1 {start_time} {duration} {speaker_name} \n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iZaFudpDYnp_", + "outputId": "981274fa-e654-4091-c838-91c81f921e5d" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" }, - "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 - } + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving sample.rttm to sample.rttm\n" + ] }, - "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": "" - } + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAACsCAYAAAAaLvvnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAOHUlEQVR4nO3de6ykZ10H8O+v3YIGCghbG1yqC+WiBWwpa9OKJk2DbQUVURRISCDyhxowXNQEFOzWqEnBtl4AjQVCDYSLgFpBqA1ZBJWCp1As5aJtbFPWUkStbVHLpT//mJdwaLuX2Z1zZp6zn08yOe95b/ObeeeZ951vnmemujsAAAAAjOOoZRcAAAAAwHwEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoTKrqeVX1msPY/uSq+khVXVNVf1VVD1i37OVVdV1Vfa6qzllMxVvbRh2PqnpIVe2pqjsOZ/8AAACwTAKdBaiqo5O8PsnLuvvxSf48ya9Oy05K8qwkj01ybpLXTeuzQfZ3PJL8X5JXJvmVJZUHAAAAh22oQKeq7ldV762qT1bVp6rqmVV1Q1W9auqJ8bGqeuS07nFV9a6q+sfp9qRp/mlTz41PVNU/VNVj7uV+njqts72qzp6mP15Vf1ZV95/WuaGqLqiqjyf5mSSPTvKhaRdXJPnpafppSd7W3Xd2978muS7JaRv6RG2SEY9Hd3+5u/8us2AHAAAAhjRUoJNZD5d/6+6Tu/txSd4/zf/vqSfGa5L83jTv95Nc3N0/kNmH+ddP8z+b5Ie7+wlJfiPJ76y/g6p6epKXJXnKNOsVSZ7c3acmWUvy0nWr/0d3n9rdb0tybWbhTTILFE6YpnckuWndNp+f5m0FIx4PAAAAGN62w9l4744Tdic5bzGlJEnO37H3pt37WX5Nkgur6oIk7+nuD1dVkrx1Wv7WJBdP009OctK0PEkeMPXmeGCSS6vqUUk6yTHr9n9Wkl1Jzu7u26rqx5KclOTvp/3cJ8lH1q3/9nXTP5fkD6rqlUkuS/KVg37UC3L6eZfvzoKPx5Xnn7N7P8sdDwAAAFiCwwp0Nlt3/3NVnZpZb43fqqoPfGPR+tWmv0clOb27v2VozfRFuHu6++lVtTPJB9ctvj7JIzIbrrOWpJJc0d3P3kdJX15X22eTnD3dx6OTPHVatDff2jvkYdO84Q16PAAAAGB4Qw25qqrvSvI/3f3mJK9Ocuq06Jnr/n6jx8bfJPmlddueMk0+MN8MVJ53t7u4MbPhQH9aVY9NcmWSJ637Hpj7TeHAvdX2ndPfozIbFvTH06LLkjyrqu5bVQ9P8qgkH5vjYa+sQY8HAAAADK+6+8BrrYjpJ79fneSuJF9N8otJ3pnZUJsfTXJnkmd393VVtT3Ja5N8X2Y9kT7U3b9QVWckuTSz3hzvTfKc7t5ZVc9Lsqu7X1hVT0jyliQ/nuR7klyQ5L5TGa/o7suq6oZp/S9Ntb0oyQumdd6d5OU9PblV9euZDQH6WpIXd/f7NuQJ2mQDH48bkjwgsyFbt2Y2pOvTG/AUAQAAwIYYKtC5N3f/IM9yOR4AAACw8YYacgUAAADAFuihAwAAAHCk0UMHAAAAYDACHQAAAIDBCHQAAAAABrNtnpW3b9/eO3fu3KBSAAAAAI48V1111Ze6+7h5tpkr0Nm5c2fW1tbmqwoAAACAfaqqG+fdxpArAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwcwV6Hz9llsWeue3XXjRQveXJJfsuW7h+1yEVa1rFW3F52orPibG53XJKtnf63EjrhfgUB3q69F7LnCk8z64eHMFOnctONC5/aKLF7q/JHnDB69f+D4XYVXrWkVb8bnaio+J8Xldskr293rciOsFOFSH+nr0ngsc6bwPLp4hVwAAAACDEegAAAAADGbbvBvs3XHCRtSxUKefd/myS+AwOYawObQ1RjHC9QcciPdcABZJDx0AAACAwQh0AAAAAAYz95CrHXtvWtidb1T36SvPP2dD9ns4dLGdzyoew8Ph+LOqtlpbY1wHep9c5PUHHI7DuX71ngscyXwmWjw9dAAAAAAGI9ABAAAAGIxABwAAAGAwcwU6Rx1//ELv/NiXvmSh+0uS55954sL3uQirWtcq2orP1VZ8TIzP65JVsr/X40ZcL8ChOtTXo/dc4EjnfXDxqrsPeuVdu3b12traBpYDAAAAcGSpqqu6e9c82xhyBQAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEehsgtsuvGjZJQxvs55DxwruSbtg1Vyy57oh9gkAq8Z13dYi0NkEt1908bJLGN5mPYeOFdyTdsGqecMHrx9inwCwalzXbS0CHQAAAIDBCHQAAAAABiPQAQAAABjMtmUXcKTYu+OEZZfAQXKsAFbf6eddvuwSAGBIPu9sHXroAAAAAAxGoAMAAAAwGEOuNsmOvTctu4ShbWa3QMcKvpVuuayiK88/Z6H7M4QLgCOFzzsrqmruTfTQAQAAABiMQAcAAABgMAKdTXDsS1+y7BKGt1nPoWMF96RdsGqef+aJQ+wTAFaN67qtpbr7oFfetWtXr62tbWA5AAAAAEeWqrqqu3fNs40eOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIOp7j74lav+PcmNG1cO3KvtSb607CKAQ6L9wpi0XRiTtgvjekx3HzvPBtvmWbm7j5uvHjh8VbXW3buWXQcwP+0XxqTtwpi0XRhXVa3Nu40hVwAAAACDEegAAAAADEagwwj+ZNkFAIdM+4UxabswJm0XxjV3+53rS5EBAAAAWD49dAAAAAAGI9BhpVTVG6vqi1X1qXXzHlxVV1TVv0x/v2OZNQL3tI+2u7uq9lbV1dPtKcusEbinqjqhqvZU1aer6tqqetE037kXVtx+2q/zL6ywqvq2qvpYVX1yarvnT/MfXlUfrarrqurtVXWfA+1LoMOqeVOSc+8272VJPtDdj0rygel/YLW8Kfdsu0lycXefMt3+epNrAg7sa0l+ubtPSnJ6khdU1Ulx7oUR7Kv9Js6/sMruTHJWd5+c5JQk51bV6UkuyKztPjLJfyV5/oF2JNBhpXT3h5L8591mPy3JpdP0pUl+clOLAg5oH20XWHHdfXN3f3yavj3JZ5LsiHMvrLz9tF9ghfXMHdO/x0y3TnJWkndO8w/q3CvQYQTHd/fN0/QXkhy/zGKAubywqv5pGpJlyAassKrameQJST4a514Yyt3ab+L8Cyutqo6uqquTfDHJFUmuT3Jrd39tWuXzOYiAVqDDUHr2s2x+mg3G8EdJTsysK+nNSS5cbjnAvlTV/ZO8K8mLu/u29cuce2G13Uv7df6FFdfdX+/uU5I8LMlpSb73UPYj0GEEt1TVQ5Nk+vvFJdcDHITuvmU6Wd2V5JLMTlbAiqmqYzL7MPiW7n73NNu5FwZwb+3X+RfG0d23JtmT5IwkD6qqbdOihyXZe6DtBTqM4LIkz52mn5vkL5dYC3CQvvFhcPL0JJ/a17rAclRVJXlDks9090XrFjn3worbV/t1/oXVVlXHVdWDpulvT/IjmX0H1p4kz5hWO6hzb8160cJqqKq3JjkzyfYktyQ5L8lfJHlHku9OcmOSn+1uX74KK2QfbffMzLp7d5Ibkvz8uu/kAFZAVf1Qkg8nuSbJXdPsX8vsezice2GF7af9PjvOv7Cyqur7M/vS46Mz62Tzju7+zap6RJK3JXlwkk8keU5337nffQl0AAAAAMZiyBUAAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAwMqrqodU1dXT7QtVtXeavqOqXrfs+gAANpufLQcAhlJVu5Pc0d2/u+xaAACWRQ8dAGBYVXVmVb1nmt5dVZdW1Yer6saq+qmqelVVXVNV76+qY6b1nlhVf1tVV1XV5VX10OU+CgCA+Ql0AICt5MQkZyX5iSRvTrKnux+f5H+TPHUKdf4wyTO6+4lJ3pjkt5dVLADAodq27AIAABbofd391aq6JsnRSd4/zb8myc4kj0nyuCRXVFWmdW5eQp0AAIdFoAMAbCV3Jkl331VVX+1vflngXZld91SSa7v7jGUVCACwCIZcAQBHks8lOa6qzkiSqjqmqh675JoAAOYm0AEAjhjd/ZUkz0hyQVV9MsnVSX5wuVUBAMzPz5YDAAAADEYPHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAw/w9yi/xWuRzNKQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "groundtruth_rttm, _ = google.colab.files.upload().popitem()\n", + "groundtruths = load_rttm(groundtruth_rttm)\n", + "if OWN_FILE['audio'] in groundtruths:\n", + " groundtruth = groundtruths[OWN_FILE['audio']]\n", + "else:\n", + " _, groundtruth = groundtruths.popitem()\n", + "groundtruth" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5MclWK2GYnp_" + }, + "source": [ + "# Speaker diarization with `pyannote.pipeline`\n", + "\n", + "We are about to run a full speaker diarization pipeline, that includes speaker segmentation, speaker embedding, and a final clustering step. **Brace yourself!**\n", + "\n", + "To load the speaker diarization pipeline, \n", + "\n", + "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization).\n", + "* login using `notebook_login` below" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "r5u7VMb-YnqB", + "outputId": "433b4f1b-c6fb-4047-be4f-fbfde0d7aa68", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 300, + "referenced_widgets": [ + "a7fd4da8fca94798b977d92ae4f3f2bf", + "cc5fdc26256248cf8dac00fbc314a3c7", + "a134ee5d26c54b04b7a34b5e7671e2cf", + "58e364b0131449659804831baa1fb421", + "7f150092f0984d65882e57c373cce7c4", + "7ee601dd1b8c4a9b9df7c0a0dce0ff3b", + "4e4de9bec49841bb8e77d176511da330", + "343a0bfe7363401b9c00602c547fc609", + "8ae65b22713547ac88aad90600f1ebb0", + "4a4b13ce55944ec985ac6eb3e302e473", + "36bfa883a7bf4306a60bd2f2e9d34c17", + "28a732468d2b43f7b0b66b81aed09305", + "a1e3a0a5f91b4a1282fab3f84918e684", + "775d04d911a347ce8993eac7ae7479d1" + ] + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Login successful\n", + "Your token has been saved to /root/.huggingface/token\n" + ] + } + ], + "source": [ + "from huggingface_hub import notebook_login\n", + "notebook_login()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "lUq1UvoJYnqB", + "outputId": "36cd5a49-b762-4ec1-a1e0-0d9471a35b39", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 273, + "referenced_widgets": [ + "bbbeab96755c4dbea662d7b821c7188f", + "29886bb25e6c444d89bd62fe0d3fc2aa", + "e7d91492ccba4a4fbd35b8b8652ce424", + "8007ece499c343438619420efb1c783d", + "d04b749f32524693a4aff3fc39565688", + "eaf64f20c7ba495480f91d21b54704ef", + "8e2b713e4b7d43658c75b254628f3a10", + "d145e071ff944867afdfcc8182125b40", + "976f00b9aeb04bc985657b018144269b", + "94eec654793d45f4891c7a43217b7e4c", + "6ce2a0b4a07f4acaa80fe11e064e05ed", + "f4ab2f4beedc469a82dc687330003453", + "45dd7efcbbdb49a8ba9e98cffc41447a", + "4653c869270b4a2cad98e970dfe3fc34", + "924ad861916442898392eaae6c44da56", + "796dde241ce44bbabc1403bef156f410", + "f40f7ddb7ebc4dac993b8f6fab2a698d", + "a8f4d54932f94730a8ba41e58253a9c9", + "9099bee7874f41dab13dbffc5479be5d", + "e94e8546d7954a0987da477f3c3b20fd", + "eb032a7f35bd4e4e9ca4328c5d0a52e6", + "49059590a13a4e6f94fff2689c5c06c3", + "b2a14badcc0548f0a056605f456c14ab", + "607b38bc10e24a6fa56f864505b98b5d", + "63ce45b4de184550acaca5b2e38c0a5c", + "b063b8808ee040e9b05311a3e89389f9", + "65b07a137ab44caa9c153803a1bec549", + "a2451a62c0ff4f4287a382db373650ca", + "6d0845291bfc4c76a1bf86e5a0740b6f", + "05d4e5935c09454885057208f89fdd95", + "103ada1efb904aa383b21ae5e0555777", + "845a0f7b2a2a428e81f9870b75aef56a", + "5e5ebb6018a749c1b1b3ca0db5ecc6f5", + "56b7159b3a4c49e69c5130ad14860bd5", + "9db61482ec0349e48d5b7ea0abe7a455", + "d4319560e75e4f2b8e0a08ed51236f4d", + "c54ff0533893489886d4e5f42c089864", + "b96775d8306849e6929d1565f36905cc", + "561ce5b2a5cb4b73b79e65649f717c94", + "60b96dbb352549c4a8be44f2b7e58027", + "caec2fe41ae044b9aa5f983799041d91", + "372a6b4d550145a1a18243918b34b377", + "7ab33c4be8454daf98c86aff05d14966", + "8b205b8a31754b038e3c90234c0f0ba0", + "78d4e56cedd24c158e32f8c4ca061e75", + "660b0d137ed6440eaec4b614edcfe6be", + "0c318128b3794483b12795e1e0bc54ac", + "cbacee0f58b0487397e221873f3d383a", + "00ad3a57fd1c4a119248499c170a78ab", + "3435da3dd0404ae8ab0961731a9a0401", + "50343a8f410344c799b8abb5253dac33", + "fd03191952134e42a881743e5c51d2db", + "ba7d97dcd55943e996ab08c25c7f8239", + "bc19cd2362504c05882bee1ad32fc4dc", + "3e667b4863c3479cb0cce455558e0ff4", + "3f152784ff7947668e1eb4d890c31043", + "92bc59fb29444d99b5420ea92b63d873", + "e89ebbf536a7415d92cdb9bb0e40bd23", + "9157ace3987147e8afd845b0b4de5365", + "1349e97c6e10422ab22d2df65f62f236", + "87ca9dd3c5cf4bf5b6a3d9afb2b97ad7", + "117925349b764bc883f076c76855b146", + "0b96234b8a464e6098f2f1f9aae445e2", + "c8c29f7f5dbe45798166423d21d0479a", + "b1f39d703abf405188d7a8c99500077b", + "5333f14482954ab58224e858cd3144d3", + "275133746d524f099c8ec736f157a1bd", + "f7dbef43a8c14f77bbcca6a02a02970b", + "543a7cfb2e4b49d39cd35f63d49a7386", + "cf9bc7d009994525b9a4edbdd02e291d", + "f5f78e586cd24028b83887ded99f43bc", + "bdbd0f99d45d4c86b6b5a69e11feec51", + "4db259c505014ab68783a3ff2a128afe", + "86bfddc1dfe44f2d8f96ccbd0dcebb2a", + "621c3ec473b3414a95f6b0f7df2898ea", + "a78cb85112ad404ca6172b216b679767", + "7e432a87cb0d4571bdc52cfcaae702b7", + "a88fb04c89834c48b922f6ff14632c87", + "4176f6e114d04cc3af8fd00c9405ab48", + "c7250d3a8d044265a1c3d098585a0117", + "cf5c362276004feab43dce3cc80ea945", + "9a8a9f130bf544949914b972e1cb302f", + "1697e1466f514b89b6fae0edf8f48bd7", + "9aa6ef23552e4b91ad9ca6c897c17579", + "a260382718bd4998a96013e8643f7589", + "44cd14b01a854294b283129db1e6beab", + "80ca456de9084ef18dc13c369f127486", + "19d13680d11f48d6938e52743c7f4275" + ] + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Downloading: 0%| | 0.00/500 [00:00" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 13 + } + ], + "source": [ + "diarization" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DLhErS6wYnqB" + }, + "source": [ + "# Evaluation with `pyannote.metrics`\n", + "\n", + "Because groundtruth is available, we can evaluate the quality of the diarization pipeline by computing the [diarization error rate](http://pyannote.github.io/pyannote-metrics/reference.html#diarization)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "vNHQRTUIYnqB" + }, + "outputs": [], + "source": [ + "from pyannote.metrics.diarization import DiarizationErrorRate\n", + "metric = DiarizationErrorRate()\n", + "der = metric(groundtruth, diarization)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "9d0vKQ0fYnqB", + "outputId": "74dc4b06-5d8d-4ffb-b764-c30fdb0dbb0a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "diarization error rate = 40.2%\n" + ] + } + ], + "source": [ + "print(f'diarization error rate = {100 * der:.1f}%')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Xz5QJV9nYnqB" + }, + "source": [ + "This implementation of diarization error rate is brought to you by [`pyannote.metrics`](http://pyannote.github.io/pyannote-metrics/).\n", + "\n", + "It can also be used to improve visualization by find the optimal one-to-one mapping between groundtruth and hypothesized speakers." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "xMLf4mrYYnqB", + "outputId": "eecd6b38-4fb2-400a-d495-9ef739480e22", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 189 + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 16 + } + ], + "source": [ + "mapping = metric.optimal_mapping(groundtruth, diarization)\n", + "diarization.rename_labels(mapping=mapping)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "Z0ewsLlQYnqB", + "outputId": "71dd0295-80b7-4909-d616-4dffcf81b40b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 189 + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 17 + } + ], + "source": [ + "groundtruth" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MxlrTbyPYnqB" + }, + "source": [ + "# Going further \n", + "\n", + "We have only scratched the surface in this introduction. \n", + "\n", + "More details can be found in the [`pyannote.audio` Github repository](https://github.com/pyannote/pyannote-audio).\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "a7fd4da8fca94798b977d92ae4f3f2bf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "VBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", + "_model_name": "VBoxModel", "_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%" + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cc5fdc26256248cf8dac00fbc314a3c7", + "IPY_MODEL_a134ee5d26c54b04b7a34b5e7671e2cf", + "IPY_MODEL_58e364b0131449659804831baa1fb421", + "IPY_MODEL_7f150092f0984d65882e57c373cce7c4" + ], + "layout": "IPY_MODEL_7ee601dd1b8c4a9b9df7c0a0dce0ff3b" } }, - "2ed58d60a46d4f8491de7ad61d7cc589": { + "cc5fdc26256248cf8dac00fbc314a3c7": { "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", + "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": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", + "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_b9fc636fcc6f4a2785999385cd340ab9", - "max": 17719103, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_ebf9284b6e514698b8c7389c758f7520", - "value": 17719103 + "layout": "IPY_MODEL_4e4de9bec49841bb8e77d176511da330", + "placeholder": "​", + "style": "IPY_MODEL_343a0bfe7363401b9c00602c547fc609", + "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" } }, - "4ea0432a604e4ac197999debb131c557": { + "a134ee5d26c54b04b7a34b5e7671e2cf": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", + "model_name": "PasswordModel", "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", + "_model_name": "PasswordModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Token:", "description_tooltip": null, - "layout": "IPY_MODEL_5749dba1be9b4eaaad17928a90ea411c", + "disabled": false, + "layout": "IPY_MODEL_8ae65b22713547ac88aad90600f1ebb0", "placeholder": "​", - "style": "IPY_MODEL_f0f3451d91bf4c5a9a8e20623a7b528d", - "value": " 17.7M/17.7M [00:00<00:00, 50.2MB/s]" + "style": "IPY_MODEL_4a4b13ce55944ec985ac6eb3e302e473", + "value": "" } }, - "21cd4080794342dbb3209df737d4f835": { - "model_module": "@jupyter-widgets/base", + "58e364b0131449659804831baa1fb421": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ButtonModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_36bfa883a7bf4306a60bd2f2e9d34c17", + "style": "IPY_MODEL_28a732468d2b43f7b0b66b81aed09305", + "tooltip": "" + } + }, + "7f150092f0984d65882e57c373cce7c4": { + "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_a1e3a0a5f91b4a1282fab3f84918e684", + "placeholder": "​", + "style": "IPY_MODEL_775d04d911a347ce8993eac7ae7479d1", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " + } + }, + "7ee601dd1b8c4a9b9df7c0a0dce0ff3b": { + "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": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "4e4de9bec49841bb8e77d176511da330": { + "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "state": { @@ -502,7 +1102,22 @@ "width": null } }, - "5cdd23be0a804fd192b6ccaddcb52964": { + "343a0bfe7363401b9c00602c547fc609": { + "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": "" + } + }, + "8ae65b22713547ac88aad90600f1ebb0": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -554,7 +1169,7 @@ "width": null } }, - "889aca71e695487d9cd31c2dae585a64": { + "4a4b13ce55944ec985ac6eb3e302e473": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -569,7 +1184,7 @@ "description_width": "" } }, - "b9fc636fcc6f4a2785999385cd340ab9": { + "36bfa883a7bf4306a60bd2f2e9d34c17": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -621,23 +1236,23 @@ "width": null } }, - "ebf9284b6e514698b8c7389c758f7520": { + "28a732468d2b43f7b0b66b81aed09305": { "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", + "model_name": "ButtonStyleModel", "model_module_version": "1.5.0", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", + "_model_name": "ButtonStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "button_color": null, + "font_weight": "" } }, - "5749dba1be9b4eaaad17928a90ea411c": { + "a1e3a0a5f91b4a1282fab3f84918e684": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -689,7 +1304,7 @@ "width": null } }, - "f0f3451d91bf4c5a9a8e20623a7b528d": { + "775d04d911a347ce8993eac7ae7479d1": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -704,7 +1319,7 @@ "description_width": "" } }, - "0f8ee54b3031408da0281f7aa98eff25": { + "bbbeab96755c4dbea662d7b821c7188f": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -719,14 +1334,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_ff89e65846414100b84b1f9cf8b70fd9", - "IPY_MODEL_a950bac54c5742e79cd2de4fda29c2e0", - "IPY_MODEL_3f5459fa25654a76bfec64d1dcb542b6" + "IPY_MODEL_29886bb25e6c444d89bd62fe0d3fc2aa", + "IPY_MODEL_e7d91492ccba4a4fbd35b8b8652ce424", + "IPY_MODEL_8007ece499c343438619420efb1c783d" ], - "layout": "IPY_MODEL_fa10eb9e43fd43a49934cdb4301aefff" + "layout": "IPY_MODEL_d04b749f32524693a4aff3fc39565688" } }, - "ff89e65846414100b84b1f9cf8b70fd9": { + "29886bb25e6c444d89bd62fe0d3fc2aa": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -741,13 +1356,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_547cbb166dba40d1b626bd204ff3cf96", + "layout": "IPY_MODEL_eaf64f20c7ba495480f91d21b54704ef", "placeholder": "​", - "style": "IPY_MODEL_a2aba4e8152c4fbda91bf59a42f25604", + "style": "IPY_MODEL_8e2b713e4b7d43658c75b254628f3a10", "value": "Downloading: 100%" } }, - "a950bac54c5742e79cd2de4fda29c2e0": { + "e7d91492ccba4a4fbd35b8b8652ce424": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -763,15 +1378,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_69a8212dded54f79adf3f8b60b9eb000", - "max": 318, + "layout": "IPY_MODEL_d145e071ff944867afdfcc8182125b40", + "max": 500, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_25142cfd61084c128fe39adad5016109", - "value": 318 + "style": "IPY_MODEL_976f00b9aeb04bc985657b018144269b", + "value": 500 } }, - "3f5459fa25654a76bfec64d1dcb542b6": { + "8007ece499c343438619420efb1c783d": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -786,13 +1401,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_7e64327fa6e948edae034c8d52bb96b4", + "layout": "IPY_MODEL_94eec654793d45f4891c7a43217b7e4c", "placeholder": "​", - "style": "IPY_MODEL_32895abb57a7426aa089230aa49cfff2", - "value": " 318/318 [00:00<00:00, 9.69kB/s]" + "style": "IPY_MODEL_6ce2a0b4a07f4acaa80fe11e064e05ed", + "value": " 500/500 [00:00<00:00, 9.11kB/s]" } }, - "fa10eb9e43fd43a49934cdb4301aefff": { + "d04b749f32524693a4aff3fc39565688": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -844,7 +1459,7 @@ "width": null } }, - "547cbb166dba40d1b626bd204ff3cf96": { + "eaf64f20c7ba495480f91d21b54704ef": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -896,7 +1511,7 @@ "width": null } }, - "a2aba4e8152c4fbda91bf59a42f25604": { + "8e2b713e4b7d43658c75b254628f3a10": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -911,7 +1526,7 @@ "description_width": "" } }, - "69a8212dded54f79adf3f8b60b9eb000": { + "d145e071ff944867afdfcc8182125b40": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -963,7 +1578,7 @@ "width": null } }, - "25142cfd61084c128fe39adad5016109": { + "976f00b9aeb04bc985657b018144269b": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -979,7 +1594,7 @@ "description_width": "" } }, - "7e64327fa6e948edae034c8d52bb96b4": { + "94eec654793d45f4891c7a43217b7e4c": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1031,7 +1646,7 @@ "width": null } }, - "32895abb57a7426aa089230aa49cfff2": { + "6ce2a0b4a07f4acaa80fe11e064e05ed": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1046,7 +1661,7 @@ "description_width": "" } }, - "747aa6596d1a4b04a6f77e38179776ad": { + "f4ab2f4beedc469a82dc687330003453": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -1061,14 +1676,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_e65942656e2347eba0a3fe3ae872159b", - "IPY_MODEL_6e5c84bfa614482b960be701f92ee22c", - "IPY_MODEL_def1205f95274d3db0fafc9c8dd1c913" + "IPY_MODEL_45dd7efcbbdb49a8ba9e98cffc41447a", + "IPY_MODEL_4653c869270b4a2cad98e970dfe3fc34", + "IPY_MODEL_924ad861916442898392eaae6c44da56" ], - "layout": "IPY_MODEL_46a04e196f9e461bb43e541270022b8d" + "layout": "IPY_MODEL_796dde241ce44bbabc1403bef156f410" } }, - "e65942656e2347eba0a3fe3ae872159b": { + "45dd7efcbbdb49a8ba9e98cffc41447a": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1083,13 +1698,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_18a02eecf49746cc972882c2cca9ded2", + "layout": "IPY_MODEL_f40f7ddb7ebc4dac993b8f6fab2a698d", "placeholder": "​", - "style": "IPY_MODEL_31e65957ea204c1084119e3e39528832", + "style": "IPY_MODEL_a8f4d54932f94730a8ba41e58253a9c9", "value": "Downloading: 100%" } }, - "6e5c84bfa614482b960be701f92ee22c": { + "4653c869270b4a2cad98e970dfe3fc34": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -1105,15 +1720,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_aa6ccf1390cc4139b7ba23ea7129b273", - "max": 1920, + "layout": "IPY_MODEL_9099bee7874f41dab13dbffc5479be5d", + "max": 17719103, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_264cde3fae9d442abdb74b4d45288be3", - "value": 1920 + "style": "IPY_MODEL_e94e8546d7954a0987da477f3c3b20fd", + "value": 17719103 } }, - "def1205f95274d3db0fafc9c8dd1c913": { + "924ad861916442898392eaae6c44da56": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1128,13 +1743,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_2c28a61cfa474c7498a8381e74639530", + "layout": "IPY_MODEL_eb032a7f35bd4e4e9ca4328c5d0a52e6", "placeholder": "​", - "style": "IPY_MODEL_5895a4011e3143a1931566822a65fd50", - "value": " 1.92k/1.92k [00:00<00:00, 61.7kB/s]" + "style": "IPY_MODEL_49059590a13a4e6f94fff2689c5c06c3", + "value": " 17.7M/17.7M [00:00<00:00, 46.2MB/s]" } }, - "46a04e196f9e461bb43e541270022b8d": { + "796dde241ce44bbabc1403bef156f410": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1186,7 +1801,7 @@ "width": null } }, - "18a02eecf49746cc972882c2cca9ded2": { + "f40f7ddb7ebc4dac993b8f6fab2a698d": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1238,7 +1853,7 @@ "width": null } }, - "31e65957ea204c1084119e3e39528832": { + "a8f4d54932f94730a8ba41e58253a9c9": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1253,7 +1868,7 @@ "description_width": "" } }, - "aa6ccf1390cc4139b7ba23ea7129b273": { + "9099bee7874f41dab13dbffc5479be5d": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1305,7 +1920,7 @@ "width": null } }, - "264cde3fae9d442abdb74b4d45288be3": { + "e94e8546d7954a0987da477f3c3b20fd": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -1321,7 +1936,7 @@ "description_width": "" } }, - "2c28a61cfa474c7498a8381e74639530": { + "eb032a7f35bd4e4e9ca4328c5d0a52e6": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1373,7 +1988,7 @@ "width": null } }, - "5895a4011e3143a1931566822a65fd50": { + "49059590a13a4e6f94fff2689c5c06c3": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1388,7 +2003,7 @@ "description_width": "" } }, - "43ada2ceb8ad44d7b8c1a3a1d0aefe2d": { + "b2a14badcc0548f0a056605f456c14ab": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -1403,14 +2018,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_42b71601aeef4271ac150288a78bf66a", - "IPY_MODEL_300b503e606147bb8bc9ff7a98be0bac", - "IPY_MODEL_dcce36fe0b0946aaa484ae1f5f7eb6da" + "IPY_MODEL_607b38bc10e24a6fa56f864505b98b5d", + "IPY_MODEL_63ce45b4de184550acaca5b2e38c0a5c", + "IPY_MODEL_b063b8808ee040e9b05311a3e89389f9" ], - "layout": "IPY_MODEL_5beb3def5ae64f05b3ceb26c611dcb79" + "layout": "IPY_MODEL_65b07a137ab44caa9c153803a1bec549" } }, - "42b71601aeef4271ac150288a78bf66a": { + "607b38bc10e24a6fa56f864505b98b5d": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1425,13 +2040,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_030181ab29c149dfaf4940ea2c713190", + "layout": "IPY_MODEL_a2451a62c0ff4f4287a382db373650ca", "placeholder": "​", - "style": "IPY_MODEL_cdec3493e32e49a1abc5f3c6783a49d9", + "style": "IPY_MODEL_6d0845291bfc4c76a1bf86e5a0740b6f", "value": "Downloading: 100%" } }, - "300b503e606147bb8bc9ff7a98be0bac": { + "63ce45b4de184550acaca5b2e38c0a5c": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -1447,15 +2062,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_b0efbf56235f4f9f866137c85ea2e189", - "max": 83316686, + "layout": "IPY_MODEL_05d4e5935c09454885057208f89fdd95", + "max": 318, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_12bee4747bc74073bf4cbfd36f0445cb", - "value": 83316686 + "style": "IPY_MODEL_103ada1efb904aa383b21ae5e0555777", + "value": 318 } }, - "dcce36fe0b0946aaa484ae1f5f7eb6da": { + "b063b8808ee040e9b05311a3e89389f9": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1470,13 +2085,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_cb0fc23346fa4b638c3cce496ac6cd70", + "layout": "IPY_MODEL_845a0f7b2a2a428e81f9870b75aef56a", "placeholder": "​", - "style": "IPY_MODEL_0200715daa5e4f4e8f7839d2ea579f19", - "value": " 83.3M/83.3M [00:03<00:00, 35.1MB/s]" + "style": "IPY_MODEL_5e5ebb6018a749c1b1b3ca0db5ecc6f5", + "value": " 318/318 [00:00<00:00, 5.73kB/s]" } }, - "5beb3def5ae64f05b3ceb26c611dcb79": { + "65b07a137ab44caa9c153803a1bec549": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1528,7 +2143,7 @@ "width": null } }, - "030181ab29c149dfaf4940ea2c713190": { + "a2451a62c0ff4f4287a382db373650ca": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1580,7 +2195,7 @@ "width": null } }, - "cdec3493e32e49a1abc5f3c6783a49d9": { + "6d0845291bfc4c76a1bf86e5a0740b6f": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1595,7 +2210,7 @@ "description_width": "" } }, - "b0efbf56235f4f9f866137c85ea2e189": { + "05d4e5935c09454885057208f89fdd95": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1647,7 +2262,7 @@ "width": null } }, - "12bee4747bc74073bf4cbfd36f0445cb": { + "103ada1efb904aa383b21ae5e0555777": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -1663,7 +2278,7 @@ "description_width": "" } }, - "cb0fc23346fa4b638c3cce496ac6cd70": { + "845a0f7b2a2a428e81f9870b75aef56a": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1715,7 +2330,7 @@ "width": null } }, - "0200715daa5e4f4e8f7839d2ea579f19": { + "5e5ebb6018a749c1b1b3ca0db5ecc6f5": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1730,7 +2345,7 @@ "description_width": "" } }, - "892182c8c97d426d9acf5467d1354d32": { + "56b7159b3a4c49e69c5130ad14860bd5": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -1745,14 +2360,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_32acc8ab3c5643d7a4c3595fd67da269", - "IPY_MODEL_3c3189d90a404112ac7f6081acab7e61", - "IPY_MODEL_34e0fb65b69d470099506bd24362c52c" + "IPY_MODEL_9db61482ec0349e48d5b7ea0abe7a455", + "IPY_MODEL_d4319560e75e4f2b8e0a08ed51236f4d", + "IPY_MODEL_c54ff0533893489886d4e5f42c089864" ], - "layout": "IPY_MODEL_c697909d569d40918acd835108e29ae7" + "layout": "IPY_MODEL_b96775d8306849e6929d1565f36905cc" } }, - "32acc8ab3c5643d7a4c3595fd67da269": { + "9db61482ec0349e48d5b7ea0abe7a455": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1767,13 +2382,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_d690ed1451e74799a2c4c265cd562ed9", + "layout": "IPY_MODEL_561ce5b2a5cb4b73b79e65649f717c94", "placeholder": "​", - "style": "IPY_MODEL_f89679f445424ec1ba2203fb8f7753de", + "style": "IPY_MODEL_60b96dbb352549c4a8be44f2b7e58027", "value": "Downloading: 100%" } }, - "3c3189d90a404112ac7f6081acab7e61": { + "d4319560e75e4f2b8e0a08ed51236f4d": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -1789,15 +2404,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_735b5f02606d4c0288f70469a8ab2902", - "max": 1921, + "layout": "IPY_MODEL_caec2fe41ae044b9aa5f983799041d91", + "max": 1920, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_0308a7a44b8b4a9cae7bda21fbad99f5", - "value": 1921 + "style": "IPY_MODEL_372a6b4d550145a1a18243918b34b377", + "value": 1920 } }, - "34e0fb65b69d470099506bd24362c52c": { + "c54ff0533893489886d4e5f42c089864": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1812,13 +2427,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_967a5451e89049b4ac4688338495b50e", + "layout": "IPY_MODEL_7ab33c4be8454daf98c86aff05d14966", "placeholder": "​", - "style": "IPY_MODEL_bb655ffda271431892bba5ebab9fd93b", - "value": " 1.92k/1.92k [00:00<00:00, 50.8kB/s]" + "style": "IPY_MODEL_8b205b8a31754b038e3c90234c0f0ba0", + "value": " 1.92k/1.92k [00:00<00:00, 51.3kB/s]" } }, - "c697909d569d40918acd835108e29ae7": { + "b96775d8306849e6929d1565f36905cc": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1870,7 +2485,7 @@ "width": null } }, - "d690ed1451e74799a2c4c265cd562ed9": { + "561ce5b2a5cb4b73b79e65649f717c94": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1922,7 +2537,7 @@ "width": null } }, - "f89679f445424ec1ba2203fb8f7753de": { + "60b96dbb352549c4a8be44f2b7e58027": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1937,7 +2552,7 @@ "description_width": "" } }, - "735b5f02606d4c0288f70469a8ab2902": { + "caec2fe41ae044b9aa5f983799041d91": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1989,7 +2604,7 @@ "width": null } }, - "0308a7a44b8b4a9cae7bda21fbad99f5": { + "372a6b4d550145a1a18243918b34b377": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -2005,7 +2620,7 @@ "description_width": "" } }, - "967a5451e89049b4ac4688338495b50e": { + "7ab33c4be8454daf98c86aff05d14966": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2057,7 +2672,7 @@ "width": null } }, - "bb655ffda271431892bba5ebab9fd93b": { + "8b205b8a31754b038e3c90234c0f0ba0": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2072,7 +2687,7 @@ "description_width": "" } }, - "f7626a7dae2a421ba31a578746be491d": { + "78d4e56cedd24c158e32f8c4ca061e75": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -2087,14 +2702,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_97d03beea7cb4e479e1ee67edfa5f883", - "IPY_MODEL_00751b0ca24b47c1b7d337a5b17fc6c1", - "IPY_MODEL_9fc668b6710c449e898d4b8401fe974c" + "IPY_MODEL_660b0d137ed6440eaec4b614edcfe6be", + "IPY_MODEL_0c318128b3794483b12795e1e0bc54ac", + "IPY_MODEL_cbacee0f58b0487397e221873f3d383a" ], - "layout": "IPY_MODEL_d0ea1fb45fe24bc3b549acc4e05860cd" + "layout": "IPY_MODEL_00ad3a57fd1c4a119248499c170a78ab" } }, - "97d03beea7cb4e479e1ee67edfa5f883": { + "660b0d137ed6440eaec4b614edcfe6be": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2109,13 +2724,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_c15d7b4b314b4fb1beb5e8b001114392", + "layout": "IPY_MODEL_3435da3dd0404ae8ab0961731a9a0401", "placeholder": "​", - "style": "IPY_MODEL_6f73694403ae46538b7280ab31657ebc", + "style": "IPY_MODEL_50343a8f410344c799b8abb5253dac33", "value": "Downloading: 100%" } }, - "00751b0ca24b47c1b7d337a5b17fc6c1": { + "0c318128b3794483b12795e1e0bc54ac": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -2131,15 +2746,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_f33d2ce982144ced87a7a834fe83bdb8", - "max": 5534328, + "layout": "IPY_MODEL_fd03191952134e42a881743e5c51d2db", + "max": 83316686, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_7693042eb27e4994b86ed1afb293be56", - "value": 5534328 + "style": "IPY_MODEL_ba7d97dcd55943e996ab08c25c7f8239", + "value": 83316686 } }, - "9fc668b6710c449e898d4b8401fe974c": { + "cbacee0f58b0487397e221873f3d383a": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2154,13 +2769,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_fd6ccdba0a2746419e744035e1096bf2", + "layout": "IPY_MODEL_bc19cd2362504c05882bee1ad32fc4dc", "placeholder": "​", - "style": "IPY_MODEL_2dc0b625a4ff4a60abc4fa3c6671c9ab", - "value": " 5.53M/5.53M [00:00<00:00, 28.0MB/s]" + "style": "IPY_MODEL_3e667b4863c3479cb0cce455558e0ff4", + "value": " 83.3M/83.3M [00:01<00:00, 56.8MB/s]" } }, - "d0ea1fb45fe24bc3b549acc4e05860cd": { + "00ad3a57fd1c4a119248499c170a78ab": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2212,7 +2827,7 @@ "width": null } }, - "c15d7b4b314b4fb1beb5e8b001114392": { + "3435da3dd0404ae8ab0961731a9a0401": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2264,7 +2879,7 @@ "width": null } }, - "6f73694403ae46538b7280ab31657ebc": { + "50343a8f410344c799b8abb5253dac33": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2279,7 +2894,7 @@ "description_width": "" } }, - "f33d2ce982144ced87a7a834fe83bdb8": { + "fd03191952134e42a881743e5c51d2db": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2331,7 +2946,7 @@ "width": null } }, - "7693042eb27e4994b86ed1afb293be56": { + "ba7d97dcd55943e996ab08c25c7f8239": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -2347,7 +2962,7 @@ "description_width": "" } }, - "fd6ccdba0a2746419e744035e1096bf2": { + "bc19cd2362504c05882bee1ad32fc4dc": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2399,7 +3014,7 @@ "width": null } }, - "2dc0b625a4ff4a60abc4fa3c6671c9ab": { + "3e667b4863c3479cb0cce455558e0ff4": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2414,7 +3029,7 @@ "description_width": "" } }, - "0552df02d084406da5b7c51e18fd2cb0": { + "3f152784ff7947668e1eb4d890c31043": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -2429,14 +3044,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_f61c385e5fa542a98652a434ad4cd324", - "IPY_MODEL_923af70854ad4651bd2d2a8556ab59f6", - "IPY_MODEL_170805a3d7ec457aaacd4d9a0acd09d0" + "IPY_MODEL_92bc59fb29444d99b5420ea92b63d873", + "IPY_MODEL_e89ebbf536a7415d92cdb9bb0e40bd23", + "IPY_MODEL_9157ace3987147e8afd845b0b4de5365" ], - "layout": "IPY_MODEL_14713e02e5734e46bfb9f9f815699e39" + "layout": "IPY_MODEL_1349e97c6e10422ab22d2df65f62f236" } }, - "f61c385e5fa542a98652a434ad4cd324": { + "92bc59fb29444d99b5420ea92b63d873": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2451,13 +3066,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_bea9fb28848d4c3da10df4fec3dfdb6b", + "layout": "IPY_MODEL_87ca9dd3c5cf4bf5b6a3d9afb2b97ad7", "placeholder": "​", - "style": "IPY_MODEL_a296598d7d3040e8b8b4dab4f7819e91", + "style": "IPY_MODEL_117925349b764bc883f076c76855b146", "value": "Downloading: 100%" } }, - "923af70854ad4651bd2d2a8556ab59f6": { + "e89ebbf536a7415d92cdb9bb0e40bd23": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -2473,15 +3088,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_ab878626da504834b827f1762bcd2c20", - "max": 128619, + "layout": "IPY_MODEL_0b96234b8a464e6098f2f1f9aae445e2", + "max": 1921, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_f5a6de62a96340f4ab3094f08e8d54ef", - "value": 128619 + "style": "IPY_MODEL_c8c29f7f5dbe45798166423d21d0479a", + "value": 1921 } }, - "170805a3d7ec457aaacd4d9a0acd09d0": { + "9157ace3987147e8afd845b0b4de5365": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2496,13 +3111,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_af1e4e3e52304c51a46eab4b989a3f0b", + "layout": "IPY_MODEL_b1f39d703abf405188d7a8c99500077b", "placeholder": "​", - "style": "IPY_MODEL_b0b8bb8fe0bc47908273136304cf4870", - "value": " 129k/129k [00:00<00:00, 210kB/s]" + "style": "IPY_MODEL_5333f14482954ab58224e858cd3144d3", + "value": " 1.92k/1.92k [00:00<00:00, 6.93kB/s]" } }, - "14713e02e5734e46bfb9f9f815699e39": { + "1349e97c6e10422ab22d2df65f62f236": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2554,7 +3169,7 @@ "width": null } }, - "bea9fb28848d4c3da10df4fec3dfdb6b": { + "87ca9dd3c5cf4bf5b6a3d9afb2b97ad7": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2606,7 +3221,7 @@ "width": null } }, - "a296598d7d3040e8b8b4dab4f7819e91": { + "117925349b764bc883f076c76855b146": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2621,7 +3236,7 @@ "description_width": "" } }, - "ab878626da504834b827f1762bcd2c20": { + "0b96234b8a464e6098f2f1f9aae445e2": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2673,7 +3288,7 @@ "width": null } }, - "f5a6de62a96340f4ab3094f08e8d54ef": { + "c8c29f7f5dbe45798166423d21d0479a": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -2689,7 +3304,7 @@ "description_width": "" } }, - "af1e4e3e52304c51a46eab4b989a3f0b": { + "b1f39d703abf405188d7a8c99500077b": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2741,7 +3356,7 @@ "width": null } }, - "b0b8bb8fe0bc47908273136304cf4870": { + "5333f14482954ab58224e858cd3144d3": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2755,908 +3370,699 @@ "_view_name": "StyleView", "description_width": "" } - } - } - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "nxNf1l8Ye_U9" - }, - "source": [ - "[`pyannote.audio`](https://github.com/pyannote/pyannote-audio) is an open-source toolkit written in Python for **speaker diarization**. \n", - "\n", - "Based on [`PyTorch`](https://pytorch.org) machine learning framework, it provides a set of trainable end-to-end neural building blocks that can be combined and jointly optimized to build speaker diarization pipelines. \n", - "\n", - "`pyannote.audio` also comes with pretrained [models](https://huggingface.co/models?other=pyannote-audio-model) and [pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) covering a wide range of domains for voice activity detection, speaker segmentation, overlapped speech detection, speaker embedding reaching state-of-the-art performance for most of them. \n", - "\n", - "**This notebook will teach you how to apply those pretrained pipelines on your own data.**\n", - "\n", - "Make sure you run it using a GPU (or it might otherwise be slow...)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "42nBTa_QgooG" - }, - "source": [ - "## Installation" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "vJGyKTQJqdzq", - "outputId": "28eabcb6-b64b-4e78-9dc0-a181797c3e84", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "source": [ - "# for speechbrain\n", - "!pip install -qq torch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 torchtext==0.12.0\n", - "!pip install -qq speechbrain==0.5.12\n", - "\n", - "# pyannote.audio\n", - "!pip install -qq pyannote.audio\n", - "\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" - }, - "source": [ - "# Visualization with `pyannote.core`\n", - "\n", - "For the purpose of this notebook, we will download and use an audio file coming from the [AMI corpus](http://groups.inf.ed.ac.uk/ami/corpus/), which contains a conversation between 4 people in a meeting room." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "w7YuPI28qlwZ" - }, - "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" - }, - "source": [ - "Because AMI is a benchmarking dataset, it comes with manual annotations (a.k.a *groundtruth*). \n", - "Let us load and visualize the expected output of the speaker diarization pipeline.\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "1pra1iVnrp5D" - }, - "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", - "metadata": { - "id": "aj1obYqhr3Qk", - "outputId": "2b1e6b24-c355-4edb-bf8f-46c1bd7f92d2", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 118 - } - }, - "source": [ - "# load groundtruth\n", - "from pyannote.database.util import load_rttm\n", - "_, groundtruth = load_rttm('ES2004a.rttm').popitem()\n", - "\n", - "# visualize groundtruth\n", - "groundtruth" - ], - "execution_count": 6, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" + }, + "275133746d524f099c8ec736f157a1bd": { + "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_f7dbef43a8c14f77bbcca6a02a02970b", + "IPY_MODEL_543a7cfb2e4b49d39cd35f63d49a7386", + "IPY_MODEL_cf9bc7d009994525b9a4edbdd02e291d" ], - "image/png": "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\n" - }, - "metadata": {}, - "execution_count": 6 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JDhKjfUBlsjH" - }, - "source": [ - "For the rest of this notebook, we will only listen to and visualize a one-minute long excerpt of the file (but will process the whole file anyway)." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "YAa_HoA9mnTZ", - "outputId": "6ff35b05-9b2c-49fa-bd4b-b674a44c7118", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 117 - } - }, - "source": [ - "from pyannote.core import Segment, notebook\n", - "# make notebook visualization zoom on 600s < t < 660s time range\n", - "EXCERPT = Segment(600, 660)\n", - "notebook.crop = EXCERPT\n", - "\n", - "# visualize excerpt groundtruth\n", - "groundtruth" - ], - "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" - }, - "source": [ - "This nice visualization is brought to you by [`pyannote.core`](http://pyannote.github.io/pyannote-core/) and basically indicates when each speaker speaks. " - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "62flXtNIsA9q", - "outputId": "7fe6edc9-194b-45c5-d3fb-973bf0553282", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 119 - } - }, - "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" - ] + "layout": "IPY_MODEL_f5f78e586cd24028b83887ded99f43bc" + } }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ], - "text/html": [ - "\n", - " \n", - " " - ] - }, - "metadata": {}, - "execution_count": 8 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "xD7QfHCHEIgE" - }, - "source": [ - "# Processing your own audio file (optional)\n", - "\n", - "In case you just want to go ahead with the demo file, skip this section entirely.\n", - "\n", - "In case you want to try processing your own audio file, proceed with running this section. It will offer you to upload an audio file (preferably a `wav` file but all formats supported by [`SoundFile`](https://pysoundfile.readthedocs.io/en/latest/) should work just fine)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CKsR0OZqLj1d" - }, - "source": [ - "## Upload audio file" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "HQRCi0C7EHor", - "outputId": "79a008b1-6ae9-48bd-b57a-22af28d1341b", - "colab": { - "resources": { - "http://localhost:8080/nbextensions/google.colab/files.js": { - "data": "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", - "ok": true, - "headers": [ - [ - "content-type", - "application/javascript" - ] - ], - "status": 200, - "status_text": "OK" - } - }, - "base_uri": "https://localhost:8080/", - "height": 121 - } - }, - "source": [ - "import google.colab\n", - "own_file, _ = google.colab.files.upload().popitem()\n", - "OWN_FILE = {'audio': own_file}\n", - "notebook.reset()\n", - "\n", - "# load audio waveform and play it\n", - "waveform, sample_rate = Audio()(OWN_FILE)\n", - "IPythonAudio(data=waveform.squeeze(), rate=sample_rate, autoplay=True)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " Upload widget is only available when the cell has been executed in the\n", - " current browser session. Please rerun this cell to enable.\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {} + "f7dbef43a8c14f77bbcca6a02a02970b": { + "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_bdbd0f99d45d4c86b6b5a69e11feec51", + "placeholder": "​", + "style": "IPY_MODEL_4db259c505014ab68783a3ff2a128afe", + "value": "Downloading: 100%" + } + }, + "543a7cfb2e4b49d39cd35f63d49a7386": { + "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_86bfddc1dfe44f2d8f96ccbd0dcebb2a", + "max": 5534328, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_621c3ec473b3414a95f6b0f7df2898ea", + "value": 5534328 + } + }, + "cf9bc7d009994525b9a4edbdd02e291d": { + "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_a78cb85112ad404ca6172b216b679767", + "placeholder": "​", + "style": "IPY_MODEL_7e432a87cb0d4571bdc52cfcaae702b7", + "value": " 5.53M/5.53M [00:00<00:00, 13.3MB/s]" + } + }, + "f5f78e586cd24028b83887ded99f43bc": { + "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 + } + }, + "bdbd0f99d45d4c86b6b5a69e11feec51": { + "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 + } + }, + "4db259c505014ab68783a3ff2a128afe": { + "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": "" + } + }, + "86bfddc1dfe44f2d8f96ccbd0dcebb2a": { + "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 + } }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Saving sample.wav to sample.wav\n" - ] + "621c3ec473b3414a95f6b0f7df2898ea": { + "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": "" + } }, - { - "output_type": "execute_result", - "data": { - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 7 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "dLDSdzCuI0ED" - }, - "source": [ - "Simply replace `DEMO_FILE` by `OWN_FILE` in the rest of the notebook.\n", - "\n", - "Note, however, that unless you provide a groundtruth annotation in the next cell, you will (obviously) not be able to visualize groundtruth annotation nor evaluate the performance of the diarization pipeline quantitatively" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "numGt3msL39D" - }, - "source": [ - "## Upload groundtruth (optional)\n", - "\n", - "The groundtruth file is expected to use the RTTM format, with one line per speech turn with the following convention:\n", - "\n", - "```\n", - "SPEAKER {file_name} 1 {start_time} {duration} {speaker_name} \n", - "```" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "f5u8wRm3GYFr", - "colab": { - "resources": { - "http://localhost:8080/nbextensions/google.colab/files.js": { - "data": "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", - "ok": true, - "headers": [ - [ - "content-type", - "application/javascript" - ] - ], - "status": 200, - "status_text": "OK" - } - }, - "base_uri": "https://localhost:8080/", - "height": 193 + "a78cb85112ad404ca6172b216b679767": { + "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 + } }, - "outputId": "a0c2b7a7-177d-430c-fc7e-d93d168aaf90" - }, - "source": [ - "groundtruth_rttm, _ = google.colab.files.upload().popitem()\n", - "groundtruths = load_rttm(groundtruth_rttm)\n", - "if OWN_FILE['audio'] in groundtruths:\n", - " groundtruth = groundtruths[OWN_FILE['audio']]\n", - "else:\n", - " _, groundtruth = groundtruths.popitem()\n", - "groundtruth" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " Upload widget is only available when the cell has been executed in the\n", - " current browser session. Please rerun this cell to enable.\n", - " \n", - " " + "7e432a87cb0d4571bdc52cfcaae702b7": { + "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": "" + } + }, + "a88fb04c89834c48b922f6ff14632c87": { + "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_4176f6e114d04cc3af8fd00c9405ab48", + "IPY_MODEL_c7250d3a8d044265a1c3d098585a0117", + "IPY_MODEL_cf5c362276004feab43dce3cc80ea945" ], - "text/plain": [ - "" - ] - }, - "metadata": {} + "layout": "IPY_MODEL_9a8a9f130bf544949914b972e1cb302f" + } }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Saving sample.rttm to sample.rttm\n" - ] + "4176f6e114d04cc3af8fd00c9405ab48": { + "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_1697e1466f514b89b6fae0edf8f48bd7", + "placeholder": "​", + "style": "IPY_MODEL_9aa6ef23552e4b91ad9ca6c897c17579", + "value": "Downloading: 100%" + } }, - { - "output_type": "execute_result", - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 8 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ByXlUaTfneEB" - }, - "source": [ - "# Speaker diarization with `pyannote.pipeline`\n", - "\n", - "We are about to run a full speaker diarization pipeline, that includes speaker segmentation, speaker embedding, and a final clustering step. **Brace yourself!**" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "go1wJBYJnsIx", - "outputId": "2c496b59-b574-4f30-80df-059b5ccb71f7", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 273, - "referenced_widgets": [ - "5da54fdb45e1485badd323232321bc96", - "e6f461cb90cc498da90a20f2a6c610e0", - "3e8a884bd6c94a86a324cfa7b9580ea7", - "0b03a220e59848dfafb6411b24c3b37f", - "001a4d8dd8954706802b3add70f34d4b", - "b950f7fe8ea34776bde01ed2f4244f5f", - "f7b175bb312c4f43809c97f98e6e84a3", - "e0c6b8aff2ad4849b3dac392ee388112", - "8ddd76365cfd4408b8ca12309b183967", - "df8dc69ca1cf4e57bfebf4762c0460f0", - "799487c4c6de471c827f120f1c11d9e2", - "9d713ac6d10949fb8d277286d969ad3b", - "e2be4344fe8e4a36be35513041ea74a3", - "2ed58d60a46d4f8491de7ad61d7cc589", - "4ea0432a604e4ac197999debb131c557", - "21cd4080794342dbb3209df737d4f835", - "5cdd23be0a804fd192b6ccaddcb52964", - "889aca71e695487d9cd31c2dae585a64", - "b9fc636fcc6f4a2785999385cd340ab9", - "ebf9284b6e514698b8c7389c758f7520", - "5749dba1be9b4eaaad17928a90ea411c", - "f0f3451d91bf4c5a9a8e20623a7b528d", - "0f8ee54b3031408da0281f7aa98eff25", - "ff89e65846414100b84b1f9cf8b70fd9", - "a950bac54c5742e79cd2de4fda29c2e0", - "3f5459fa25654a76bfec64d1dcb542b6", - "fa10eb9e43fd43a49934cdb4301aefff", - "547cbb166dba40d1b626bd204ff3cf96", - "a2aba4e8152c4fbda91bf59a42f25604", - "69a8212dded54f79adf3f8b60b9eb000", - "25142cfd61084c128fe39adad5016109", - "7e64327fa6e948edae034c8d52bb96b4", - "32895abb57a7426aa089230aa49cfff2", - "747aa6596d1a4b04a6f77e38179776ad", - "e65942656e2347eba0a3fe3ae872159b", - "6e5c84bfa614482b960be701f92ee22c", - "def1205f95274d3db0fafc9c8dd1c913", - "46a04e196f9e461bb43e541270022b8d", - "18a02eecf49746cc972882c2cca9ded2", - "31e65957ea204c1084119e3e39528832", - "aa6ccf1390cc4139b7ba23ea7129b273", - "264cde3fae9d442abdb74b4d45288be3", - "2c28a61cfa474c7498a8381e74639530", - "5895a4011e3143a1931566822a65fd50", - "43ada2ceb8ad44d7b8c1a3a1d0aefe2d", - "42b71601aeef4271ac150288a78bf66a", - "300b503e606147bb8bc9ff7a98be0bac", - "dcce36fe0b0946aaa484ae1f5f7eb6da", - "5beb3def5ae64f05b3ceb26c611dcb79", - "030181ab29c149dfaf4940ea2c713190", - "cdec3493e32e49a1abc5f3c6783a49d9", - "b0efbf56235f4f9f866137c85ea2e189", - "12bee4747bc74073bf4cbfd36f0445cb", - "cb0fc23346fa4b638c3cce496ac6cd70", - "0200715daa5e4f4e8f7839d2ea579f19", - "892182c8c97d426d9acf5467d1354d32", - "32acc8ab3c5643d7a4c3595fd67da269", - "3c3189d90a404112ac7f6081acab7e61", - "34e0fb65b69d470099506bd24362c52c", - "c697909d569d40918acd835108e29ae7", - "d690ed1451e74799a2c4c265cd562ed9", - "f89679f445424ec1ba2203fb8f7753de", - "735b5f02606d4c0288f70469a8ab2902", - "0308a7a44b8b4a9cae7bda21fbad99f5", - "967a5451e89049b4ac4688338495b50e", - "bb655ffda271431892bba5ebab9fd93b", - "f7626a7dae2a421ba31a578746be491d", - "97d03beea7cb4e479e1ee67edfa5f883", - "00751b0ca24b47c1b7d337a5b17fc6c1", - "9fc668b6710c449e898d4b8401fe974c", - "d0ea1fb45fe24bc3b549acc4e05860cd", - "c15d7b4b314b4fb1beb5e8b001114392", - "6f73694403ae46538b7280ab31657ebc", - "f33d2ce982144ced87a7a834fe83bdb8", - "7693042eb27e4994b86ed1afb293be56", - "fd6ccdba0a2746419e744035e1096bf2", - "2dc0b625a4ff4a60abc4fa3c6671c9ab", - "0552df02d084406da5b7c51e18fd2cb0", - "f61c385e5fa542a98652a434ad4cd324", - "923af70854ad4651bd2d2a8556ab59f6", - "170805a3d7ec457aaacd4d9a0acd09d0", - "14713e02e5734e46bfb9f9f815699e39", - "bea9fb28848d4c3da10df4fec3dfdb6b", - "a296598d7d3040e8b8b4dab4f7819e91", - "ab878626da504834b827f1762bcd2c20", - "f5a6de62a96340f4ab3094f08e8d54ef", - "af1e4e3e52304c51a46eab4b989a3f0b", - "b0b8bb8fe0bc47908273136304cf4870" - ] - } - }, - "source": [ - "from pyannote.audio import Pipeline\n", - "pipeline = Pipeline.from_pretrained('pyannote/speaker-diarization')\n", - "diarization = pipeline(DEMO_FILE)" - ], - "execution_count": 9, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "Downloading: 0%| | 0.00/598 [00:00" - ], - "image/png": "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\n" - }, - "metadata": {}, - "execution_count": 10 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "smAd5ofBqWWB" - }, - "source": [ - "# Evaluation with `pyannote.metrics`\n", - "\n", - "Because groundtruth is available, we can evaluate the quality of the diarization pipeline by computing the [diarization error rate](http://pyannote.github.io/pyannote-metrics/reference.html#diarization)." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "z0Ore3eGpNyy" - }, - "source": [ - "from pyannote.metrics.diarization import DiarizationErrorRate\n", - "metric = DiarizationErrorRate()\n", - "der = metric(groundtruth, diarization)" - ], - "execution_count": 11, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "e0F8IUaqYFU8", - "outputId": "4de50c4e-640a-46d2-d412-c7242cccb263", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "source": [ - "print(f'diarization error rate = {100 * der:.1f}%')" - ], - "execution_count": 12, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "diarization error rate = 18.4%\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2w0Xp_ElrYTa" - }, - "source": [ - "This implementation of diarization error rate is brought to you by [`pyannote.metrics`](http://pyannote.github.io/pyannote-metrics/).\n", - "\n", - "It can also be used to improve visualization by find the optimal one-to-one mapping between groundtruth and hypothesized speakers." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "WPF5JG3Ppt9K", - "outputId": "7963cc1e-b26a-4fde-cdb0-d72057975dd4", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 117 - } - }, - "source": [ - "mapping = metric.optimal_mapping(groundtruth, diarization)\n", - "diarization.rename_labels(mapping=mapping)" - ], - "execution_count": 13, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAABH0AAACsCAYAAADmO9AtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAARnUlEQVR4nO3de5BtV10n8O9PrmAGHxCTURT0xhTEIoghXJ1gGSviaNBQSWBQo1LADDWCCpZVvlCr5MYZpoaHwwxYRkTiYBEMVEpCildIWfj4J+ANueRBzBgETGJAcQadkJgY8vOP3rfS9O1zb6f7dJ8+qz+fqq57zr5r715n9e/sXv2tvfap7g4AAAAAY/myRXcAAAAAgPkT+gAAAAAMSOgDAAAAMCChDwAAAMCAhD4AAAAAAxL6AAAAAAxI6AMAAAAwIKEPAAAAwICEPgAAAAADEvoAAAAADGiY0KeqvlhVh1d97a+qc6rqH9ds//cz2r9i2n5KVX24qm6rqndU1SOn7d9TVR+tqgeq6nmrvu83T9sPV9XNVfXSxYzA/C1qTKf/+6aq+mBV3VJVH6+q/Tv9+rdDVXVVvW3V831V9fdV9Z7p+Yum56vH8cnT2N+7ZvsLpn2eXlU3TuP7hqqqafsPTzX5YFUdWKcv31RVd1fVL+zU6wcAAGDn7Ft0B+bo3u4+Y/WGKSj48+5+9kbaT16d5PXdfXlV/U6SFye5JMnfJHlRkrV/IN+V5BndfV9VfWWSm6rqqu7+2y29mt1hUWOaJH+Q5FXdfc00rg9u+lXsLl9I8pSqOqG7703y/UnuXNPmHd39stUbpnH/xIzxvSTJf07y4STvS/KsJO9PclOS5yZ504y+/I+pHQAAAAMa5kqfeZiukHhmkiumTW9NcmGSdPenuvuGrAkfuvv+7r5vevqoGNMvsZkxraonJ9nX3ddM7e7u7nt2rtfb7n1Jzpse/1iSP9zsgarqcUm+uruv7e7OSlh2ZHxv6e5bZ+x3YZJPJrl5s98bAACA3W2kgOKEVcte3rVq+9lrlsScuk77w1X1o0m+Nsnnu/uBqc0dSb7xeN+4qp5QVTckuT3Jqwe5yidZ3Jg+Kcnnq+qPqur6qnptVT1ivi9toS5PclFVfUWSp2blCp3VfnTNOJ4wbT91zfazszKWd6za97jjO1059ctJLp7LqwEAAGBX2pblXWe98uqDSV45x0NefO3F5x48TptZS4s2vBSpqk7aTOe6+/YkT62qb0hyZVVd0d2f3cyxZjn/yvMOZs5jetWF7z14nDaLGtN9Sc5O8rSsLAF7R1aWgb1lE8ea6U0XvO1g5jymL3n38w8er1F33zAt1/qxrFz1s9Z6y7uSdZZ3rXevng04mJXldndPxwUAAGBAI13pMw//kOQxVXUkDHt8jr7fykzTFT43ZSWwYMVmxvSOJIe7+6+nK4SuTHLmNvZxEa5K8rpsYWnX5M6sjOkRGxnff5fkNVX1qSQ/l+RXq+plx94FAACAZSP0WWW6J8qHkhz5JKkXJnn3sfapqscfWX5TVY9N8t1J1r2Pyl60mTFN8hdZCYpOnp4/M8nHt6eHC3Npkou7+8atHKS770ryT1V11nT/pBfkOOPb3Wd39/7u3p/kfyb5b939W1vpBwAAALtPrfxNvvyq6u7u/so1287Jyh/An1y1+b929xVV9cUkq//g/kB3v6KqviUr91w5Mcn1SZ4/fTLXdyR5V5LHJvnnJJ/p7tOr6vuT/GaSTlJJfqu7f3d7XuXOWtSYTt/nyLhWkuuS/GR3378dr3MnHWNMf6G7n11VL0ry2nzp1To/neRvk9ySLw0UL+3uN0xLvP53khOy8mlcL+/urqrnJHljkpOTfD4rV0+du+Z7H0xyd3e/bm4vEgAAgF1hmNAHAAAAgIdY3gUAAAAwIKEPAAAAwICEPgAAAAADEvoAAAAADEjoAwAAADCgffM4yEknndT79++fx6EAAAAASHLdddd9rrtP3uz+cwl99u/fn0OHDs3jUAAAAAAkqapPb2V/y7sAAAAABiT0AQAAABiQ0AcAAABgQEIfAAAAgAEJfQAAAAAGJPQBAAAAGJDQBwAAAGBAQh8AAACAAQl9AAAAAAYk9AEAAAAYkNAHAAAAYEBCHwAAAIABCX0AAAAABiT0AQAAABiQ0AcAAABgQEIfAAAAgAEJfQAAAAAGJPQBAAAAGJDQBwAAAGBAQh8AAACAAQl9AAAAAAYk9AEAAAAYkNAHAAAAYEBCHwAAAIABCX0AAAAABiT0AQAAABiQ0AcAAABgQEIfAAAAgAEJfQAAAAAGNJfQ557/e+88DsMSOvSHH9uW4779lsu25bjMj58RW7Xe+WO7zinzMKvmvRfGMY+f5c++811z6Eny5g/ddtS2n7r0I+tuZ/PmNZ7OA7D3LPJ9v1vPObu1X3vdXEKfLwh99qzrLr9xW457+a1v35bjMj9+RmzVeueP7TqnzMOsmvdeGMc8fpYfufnfzKEnyVv+5BNHbbv+0/9v3e1s3rzG03kA9p5Fvu936zlnt/Zrr7O8CwAAAGBAQh8AAACAAe2b14HedMHb5nUoSJKcf+V5i+4CsM2W7XeH89L4tv4z/tmc9cqr59KXWbb7+GyO8wOwk5xz2ChX+gAAAAAMSOgDAAAAMKC5Le96ybufP69DsUS2c2nGVRe+d9uOzda5pJR5WPu7Y7cv91rvvOS9MJat/u456/qrc+3F5265H8dawjWP47NinkvlzFtgb1n07//deM5Z9JiwPlf6AAAAAAxI6AMAAAAwIKEPAAAAwIDmck+fR594wjwOwxJ6+kXfti3Hvei0H9+W4zI/fkZs1Xrnj+06p8zDrJr3XhjHPH6W33n6PXPoSfLic049atvTvvmxOfOUE+dyfFasN86b4TwAe88i3/e79ZyzW/u111V3b/kgBw4c6EOHDs2hOwAAAAAkSVVd190HNru/5V0AAAAAAxL6AAAAAAxI6AMAAAAwIKEPAAAAwICEPgAAAAADEvoAAAAADEjoAwAAADAgoQ8AAADAgIQ+AAAAAAMS+gAAAAAMSOgDAAAAMCChDwAAAMCAhD4AAAAAAxL6AAAAAAxI6AMAAAAwIKEPAAAAwICEPgAAAAADEvoAAAAADEjoAwAAADAgoQ8AAADAgIQ+AAAAAAMS+gAAAAAMSOgDAAAAMCChzxa9/ZbLFro/7KQ3f+i2RXcB4CjOTWNYOyfayBxpvTbmVgDbz+/e5SH02aLLb337QveHnfSWP/nEorsAcBTnpjGsnRNtZI60XhtzK4Dt53fv8hD6AAAAAAxI6AMAAAAwIKEPAAAAwID2LboDIzj/yvMW3QXYMWe98upFdwGAQW1mTmUeBrAY/i5YDq70AQAAABiQ0AcAAABgQJZ3zcFVF7530/u6JJllc+3F5y66CwBfwuXl41g9p9roHGntPMzcCmBn+LtgZ9RvbG1/V/oAAAAADEjoAwAAADAgoc8WXXTajy90f9hJLz7n1EV3AeAozk1jWDsn2sgcab025lYA28/v3uVR3b3lgxw4cKAPHTo0h+4AAAAAkCRVdV13H9js/q70AQAAABiQ0AcAAABgQEIfAAAAgAEJfQAAAAAGJPQBAAAAGJDQBwAAAGBAQh8AAACAAQl9AAAAAAYk9AEAAAAYkNAHAAAAYEBCHwAAAIABCX0AAAAABiT0AQAAABiQ0AcAAABgQEIfAAAAgAEJfQAAAAAGJPQBAAAAGJDQBwAAAGBAQh8AAACAAQl9AAAAAAYk9AEAAAAYkNAHAAAAYEBCHwAAAIABCX0AAAAABiT0AQAAABiQ0AcAAABgQEIfAAAAgAEJfQAAAAAGJPQBAAAAGFB199YPUvX/k9y69e7ArnZSks8tuhOwzdQ5e4E6Zy9Q5+wF6py94LTu/qrN7rxvTp24tbsPzOlYsCtV1SF1zujUOXuBOmcvUOfsBeqcvaCqDm1lf8u7AAAAAAYk9AEAAAAY0LxCn9+d03FgN1Pn7AXqnL1AnbMXqHP2AnXOXrClOp/LjZwBAAAA2F0s7wIAAAAY0IZCn6p6TFVdUVV/WVW3VNUzqurEqrqmqv5q+vexU9uqqjdU1W1VdUNVnbm9LwHmY0ad/3BV3VxVD1bVgTXtf2Wq81ur6txF9Rsejhl1/trp+Q1V9a6qesyq9uqcpTOjzv/LVOOHq+qDVfUNU1vzFpbSenW+6v9+vqq6qk6anqtzltKM8/nBqrpzOp8frqofWtXevIWlM+t8XlUvn7bdXFWvWdX+YdX5Rq/0+V9JPtDd35rk25PckuQVSf64u5+Y5I+n50nyg0meOH39ZJJLNvg9YNHWq/Obkjw3yZ+tblhVT05yUZLTkzwryW9X1SN2truwKevV+TVJntLdT03yf5L8SqLOWWrr1flru/up3X1Gkvck+fWprXkLy2q9Ok9VPSHJDyT5m1Vt1TnLat06T/L67j5j+npfYt7CUjuqzqvqe5NckOTbu/v0JK9LNlfnxw19quprknxPkrckSXff392fnzrw1qnZW5NcOD2+IMkf9Iprkzymqh73MF4w7LhZdd7dt3T3revsckGSy7v7vu7+ZJLbknznzvUYHr5j1PkHu/uBqdm1SR4/PVbnLJ1j1Pk/rWr26CRHbmpo3sLSOcb8PElen+SX8lCNJ+qcJXScOl+PeQtL5xh1/lNJ/nt33zdt/7tpl4dd5xu50ueUJH+f5Per6vqq+r2qenSSr+vuu6Y2n0nyddPjb0xy+6r975i2wW42q85nUecso43U+X9K8v7psTpnGc2s86p6VVXdnuQn8tCVPuqcZbRunVfVBUnu7O6PrWmvzllGx5q3vGxaqnhpTbcZiTpnOc2q8yclObuqPlxVf1pV3zG1f9h1vpHQZ1+SM5Nc0t1PS/KFPLSUK0nSKx8B5mPAWGbHrXMYwDHrvKp+LckDSS5bTPdgLmbWeXf/Wnc/ISs1/rLFdRG2bL06P5jkV/NQoAnLbtb5/JIkpyY5I8ldSX5zYT2ErZtV5/uSnJjkrCS/mOSdVVWb+QYbCX3uSHJHd394en7F1KnPHrksdPr3yOVGdyZ5wqr9Hz9tg91sVp3Pos5ZRjPrvKpelOTZSX5iCvITdc5y2sj5/LIk/2F6rM5ZRrPq/JQkH6uqT2Wllj9aVV8fdc5yWrfOu/uz3f3F7n4wyZvz0NIWdc4ymnU+vyPJH03Lcj+S5MEkJ2UTdX7c0Ke7P5Pk9qo6bdr0fUk+nuSqJC+ctr0wybunx1clecH0KQFnJfnHVcvAYFc6Rp3PclWSi6rqUVV1SlZujPiRbe4mbMmsOq+qZ2Xl/g/nd/c9q3ZR5yydY9T5E1c1uyDJX06PzVtYOjPq/KPd/W+7e39378/KHwxnTm3VOUvnGOfz1fejek5WPnglMW9hCR3j79Ark3xvklTVk5I8Msnnsok637fBvrw8yWVV9cgkf53kP2YlMHpnVb04yaeT/MjU9n1JfigrNxS6Z2oLy+CoOq+q5yR5Y5KTk7y3qg5397ndfXNVvTMrb8gHkvxMd39xYT2HjVvvfP4XSR6V5JrpqtFru/ul6pwltl6d/940oXowK/OWl05tzVtYVuvV+SzqnGW1Xp2/oarOyMrtRT6V5CVJYt7CEluvzr+Q5NKquinJ/UleOF2N/7DrvB66ih8AAACAUWzknj4AAAAALBmhDwAAAMCAhD4AAAAAAxL6AAAAAAxI6AMAAAAwIKEPALC0quprq+rw9PWZqrpzenx3Vf32ovsHALBIPrIdABhCVR1Mcnd3v27RfQEA2A1c6QMADKeqzqmq90yPD1bVW6vqz6vq01X13Kp6TVXdWFUfqKovn9o9var+tKquq6qrq+pxi30VAABbI/QBAPaCU5M8M8n5Sd6W5EPd/W1J7k1y3hT8vDHJ87r76UkuTfKqRXUWAGAe9i26AwAAO+D93f0vVXVjkkck+cC0/cYk+5OcluQpSa6pqkxt7lpAPwEA5kboAwDsBfclSXc/WFX/0g/d1PDBrMyHKsnN3f2MRXUQAGDeLO8CAEhuTXJyVT0jSarqy6vq9AX3CQBgS4Q+AMCe1933J3lekldX1ceSHE7yXYvtFQDA1vjIdgAAAIABudIHAAAAYEBCHwAAAIABCX0AAAAABiT0AQAAABiQ0AcAAABgQEIfAAAAgAEJfQAAAAAGJPQBAAAAGNC/Ai8VBrvAw2FYAAAAAElFTkSuQmCC\n" - }, - "metadata": {}, - "execution_count": 13 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "DKk6ePLWp4eB", - "outputId": "e0a18bd2-ebbb-49b1-f2c9-73196177b799", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 117 - } - }, - "source": [ - "groundtruth" - ], - "execution_count": 14, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {}, - "execution_count": 14 + "19d13680d11f48d6938e52743c7f4275": { + "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": "" + } } - ] + } }, - { - "cell_type": "markdown", - "metadata": { - "id": "q4Rjo1aasVS1" - }, - "source": [ - "# Going further \n", - "\n", - "We have only scratched the surface in this introduction. \n", - "\n", - "More details can be found in the [`pyannote.audio` Github repository](https://github.com/pyannote/pyannote-audio).\n" - ] + "colab": { + "provenance": [], + "include_colab_link": true }, - { - "cell_type": "code", - "source": [ - "" - ], - "metadata": { - "id": "wFK33Y6Dfkw3" - }, - "execution_count": null, - "outputs": [] - } - ] + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 } \ No newline at end of file diff --git a/tutorials/training_a_model.ipynb b/tutorials/training_a_model.ipynb index 871ab1d1c..167a48c9a 100644 --- a/tutorials/training_a_model.ipynb +++ b/tutorials/training_a_model.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -202,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -220,17 +220,17 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -252,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -262,7 +262,7 @@ ", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" ] }, - "execution_count": 19, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -280,17 +280,32 @@ "\n", "Speaker diarization is the task of partitioning a given audio stream of recording into according to the speaker identity.\n", "\n", - "[`pyannote/segmentation`](https://hf.co/pyannote/segmentation) is a model that was pretrained to perform speaker diarization, but only locally, on 5s-long audio chunks. " + "[`pyannote/segmentation`](https://hf.co/pyannote/segmentation) is a model that was pretrained to perform speaker diarization, but only locally, on 5s-long audio chunks. \n", + "\n", + "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": 20, + "execution_count": null, + "metadata": {}, + "outputs": [], + "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", - "pretrained = Model.from_pretrained(\"pyannote/segmentation\")" + "pretrained = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)" ] }, { @@ -302,17 +317,17 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": 23, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -331,17 +346,17 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": 22, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -359,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -376,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -409,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -434,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -452,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -543,7 +558,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -575,38 +590,39 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": 37, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "Inference('pyannote/segmentation', step=2.5)(test_file)" + "\n", + "Inference('pyannote/segmentation', use_auth_token=True, step=2.5)(test_file)" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": 38, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -625,14 +641,14 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from pyannote.audio.tasks import OverlappedSpeechDetection\n", "osd_task = OverlappedSpeechDetection(ami, duration=2.0)\n", "\n", - "osd_model = Model.from_pretrained(\"pyannote/segmentation\")\n", + "osd_model = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)\n", "osd_model.task = osd_task" ] }, @@ -645,7 +661,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -669,7 +685,7 @@ " 'lstm']" ] }, - "execution_count": 40, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -687,7 +703,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -778,17 +794,17 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": 46, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -800,17 +816,17 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": 44, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -860,21 +876,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "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.0" } }, "nbformat": 4, From cca33169bb646332d274d81b8469832c81b7cd08 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 21:52:19 +0200 Subject: [PATCH 005/112] doc: update changelog --- CHANGELOG.md | 75 ++++++++++++++++++++++++++++++++++++++++ README.md | 1 + doc/source/changelog.rst | 15 +++++++- 3 files changed, 90 insertions(+), 1 deletion(-) create mode 100644 CHANGELOG.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 000000000..eaba738a5 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,75 @@ +# Changelog + +## Version 2.1 (2022-11-xx) + + - BREAKING(pipeline): rewrite speaker diarization pipeline + - feat(pipeline): add option to optimize for DER variant + - feat(clustering): add support for NeMo speaker embedding + - feat(clustering): add FINCH clustering + - feat(clustering): add min_cluster_size hparams to AgglomerativeClustering + - feat(hub): add support for private/gated models + - setup(hub): switch to latest hugginface_hub API + - fix(pipeline): fix support for missing reference in Resegmentation pipeline + - fix(clustering) fix corner case where HMM.fit finds too little states + +## Version 2.0.1 (2022-07-20) + + - BREAKING: complete rewrite + - feat: much better performance + - feat: Python-first API + - feat: pretrained pipelines (and models) on Huggingface model hub + - feat: multi-GPU training with pytorch-lightning + - feat: data augmentation with torch-audiomentations + - feat: Prodigy recipe for model-assisted audio annotation + +## Version 1.1.2 (2021-01-28) + + - fix: make sure master branch is used to load pretrained models (#599) + +## Version 1.1 (2020-11-08) + + - last release before complete rewriting + +## Version 1.0.1 (2018--07-19) + + - fix: fix regression in Precomputed.__call__ (#110, #105) + +## Version 1.0 (2018-07-03) + + - chore: switch from keras to pytorch (with tensorboard support) + - improve: faster & better traning (`AutoLR`, advanced learning rate schedulers, improved batch generators) + - feat: add tunable speaker diarization pipeline (with its own tutorial) + - chore: drop support for Python 2 (use Python 3.6 or later) + +## Version 0.3.1 (2017-07-06) + + - feat: add python 3 support + - chore: rewrite neural speaker embedding using autograd + - feat: add new embedding architectures + - feat: add new embedding losses + - chore: switch to Keras 2 + - doc: add tutorial for (MFCC) feature extraction + - doc: add tutorial for (LSTM-based) speech activity detection + - doc: add tutorial for (LSTM-based) speaker change detection + - doc: add tutorial for (TristouNet) neural speaker embedding + +## Version 0.2.1 (2017-03-28) + + - feat: add LSTM-based speech activity detection + - feat: add LSTM-based speaker change detection + - improve: refactor LSTM-based speaker embedding + - feat: add librosa basic support + - feat: add SMORMS3 optimizer + +## Version 0.1.4 (2016-09-26) + + - feat: add 'covariance_type' option to BIC segmentation + +## Version 0.1.3 (2016-09-23) + + - chore: rename sequence generator in preparation of the release of + TristouNet reproducible research package. + +## Version 0.1.2 (2016-09-22) + + - first public version diff --git a/README.md b/README.md index 035a03e93..8608d53e3 100644 --- a/README.md +++ b/README.md @@ -59,6 +59,7 @@ pip install pyannote.audio ## Documentation +- [Changelog](CHANGELOG.md) - Models - Available tasks explained - [Applying a pretrained model](tutorials/applying_a_model.ipynb) diff --git a/doc/source/changelog.rst b/doc/source/changelog.rst index be69c3f54..c6a3ff50e 100644 --- a/doc/source/changelog.rst +++ b/doc/source/changelog.rst @@ -2,9 +2,22 @@ Changelog ######### -Version 2.0.1 (2022-07-20) +Version 2.1 (2022-11-xx) ~~~~~~~~~~~~~~~~~~~~~~~~ + - BREAKING(pipeline): rewrite speaker diarization pipeline + - feat(pipeline): add option to optimize for DER variant + - feat(clustering): add support for NeMo speaker embedding + - feat(clustering): add FINCH clustering + - feat(clustering): add min_cluster_size hparams to AgglomerativeClustering + - feat(hub): add support for private/gated models + - setup(hub): switch to latest hugginface_hub API + - fix(pipeline): fix support for missing reference in Resegmentation pipeline + - fix(clustering) fix corner case where HMM.fit finds too little states + +Version 2.0.1 (2022-07-20) +~~~~~~~~~~~~~~~~~~~~~~~~~~ + - BREAKING: complete rewrite - feat: much better performance - feat: Python-first API From b7343ccc0428fb63e71adee108c99996811f23a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 21:52:32 +0200 Subject: [PATCH 006/112] doc: update README --- README.md | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 8608d53e3..15f2a9fe6 100644 --- a/README.md +++ b/README.md @@ -24,13 +24,13 @@ diarization = pipeline("audio.wav") # 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 -# start=1.8s stop=3.9s speaker_B -# start=4.2s stop=5.7s speaker_A +# start=0.2s stop=1.5s speaker_0 +# start=1.8s stop=3.9s speaker_1 +# start=4.2s stop=5.7s speaker_0 # ... ``` -## What's new in `pyannote.audio` 2.0 +## What's new in `pyannote.audio` 2.x? For version 2.x of `pyannote.audio`, [I](https://herve.niderb.fr) decided to rewrite almost everything from scratch. Highlights of this release are: @@ -54,7 +54,7 @@ conda activate pyannote # (see https://pytorch.org/get-started/previous-versions/#v1110) conda install pytorch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 -c pytorch -pip install pyannote.audio +pip install -qq https://github.com/pyannote/pyannote-audio/archive/develop.zip ``` ## Documentation @@ -73,6 +73,9 @@ pip install pyannote.audio - [Adding a new task](tutorials/add_your_own_task.ipynb) - Adding a new pipeline - Sharing pretrained models and pipelines +- Blog + - 2022-10-23 > ["One speaker segmentation model to rule them all"](https://herve.niderb.fr/fastpages/2022/10/23/One-speaker-segmentation-model-to-rule-them-all) + - 2021-08-05 > ["Streaming voice activity detection with pyannote.audio"](https://herve.niderb.fr/fastpages/2021/08/05/Streaming-voice-activity-detection-with-pyannote.html) - Miscellaneous - [Training with `pyannote-audio-train` command line tool](tutorials/training_with_cli.md) - [Annotating your own data with Prodigy](tutorials/prodigy.md) @@ -98,15 +101,19 @@ pip install pyannote.audio ## Benchmark -Out of the box, `pyannote.audio` default speaker diarization pipeline is expected to be much better (and faster) in v2.0 than in v1.1.: - -| Dataset | DER% with v1.1 | DER% with v2.0 | Relative improvement | -| ----------- | -------------- | -------------- | -------------------- | -| AMI | 29.7% | 18.2% | 38% | -| DIHARD | 29.2% | 21.0% | 28% | -| VoxConverse | 21.5% | 12.6% | 41% | - -A more detailed benchmark is available [here](https://hf.co/pyannote/speaker-diarization). +Out of the box, `pyannote.audio` default speaker diarization [pipeline](https://hf.co/pyannote/speaker-diarization) is expected to be much better (and faster) in v2.x than in v1.1. Those numbers are diarization error rates (in %) + +| Dataset \ Version | v1.1 | v2.0 | v2.1 (finetuned) | +| ---------------------- | ---- | ---- | ---------------- | +| AISHELL-4 | - | 14.6 | 14.1 (14.5) | +| AliMeeting (channel 1) | - | - | 27.4 (23.8) | +| AMI (IHM) | 29.7 | 18.2 | 18.9 (18.5) | +| AMI (SDM) | - | 29.0 | 27.1 (22.2) | +| CALLHOME (part2) | - | 30.2 | 32.4 (29.3) | +| DIHARD 3 (full) | 29.2 | 21.0 | 26.9 (21.9) | +| VoxConverse (v0.3) | 21.5 | 12.6 | 11.2 (10.7) | +| REPERE (phase2) | - | 12.6 | 8.2 ( 8.3) | +| This American Life | - | - | 20.8 (15.2) | ## Citations From fc559465dd5e6f6bcd1f565a0bda60c38b17acc3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 21:52:44 +0200 Subject: [PATCH 007/112] setup: bump version --- version.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.txt b/version.txt index 38f77a65b..7ec1d6db4 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -2.0.1 +2.1.0 From 6d9d98c0035a825384b0e4ae3760e786850bc523 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 21:53:26 +0200 Subject: [PATCH 008/112] setup: fix version number --- version.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.txt b/version.txt index 7ec1d6db4..879b416e6 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -2.1.0 +2.1 From 82a07add2ea220a6f00636b06626a74b9324c2d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 22:01:38 +0200 Subject: [PATCH 009/112] git: update version number --- CHANGELOG.md | 2 +- README.md | 22 +++++++++++----------- version.txt | 2 +- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index eaba738a5..0169d74c8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## Version 2.1 (2022-11-xx) +## Version 2.1.1 (2022-10-27) - BREAKING(pipeline): rewrite speaker diarization pipeline - feat(pipeline): add option to optimize for DER variant diff --git a/README.md b/README.md index 15f2a9fe6..388dfb4b5 100644 --- a/README.md +++ b/README.md @@ -103,17 +103,17 @@ pip install -qq https://github.com/pyannote/pyannote-audio/archive/develop.zip Out of the box, `pyannote.audio` default speaker diarization [pipeline](https://hf.co/pyannote/speaker-diarization) is expected to be much better (and faster) in v2.x than in v1.1. Those numbers are diarization error rates (in %) -| Dataset \ Version | v1.1 | v2.0 | v2.1 (finetuned) | -| ---------------------- | ---- | ---- | ---------------- | -| AISHELL-4 | - | 14.6 | 14.1 (14.5) | -| AliMeeting (channel 1) | - | - | 27.4 (23.8) | -| AMI (IHM) | 29.7 | 18.2 | 18.9 (18.5) | -| AMI (SDM) | - | 29.0 | 27.1 (22.2) | -| CALLHOME (part2) | - | 30.2 | 32.4 (29.3) | -| DIHARD 3 (full) | 29.2 | 21.0 | 26.9 (21.9) | -| VoxConverse (v0.3) | 21.5 | 12.6 | 11.2 (10.7) | -| REPERE (phase2) | - | 12.6 | 8.2 ( 8.3) | -| This American Life | - | - | 20.8 (15.2) | +| Dataset \ Version | v1.1 | v2.0 | v2.1.1 (finetuned) | +| ---------------------- | ---- | ---- | ------------------ | +| AISHELL-4 | - | 14.6 | 14.1 (14.5) | +| AliMeeting (channel 1) | - | - | 27.4 (23.8) | +| AMI (IHM) | 29.7 | 18.2 | 18.9 (18.5) | +| AMI (SDM) | - | 29.0 | 27.1 (22.2) | +| CALLHOME (part2) | - | 30.2 | 32.4 (29.3) | +| DIHARD 3 (full) | 29.2 | 21.0 | 26.9 (21.9) | +| VoxConverse (v0.3) | 21.5 | 12.6 | 11.2 (10.7) | +| REPERE (phase2) | - | 12.6 | 8.2 ( 8.3) | +| This American Life | - | - | 20.8 (15.2) | ## Citations diff --git a/version.txt b/version.txt index 879b416e6..3e3c2f1e5 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -2.1 +2.1.1 From d992509ff82e01ae1fcc311c0ec3b3ecb8893b3c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 22:04:37 +0200 Subject: [PATCH 010/112] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 388dfb4b5..1f1340cdd 100644 --- a/README.md +++ b/README.md @@ -54,7 +54,7 @@ conda activate pyannote # (see https://pytorch.org/get-started/previous-versions/#v1110) conda install pytorch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 -c pytorch -pip install -qq https://github.com/pyannote/pyannote-audio/archive/develop.zip +pip install pyannote.audio ``` ## Documentation From 378f7fbe36cd7de46eab991da9c60370addc842b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 27 Oct 2022 22:29:57 +0200 Subject: [PATCH 011/112] =?UTF-8?q?Cr=C3=A9=C3=A9=20avec=20Colaboratory?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tutorials/intro.ipynb | 778 +++++++++++++++++++++--------------------- 1 file changed, 396 insertions(+), 382 deletions(-) diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index 26bba3afb..3f9489aae 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -7,7 +7,7 @@ "colab_type": "text" }, "source": [ - "\"Open" + "\"Open" ] }, { @@ -47,10 +47,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "metadata": { "id": "ai082p4HYnp7", - "outputId": "42816e76-2ab7-4283-82e2-2a60ae199af5", + "outputId": "bb673846-8b58-4743-cea2-6c6270632d7f", "colab": { "base_uri": "https://localhost:8080/" } @@ -60,31 +60,45 @@ "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 |████████████████████████████████| 750.6 MB 10 kB/s \n", + "\u001b[K |████████████████████████████████| 21.0 MB 1.3 MB/s \n", + "\u001b[K |████████████████████████████████| 2.9 MB 55.5 MB/s \n", + "\u001b[K |████████████████████████████████| 10.4 MB 46.0 MB/s \n", + "\u001b[K |████████████████████████████████| 496 kB 25.8 MB/s \n", + "\u001b[K |████████████████████████████████| 1.3 MB 60.6 MB/s \n", + "\u001b[K |████████████████████████████████| 163 kB 70.7 MB/s \n", + "\u001b[K |████████████████████████████████| 109 kB 74.9 MB/s \n", + "\u001b[K |████████████████████████████████| 500 kB 62.8 MB/s \n", + "\u001b[?25h Building wheel for hyperpyyaml (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[K |████████████████████████████████| 390 kB 37.8 MB/s \n", + "\u001b[K |████████████████████████████████| 217 kB 67.2 MB/s \n", + "\u001b[K |████████████████████████████████| 111 kB 75.6 MB/s \n", + "\u001b[K |████████████████████████████████| 529 kB 61.5 MB/s \n", + "\u001b[K |████████████████████████████████| 41 kB 494 kB/s \n", + "\u001b[K |████████████████████████████████| 47 kB 5.5 MB/s \n", + "\u001b[K |████████████████████████████████| 585 kB 62.0 MB/s \n", + "\u001b[K |████████████████████████████████| 60 kB 8.4 MB/s \n", + "\u001b[K |████████████████████████████████| 51 kB 186 kB/s \n", + "\u001b[K |████████████████████████████████| 79 kB 9.3 MB/s \n", + "\u001b[K |████████████████████████████████| 117 kB 78.4 MB/s \n", + "\u001b[K |████████████████████████████████| 130 kB 73.0 MB/s \n", + "\u001b[K |████████████████████████████████| 348 kB 67.7 MB/s \n", + "\u001b[K |████████████████████████████████| 81 kB 10.6 MB/s \n", + "\u001b[K |████████████████████████████████| 209 kB 76.6 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", + "\u001b[K |████████████████████████████████| 112 kB 71.5 MB/s \n", + "\u001b[K |████████████████████████████████| 50 kB 7.0 MB/s \n", + "\u001b[K |████████████████████████████████| 147 kB 60.0 MB/s \n", + "\u001b[?25h 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" + " Building wheel for pyperclip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[K |████████████████████████████████| 793 kB 34.5 MB/s \n", + "\u001b[K |████████████████████████████████| 1.6 MB 56.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", + "google-colab 1.0.0 requires ipython~=7.9.0, but you have ipython 7.34.0 which is incompatible.\u001b[0m\n", + "\u001b[?25h" ] } ], @@ -97,7 +111,7 @@ "!pip install -qq pyannote.audio\n", "\n", "# for visualization purposes\n", - "!pip install -qq moviepy ipython==7.34.0" + "!pip install -qq ipython==7.34.0" ] }, { @@ -113,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": { "id": "uJWoQiJgYnp8" }, @@ -135,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": { "id": "Mmm0Q22JYnp8" }, @@ -146,13 +160,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": { "id": "ToqCwl_FYnp9", - "outputId": "f1487da9-785d-4967-dad1-a2a7f5ef5e9f", + "outputId": "a1d9631f-b198-44d1-ff6d-ec304125a9f4", "colab": { "base_uri": "https://localhost:8080/", - "height": 189 + "height": 233 } }, "outputs": [ @@ -160,12 +174,12 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, - "execution_count": 8 + "execution_count": 3 } ], "source": [ @@ -188,13 +202,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "metadata": { "id": "bAHza4Y1Ynp-", - "outputId": "a24b6611-6fb4-43f9-e5c8-02e00a6479f1", + "outputId": "c4cc2369-bfe4-4ac2-bb71-37602e7c7a8a", "colab": { "base_uri": "https://localhost:8080/", - "height": 189 + "height": 230 } }, "outputs": [ @@ -202,12 +216,12 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, - "execution_count": 9 + "execution_count": 4 } ], "source": [ @@ -231,10 +245,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": { "id": "rDhZ3bXEYnp-", - "outputId": "e94fac2e-5370-419e-9f76-a85cda9702ae", + "outputId": "a82efe4e-2f9c-48bd-94fb-c62af3a3cb43", "colab": { "base_uri": "https://localhost:8080/", "height": 62 @@ -257,7 +271,7 @@ ] }, "metadata": {}, - "execution_count": 10 + "execution_count": 5 } ], "source": [ @@ -453,28 +467,28 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": { "id": "r5u7VMb-YnqB", - "outputId": "433b4f1b-c6fb-4047-be4f-fbfde0d7aa68", + "outputId": "c714a997-d4f8-417a-e5ad-0a4924333859", "colab": { "base_uri": "https://localhost:8080/", - "height": 300, + "height": 301, "referenced_widgets": [ - "a7fd4da8fca94798b977d92ae4f3f2bf", - "cc5fdc26256248cf8dac00fbc314a3c7", - "a134ee5d26c54b04b7a34b5e7671e2cf", - "58e364b0131449659804831baa1fb421", - "7f150092f0984d65882e57c373cce7c4", - "7ee601dd1b8c4a9b9df7c0a0dce0ff3b", - "4e4de9bec49841bb8e77d176511da330", - "343a0bfe7363401b9c00602c547fc609", - "8ae65b22713547ac88aad90600f1ebb0", - "4a4b13ce55944ec985ac6eb3e302e473", - "36bfa883a7bf4306a60bd2f2e9d34c17", - "28a732468d2b43f7b0b66b81aed09305", - "a1e3a0a5f91b4a1282fab3f84918e684", - "775d04d911a347ce8993eac7ae7479d1" + "c8731777ce834e58a76a295076200cfc", + "859b12a6d95b4c6f987791ca848122b9", + "94756148d2e94a93ae233baba20af683", + "ba18cded436e486da34882d821d8f1eb", + "99898e6ee64a46bd832af112e79b58b7", + "79184c8c2a6f4b7493bb7f6983f18a09", + "ea95ffd922c0455d957120f034e541f8", + "13525aa369a9410a83343952ab511f3c", + "b2be65e192384c948fb8987d4cfca505", + "333b42ca7aa44788b1c22724eb11bcc3", + "0e382d66f09f4958a40baa7ab83c4ccb", + "6a45ce374e2e47ba9457d02e02522748", + "765485a1d3f941d28b79782dcffbf401", + "3499ef4dd9f243d9bef00b396e78ed69" ] } }, @@ -495,102 +509,102 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "metadata": { "id": "lUq1UvoJYnqB", - "outputId": "36cd5a49-b762-4ec1-a1e0-0d9471a35b39", + "outputId": "8c052808-d0b2-4f2e-8771-f86114ae3fe3", "colab": { "base_uri": "https://localhost:8080/", "height": 273, "referenced_widgets": [ - "bbbeab96755c4dbea662d7b821c7188f", - "29886bb25e6c444d89bd62fe0d3fc2aa", - "e7d91492ccba4a4fbd35b8b8652ce424", - "8007ece499c343438619420efb1c783d", - "d04b749f32524693a4aff3fc39565688", - "eaf64f20c7ba495480f91d21b54704ef", - "8e2b713e4b7d43658c75b254628f3a10", - "d145e071ff944867afdfcc8182125b40", - "976f00b9aeb04bc985657b018144269b", - "94eec654793d45f4891c7a43217b7e4c", - "6ce2a0b4a07f4acaa80fe11e064e05ed", - "f4ab2f4beedc469a82dc687330003453", - "45dd7efcbbdb49a8ba9e98cffc41447a", - "4653c869270b4a2cad98e970dfe3fc34", - "924ad861916442898392eaae6c44da56", - "796dde241ce44bbabc1403bef156f410", - "f40f7ddb7ebc4dac993b8f6fab2a698d", - "a8f4d54932f94730a8ba41e58253a9c9", - "9099bee7874f41dab13dbffc5479be5d", - "e94e8546d7954a0987da477f3c3b20fd", - "eb032a7f35bd4e4e9ca4328c5d0a52e6", - "49059590a13a4e6f94fff2689c5c06c3", - "b2a14badcc0548f0a056605f456c14ab", - "607b38bc10e24a6fa56f864505b98b5d", - "63ce45b4de184550acaca5b2e38c0a5c", - "b063b8808ee040e9b05311a3e89389f9", - "65b07a137ab44caa9c153803a1bec549", - "a2451a62c0ff4f4287a382db373650ca", - "6d0845291bfc4c76a1bf86e5a0740b6f", - "05d4e5935c09454885057208f89fdd95", - "103ada1efb904aa383b21ae5e0555777", - "845a0f7b2a2a428e81f9870b75aef56a", - "5e5ebb6018a749c1b1b3ca0db5ecc6f5", - "56b7159b3a4c49e69c5130ad14860bd5", - "9db61482ec0349e48d5b7ea0abe7a455", - "d4319560e75e4f2b8e0a08ed51236f4d", - "c54ff0533893489886d4e5f42c089864", - "b96775d8306849e6929d1565f36905cc", - "561ce5b2a5cb4b73b79e65649f717c94", - "60b96dbb352549c4a8be44f2b7e58027", - "caec2fe41ae044b9aa5f983799041d91", - "372a6b4d550145a1a18243918b34b377", - "7ab33c4be8454daf98c86aff05d14966", - "8b205b8a31754b038e3c90234c0f0ba0", - "78d4e56cedd24c158e32f8c4ca061e75", - "660b0d137ed6440eaec4b614edcfe6be", - "0c318128b3794483b12795e1e0bc54ac", - "cbacee0f58b0487397e221873f3d383a", - "00ad3a57fd1c4a119248499c170a78ab", - "3435da3dd0404ae8ab0961731a9a0401", - "50343a8f410344c799b8abb5253dac33", - "fd03191952134e42a881743e5c51d2db", - "ba7d97dcd55943e996ab08c25c7f8239", - "bc19cd2362504c05882bee1ad32fc4dc", - "3e667b4863c3479cb0cce455558e0ff4", - "3f152784ff7947668e1eb4d890c31043", - "92bc59fb29444d99b5420ea92b63d873", - "e89ebbf536a7415d92cdb9bb0e40bd23", - "9157ace3987147e8afd845b0b4de5365", - "1349e97c6e10422ab22d2df65f62f236", - "87ca9dd3c5cf4bf5b6a3d9afb2b97ad7", - "117925349b764bc883f076c76855b146", - "0b96234b8a464e6098f2f1f9aae445e2", - "c8c29f7f5dbe45798166423d21d0479a", - "b1f39d703abf405188d7a8c99500077b", - "5333f14482954ab58224e858cd3144d3", - "275133746d524f099c8ec736f157a1bd", - "f7dbef43a8c14f77bbcca6a02a02970b", - "543a7cfb2e4b49d39cd35f63d49a7386", - "cf9bc7d009994525b9a4edbdd02e291d", - "f5f78e586cd24028b83887ded99f43bc", - "bdbd0f99d45d4c86b6b5a69e11feec51", - "4db259c505014ab68783a3ff2a128afe", - "86bfddc1dfe44f2d8f96ccbd0dcebb2a", - "621c3ec473b3414a95f6b0f7df2898ea", - "a78cb85112ad404ca6172b216b679767", - "7e432a87cb0d4571bdc52cfcaae702b7", - "a88fb04c89834c48b922f6ff14632c87", - "4176f6e114d04cc3af8fd00c9405ab48", - "c7250d3a8d044265a1c3d098585a0117", - "cf5c362276004feab43dce3cc80ea945", - "9a8a9f130bf544949914b972e1cb302f", - "1697e1466f514b89b6fae0edf8f48bd7", - "9aa6ef23552e4b91ad9ca6c897c17579", - "a260382718bd4998a96013e8643f7589", - "44cd14b01a854294b283129db1e6beab", - "80ca456de9084ef18dc13c369f127486", - "19d13680d11f48d6938e52743c7f4275" + "183c55d5d3ce4058ae338c81344547c5", + "70efa83bf3ea45b4bd8cc41f57613328", + "338747810ac74b4e83e356a01459c8a5", + "ac0bcfa1ef6e4e78a7769c4cb2e8762f", + "6efb7939bb954dc8ba116680139eb257", + "6242493d251a47609c0c44f1dbe82958", + "f439c1de68ac4c799d81fdb29d053d10", + "e4c1e9affaba4045a3ec903091b6f454", + "1946386483ed4947a2184cdb4ea6e434", + "549a30c85c47466eadedbd24da42e304", + "bedc7d916b9745f097094c5c51a81f06", + "d12f07e25bf5422facc38c3463700994", + "eae11f84c2644ada8295b445c924baec", + "bcf766d2a2c641f0aa2af596c7da1b18", + "74bf69aa6eaa4a8594b2ea9a0fb20957", + "2d7a0b901d7044d5b1f273a3e9bea560", + "2cbf0faadd4842c8b22e10541ff9de4e", + "ab32c7daa1d9404fb921f39fbc4fc05c", + "ee537ee5470f4d7b816a8c8f96948b4d", + "652e97509a914f3b914665c4889c6d11", + "ebc9801e164a44b3b6f8dc7f590e1c79", + "0821b47ae70444dfa38b84719c4836a6", + "c3358d32ac814ea6bc5714402c5bc62d", + "ecd8e5e364d34ea8bfbba4fbd467384d", + "0125df9fa8e14b3db0e2bce299529812", + "e3169ca885e04536a709d5751173ce9a", + "70abdfd99be84f7b9b8d24fee9eec022", + "554e567a83b348f88092c6ba01830930", + "6e334cad2e94462cae6e722bd6f11a9e", + "407e250e244b4985b1ce8c9d32a8af7d", + "8127c4258e374ad986ce1f8b4c70f704", + "358c3a67f8b54c4c899e095611fa116b", + "e1c9df12fa034c93a9b3530ea4a7c5aa", + "404f7ce06a01470fbb0b747981d00e84", + "38b3054ad59549e4b4f2de4697139a87", + "7d90af87c9574f5ca21fca058c39bf02", + "fee75343289f42fb8d6dfb4bf26fe368", + "f21c0c6379d74898ac6aadcb6fc14a8a", + "0adb304bf90f4079a4031caea1cfb924", + "40021e0b59fe4e1e9bac351dbec57c6c", + "ed169fd606274f2ebbb3e8f32ab42431", + "304e9682570b4abeb1719001c04449d6", + "16c0017f65b649f5ac5bebf1c955a1fd", + "5e2c207db5424f91829bf5c52040a9f2", + "8011d68253ac4080a637659ef3383dc4", + "e928540e99564d808cb2d12c92daa498", + "fc9a3c4ae0a947ec91a227360a80f602", + "f91dcd9f30c743d69f9d4b7e8d1beba5", + "6ede83f870a24e71b5182fcc458cdc42", + "c9974003727a401797953ef2885db5a2", + "77a361d1ff214e8799891bbeb28a0789", + "27f6f437c5264368bc2c679942ad1e53", + "e7728d9c55e44274966f8f6dbc445c54", + "2b2d7912186a49dd9891ae12c77482c7", + "1600b9cd09c446e581b7912e35c9f56e", + "28004251b0e44a6c9dfa7ce1b30dcb18", + "e98cf7a63c814ffd94f69928f0700ebf", + "6a4dee55cbae4959bd7fe3c4d92242b1", + "8dba487876124827919079519406ecb8", + "5c211704f90946afbae2f66a7586ce70", + "aba21021d3bb4565a58ffa40049810db", + "f7812fa7fbf744c1b261b985d085e28e", + "d7071582bfbe4ec4b2c3c9843e5481ae", + "0d80273cabbc42ba9a408fb1144151c9", + "67fcc38a1e5d4eb39381685447e397de", + "0b4bf8076fdf4d19843a3246c8bd61ac", + "d182e37b4a404158bee8446fc2728bd9", + "603e99f45afb4910a99f7684ffd21b6a", + "d13ba6030aff42bca48c72ff071c44c0", + "a899f4bc6ed842d397723cca582669e6", + "a02030ba8f324d93a7ed6cc793d70a3b", + "b26354d0278f447d92c7e1ad4c211d64", + "3bd33a372aad4c438f64d73c97f14c6a", + "c8e0c9a60ef34d2caee9d55a3c21c3d4", + "764aa53d75324d73ab06936c52fd8fc8", + "341615c971b04033b7293d82fc40f35c", + "17856a72e4e948039a66c51e8244cb50", + "41eb32a6fef141ff9cc3ce6e4d771822", + "0d10fb0edc9144b1a1fc1f2c9e322410", + "32accb0adfa24c62a75c15c8ec88df8c", + "bf299285318b4a04a88569cc581ecd75", + "ac2950d08fc145ba9eb9cf5824b1ee18", + "d33fba0d78fb41f983c55f5cd2a0a740", + "fd47487fc8734594823f8afa00c4239d", + "23d4e25ec6c541818d5927b69576d278", + "54d9456703324160aced03ee5fef2943", + "bacfb50c001047c4824a05c9f2ee2e40", + "c53a1cf68fcd4388abf1f0379891089a" ] } }, @@ -604,7 +618,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "bbbeab96755c4dbea662d7b821c7188f" + "model_id": "183c55d5d3ce4058ae338c81344547c5" } }, "metadata": {} @@ -618,7 +632,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "f4ab2f4beedc469a82dc687330003453" + "model_id": "d12f07e25bf5422facc38c3463700994" } }, "metadata": {} @@ -632,7 +646,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "b2a14badcc0548f0a056605f456c14ab" + "model_id": "c3358d32ac814ea6bc5714402c5bc62d" } }, "metadata": {} @@ -646,7 +660,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "56b7159b3a4c49e69c5130ad14860bd5" + "model_id": "404f7ce06a01470fbb0b747981d00e84" } }, "metadata": {} @@ -660,7 +674,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "78d4e56cedd24c158e32f8c4ca061e75" + "model_id": "8011d68253ac4080a637659ef3383dc4" } }, "metadata": {} @@ -674,7 +688,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "3f152784ff7947668e1eb4d890c31043" + "model_id": "28004251b0e44a6c9dfa7ce1b30dcb18" } }, "metadata": {} @@ -688,7 +702,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "275133746d524f099c8ec736f157a1bd" + "model_id": "d182e37b4a404158bee8446fc2728bd9" } }, "metadata": {} @@ -702,7 +716,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "a88fb04c89834c48b922f6ff14632c87" + "model_id": "41eb32a6fef141ff9cc3ce6e4d771822" } }, "metadata": {} @@ -725,13 +739,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": { "id": "DPosdyGrYnqB", - "outputId": "d0f7cd67-edab-4748-dfb4-24a12eaa7f89", + "outputId": "45a2315e-6841-4de4-e54e-1f3da7cf2d46", "colab": { "base_uri": "https://localhost:8080/", - "height": 190 + "height": 230 } }, "outputs": [ @@ -739,12 +753,12 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, - "execution_count": 13 + "execution_count": 8 } ], "source": [ @@ -764,7 +778,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 9, "metadata": { "id": "vNHQRTUIYnqB" }, @@ -777,10 +791,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "metadata": { "id": "9d0vKQ0fYnqB", - "outputId": "74dc4b06-5d8d-4ffb-b764-c30fdb0dbb0a", + "outputId": "9a664753-cd84-4211-9153-d33e929bb252", "colab": { "base_uri": "https://localhost:8080/" } @@ -790,7 +804,7 @@ "output_type": "stream", "name": "stdout", "text": [ - "diarization error rate = 40.2%\n" + "diarization error rate = 19.2%\n" ] } ], @@ -811,13 +825,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 11, "metadata": { "id": "xMLf4mrYYnqB", - "outputId": "eecd6b38-4fb2-400a-d495-9ef739480e22", + "outputId": "ed08bcc8-24c6-439c-a244-3a673ff480b0", "colab": { "base_uri": "https://localhost:8080/", - "height": 189 + "height": 230 } }, "outputs": [ @@ -825,12 +839,12 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, - "execution_count": 16 + "execution_count": 11 } ], "source": [ @@ -840,13 +854,13 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "metadata": { "id": "Z0ewsLlQYnqB", - "outputId": "71dd0295-80b7-4909-d616-4dffcf81b40b", + "outputId": "8a8cd040-ee1d-48f7-d4be-eef9e08e9e55", "colab": { "base_uri": "https://localhost:8080/", - "height": 189 + "height": 230 } }, "outputs": [ @@ -854,12 +868,12 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, - "execution_count": 17 + "execution_count": 12 } ], "source": [ @@ -888,7 +902,7 @@ }, "widgets": { "application/vnd.jupyter.widget-state+json": { - "a7fd4da8fca94798b977d92ae4f3f2bf": { + "c8731777ce834e58a76a295076200cfc": { "model_module": "@jupyter-widgets/controls", "model_name": "VBoxModel", "model_module_version": "1.5.0", @@ -903,15 +917,15 @@ "_view_name": "VBoxView", "box_style": "", "children": [ - "IPY_MODEL_cc5fdc26256248cf8dac00fbc314a3c7", - "IPY_MODEL_a134ee5d26c54b04b7a34b5e7671e2cf", - "IPY_MODEL_58e364b0131449659804831baa1fb421", - "IPY_MODEL_7f150092f0984d65882e57c373cce7c4" + "IPY_MODEL_859b12a6d95b4c6f987791ca848122b9", + "IPY_MODEL_94756148d2e94a93ae233baba20af683", + "IPY_MODEL_ba18cded436e486da34882d821d8f1eb", + "IPY_MODEL_99898e6ee64a46bd832af112e79b58b7" ], - "layout": "IPY_MODEL_7ee601dd1b8c4a9b9df7c0a0dce0ff3b" + "layout": "IPY_MODEL_79184c8c2a6f4b7493bb7f6983f18a09" } }, - "cc5fdc26256248cf8dac00fbc314a3c7": { + "859b12a6d95b4c6f987791ca848122b9": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -926,13 +940,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_4e4de9bec49841bb8e77d176511da330", + "layout": "IPY_MODEL_ea95ffd922c0455d957120f034e541f8", "placeholder": "​", - "style": "IPY_MODEL_343a0bfe7363401b9c00602c547fc609", + "style": "IPY_MODEL_13525aa369a9410a83343952ab511f3c", "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" } }, - "a134ee5d26c54b04b7a34b5e7671e2cf": { + "94756148d2e94a93ae233baba20af683": { "model_module": "@jupyter-widgets/controls", "model_name": "PasswordModel", "model_module_version": "1.5.0", @@ -949,13 +963,13 @@ "description": "Token:", "description_tooltip": null, "disabled": false, - "layout": "IPY_MODEL_8ae65b22713547ac88aad90600f1ebb0", + "layout": "IPY_MODEL_b2be65e192384c948fb8987d4cfca505", "placeholder": "​", - "style": "IPY_MODEL_4a4b13ce55944ec985ac6eb3e302e473", + "style": "IPY_MODEL_333b42ca7aa44788b1c22724eb11bcc3", "value": "" } }, - "58e364b0131449659804831baa1fb421": { + "ba18cded436e486da34882d821d8f1eb": { "model_module": "@jupyter-widgets/controls", "model_name": "ButtonModel", "model_module_version": "1.5.0", @@ -972,12 +986,12 @@ "description": "Login", "disabled": false, "icon": "", - "layout": "IPY_MODEL_36bfa883a7bf4306a60bd2f2e9d34c17", - "style": "IPY_MODEL_28a732468d2b43f7b0b66b81aed09305", + "layout": "IPY_MODEL_0e382d66f09f4958a40baa7ab83c4ccb", + "style": "IPY_MODEL_6a45ce374e2e47ba9457d02e02522748", "tooltip": "" } }, - "7f150092f0984d65882e57c373cce7c4": { + "99898e6ee64a46bd832af112e79b58b7": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -992,13 +1006,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_a1e3a0a5f91b4a1282fab3f84918e684", + "layout": "IPY_MODEL_765485a1d3f941d28b79782dcffbf401", "placeholder": "​", - "style": "IPY_MODEL_775d04d911a347ce8993eac7ae7479d1", + "style": "IPY_MODEL_3499ef4dd9f243d9bef00b396e78ed69", "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " } }, - "7ee601dd1b8c4a9b9df7c0a0dce0ff3b": { + "79184c8c2a6f4b7493bb7f6983f18a09": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1050,7 +1064,7 @@ "width": "50%" } }, - "4e4de9bec49841bb8e77d176511da330": { + "ea95ffd922c0455d957120f034e541f8": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1102,7 +1116,7 @@ "width": null } }, - "343a0bfe7363401b9c00602c547fc609": { + "13525aa369a9410a83343952ab511f3c": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1117,7 +1131,7 @@ "description_width": "" } }, - "8ae65b22713547ac88aad90600f1ebb0": { + "b2be65e192384c948fb8987d4cfca505": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1169,7 +1183,7 @@ "width": null } }, - "4a4b13ce55944ec985ac6eb3e302e473": { + "333b42ca7aa44788b1c22724eb11bcc3": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1184,7 +1198,7 @@ "description_width": "" } }, - "36bfa883a7bf4306a60bd2f2e9d34c17": { + "0e382d66f09f4958a40baa7ab83c4ccb": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1236,7 +1250,7 @@ "width": null } }, - "28a732468d2b43f7b0b66b81aed09305": { + "6a45ce374e2e47ba9457d02e02522748": { "model_module": "@jupyter-widgets/controls", "model_name": "ButtonStyleModel", "model_module_version": "1.5.0", @@ -1252,7 +1266,7 @@ "font_weight": "" } }, - "a1e3a0a5f91b4a1282fab3f84918e684": { + "765485a1d3f941d28b79782dcffbf401": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1304,7 +1318,7 @@ "width": null } }, - "775d04d911a347ce8993eac7ae7479d1": { + "3499ef4dd9f243d9bef00b396e78ed69": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1319,7 +1333,7 @@ "description_width": "" } }, - "bbbeab96755c4dbea662d7b821c7188f": { + "183c55d5d3ce4058ae338c81344547c5": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -1334,14 +1348,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_29886bb25e6c444d89bd62fe0d3fc2aa", - "IPY_MODEL_e7d91492ccba4a4fbd35b8b8652ce424", - "IPY_MODEL_8007ece499c343438619420efb1c783d" + "IPY_MODEL_70efa83bf3ea45b4bd8cc41f57613328", + "IPY_MODEL_338747810ac74b4e83e356a01459c8a5", + "IPY_MODEL_ac0bcfa1ef6e4e78a7769c4cb2e8762f" ], - "layout": "IPY_MODEL_d04b749f32524693a4aff3fc39565688" + "layout": "IPY_MODEL_6efb7939bb954dc8ba116680139eb257" } }, - "29886bb25e6c444d89bd62fe0d3fc2aa": { + "70efa83bf3ea45b4bd8cc41f57613328": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1356,13 +1370,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_eaf64f20c7ba495480f91d21b54704ef", + "layout": "IPY_MODEL_6242493d251a47609c0c44f1dbe82958", "placeholder": "​", - "style": "IPY_MODEL_8e2b713e4b7d43658c75b254628f3a10", + "style": "IPY_MODEL_f439c1de68ac4c799d81fdb29d053d10", "value": "Downloading: 100%" } }, - "e7d91492ccba4a4fbd35b8b8652ce424": { + "338747810ac74b4e83e356a01459c8a5": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -1378,15 +1392,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_d145e071ff944867afdfcc8182125b40", + "layout": "IPY_MODEL_e4c1e9affaba4045a3ec903091b6f454", "max": 500, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_976f00b9aeb04bc985657b018144269b", + "style": "IPY_MODEL_1946386483ed4947a2184cdb4ea6e434", "value": 500 } }, - "8007ece499c343438619420efb1c783d": { + "ac0bcfa1ef6e4e78a7769c4cb2e8762f": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1401,13 +1415,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_94eec654793d45f4891c7a43217b7e4c", + "layout": "IPY_MODEL_549a30c85c47466eadedbd24da42e304", "placeholder": "​", - "style": "IPY_MODEL_6ce2a0b4a07f4acaa80fe11e064e05ed", - "value": " 500/500 [00:00<00:00, 9.11kB/s]" + "style": "IPY_MODEL_bedc7d916b9745f097094c5c51a81f06", + "value": " 500/500 [00:00<00:00, 5.05kB/s]" } }, - "d04b749f32524693a4aff3fc39565688": { + "6efb7939bb954dc8ba116680139eb257": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1459,7 +1473,7 @@ "width": null } }, - "eaf64f20c7ba495480f91d21b54704ef": { + "6242493d251a47609c0c44f1dbe82958": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1511,7 +1525,7 @@ "width": null } }, - "8e2b713e4b7d43658c75b254628f3a10": { + "f439c1de68ac4c799d81fdb29d053d10": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1526,7 +1540,7 @@ "description_width": "" } }, - "d145e071ff944867afdfcc8182125b40": { + "e4c1e9affaba4045a3ec903091b6f454": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1578,7 +1592,7 @@ "width": null } }, - "976f00b9aeb04bc985657b018144269b": { + "1946386483ed4947a2184cdb4ea6e434": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -1594,7 +1608,7 @@ "description_width": "" } }, - "94eec654793d45f4891c7a43217b7e4c": { + "549a30c85c47466eadedbd24da42e304": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1646,7 +1660,7 @@ "width": null } }, - "6ce2a0b4a07f4acaa80fe11e064e05ed": { + "bedc7d916b9745f097094c5c51a81f06": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1661,7 +1675,7 @@ "description_width": "" } }, - "f4ab2f4beedc469a82dc687330003453": { + "d12f07e25bf5422facc38c3463700994": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -1676,14 +1690,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_45dd7efcbbdb49a8ba9e98cffc41447a", - "IPY_MODEL_4653c869270b4a2cad98e970dfe3fc34", - "IPY_MODEL_924ad861916442898392eaae6c44da56" + "IPY_MODEL_eae11f84c2644ada8295b445c924baec", + "IPY_MODEL_bcf766d2a2c641f0aa2af596c7da1b18", + "IPY_MODEL_74bf69aa6eaa4a8594b2ea9a0fb20957" ], - "layout": "IPY_MODEL_796dde241ce44bbabc1403bef156f410" + "layout": "IPY_MODEL_2d7a0b901d7044d5b1f273a3e9bea560" } }, - "45dd7efcbbdb49a8ba9e98cffc41447a": { + "eae11f84c2644ada8295b445c924baec": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1698,13 +1712,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_f40f7ddb7ebc4dac993b8f6fab2a698d", + "layout": "IPY_MODEL_2cbf0faadd4842c8b22e10541ff9de4e", "placeholder": "​", - "style": "IPY_MODEL_a8f4d54932f94730a8ba41e58253a9c9", + "style": "IPY_MODEL_ab32c7daa1d9404fb921f39fbc4fc05c", "value": "Downloading: 100%" } }, - "4653c869270b4a2cad98e970dfe3fc34": { + "bcf766d2a2c641f0aa2af596c7da1b18": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -1720,15 +1734,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_9099bee7874f41dab13dbffc5479be5d", + "layout": "IPY_MODEL_ee537ee5470f4d7b816a8c8f96948b4d", "max": 17719103, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_e94e8546d7954a0987da477f3c3b20fd", + "style": "IPY_MODEL_652e97509a914f3b914665c4889c6d11", "value": 17719103 } }, - "924ad861916442898392eaae6c44da56": { + "74bf69aa6eaa4a8594b2ea9a0fb20957": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -1743,13 +1757,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_eb032a7f35bd4e4e9ca4328c5d0a52e6", + "layout": "IPY_MODEL_ebc9801e164a44b3b6f8dc7f590e1c79", "placeholder": "​", - "style": "IPY_MODEL_49059590a13a4e6f94fff2689c5c06c3", - "value": " 17.7M/17.7M [00:00<00:00, 46.2MB/s]" + "style": "IPY_MODEL_0821b47ae70444dfa38b84719c4836a6", + "value": " 17.7M/17.7M [00:00<00:00, 54.3MB/s]" } }, - "796dde241ce44bbabc1403bef156f410": { + "2d7a0b901d7044d5b1f273a3e9bea560": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1801,7 +1815,7 @@ "width": null } }, - "f40f7ddb7ebc4dac993b8f6fab2a698d": { + "2cbf0faadd4842c8b22e10541ff9de4e": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1853,7 +1867,7 @@ "width": null } }, - "a8f4d54932f94730a8ba41e58253a9c9": { + "ab32c7daa1d9404fb921f39fbc4fc05c": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -1868,7 +1882,7 @@ "description_width": "" } }, - "9099bee7874f41dab13dbffc5479be5d": { + "ee537ee5470f4d7b816a8c8f96948b4d": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1920,7 +1934,7 @@ "width": null } }, - "e94e8546d7954a0987da477f3c3b20fd": { + "652e97509a914f3b914665c4889c6d11": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -1936,7 +1950,7 @@ "description_width": "" } }, - "eb032a7f35bd4e4e9ca4328c5d0a52e6": { + "ebc9801e164a44b3b6f8dc7f590e1c79": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -1988,7 +2002,7 @@ "width": null } }, - "49059590a13a4e6f94fff2689c5c06c3": { + "0821b47ae70444dfa38b84719c4836a6": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2003,7 +2017,7 @@ "description_width": "" } }, - "b2a14badcc0548f0a056605f456c14ab": { + "c3358d32ac814ea6bc5714402c5bc62d": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -2018,14 +2032,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_607b38bc10e24a6fa56f864505b98b5d", - "IPY_MODEL_63ce45b4de184550acaca5b2e38c0a5c", - "IPY_MODEL_b063b8808ee040e9b05311a3e89389f9" + "IPY_MODEL_ecd8e5e364d34ea8bfbba4fbd467384d", + "IPY_MODEL_0125df9fa8e14b3db0e2bce299529812", + "IPY_MODEL_e3169ca885e04536a709d5751173ce9a" ], - "layout": "IPY_MODEL_65b07a137ab44caa9c153803a1bec549" + "layout": "IPY_MODEL_70abdfd99be84f7b9b8d24fee9eec022" } }, - "607b38bc10e24a6fa56f864505b98b5d": { + "ecd8e5e364d34ea8bfbba4fbd467384d": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2040,13 +2054,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_a2451a62c0ff4f4287a382db373650ca", + "layout": "IPY_MODEL_554e567a83b348f88092c6ba01830930", "placeholder": "​", - "style": "IPY_MODEL_6d0845291bfc4c76a1bf86e5a0740b6f", + "style": "IPY_MODEL_6e334cad2e94462cae6e722bd6f11a9e", "value": "Downloading: 100%" } }, - "63ce45b4de184550acaca5b2e38c0a5c": { + "0125df9fa8e14b3db0e2bce299529812": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -2062,15 +2076,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_05d4e5935c09454885057208f89fdd95", + "layout": "IPY_MODEL_407e250e244b4985b1ce8c9d32a8af7d", "max": 318, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_103ada1efb904aa383b21ae5e0555777", + "style": "IPY_MODEL_8127c4258e374ad986ce1f8b4c70f704", "value": 318 } }, - "b063b8808ee040e9b05311a3e89389f9": { + "e3169ca885e04536a709d5751173ce9a": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2085,13 +2099,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_845a0f7b2a2a428e81f9870b75aef56a", + "layout": "IPY_MODEL_358c3a67f8b54c4c899e095611fa116b", "placeholder": "​", - "style": "IPY_MODEL_5e5ebb6018a749c1b1b3ca0db5ecc6f5", - "value": " 318/318 [00:00<00:00, 5.73kB/s]" + "style": "IPY_MODEL_e1c9df12fa034c93a9b3530ea4a7c5aa", + "value": " 318/318 [00:00<00:00, 11.0kB/s]" } }, - "65b07a137ab44caa9c153803a1bec549": { + "70abdfd99be84f7b9b8d24fee9eec022": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2143,7 +2157,7 @@ "width": null } }, - "a2451a62c0ff4f4287a382db373650ca": { + "554e567a83b348f88092c6ba01830930": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2195,7 +2209,7 @@ "width": null } }, - "6d0845291bfc4c76a1bf86e5a0740b6f": { + "6e334cad2e94462cae6e722bd6f11a9e": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2210,7 +2224,7 @@ "description_width": "" } }, - "05d4e5935c09454885057208f89fdd95": { + "407e250e244b4985b1ce8c9d32a8af7d": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2262,7 +2276,7 @@ "width": null } }, - "103ada1efb904aa383b21ae5e0555777": { + "8127c4258e374ad986ce1f8b4c70f704": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -2278,7 +2292,7 @@ "description_width": "" } }, - "845a0f7b2a2a428e81f9870b75aef56a": { + "358c3a67f8b54c4c899e095611fa116b": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2330,7 +2344,7 @@ "width": null } }, - "5e5ebb6018a749c1b1b3ca0db5ecc6f5": { + "e1c9df12fa034c93a9b3530ea4a7c5aa": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2345,7 +2359,7 @@ "description_width": "" } }, - "56b7159b3a4c49e69c5130ad14860bd5": { + "404f7ce06a01470fbb0b747981d00e84": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -2360,14 +2374,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_9db61482ec0349e48d5b7ea0abe7a455", - "IPY_MODEL_d4319560e75e4f2b8e0a08ed51236f4d", - "IPY_MODEL_c54ff0533893489886d4e5f42c089864" + "IPY_MODEL_38b3054ad59549e4b4f2de4697139a87", + "IPY_MODEL_7d90af87c9574f5ca21fca058c39bf02", + "IPY_MODEL_fee75343289f42fb8d6dfb4bf26fe368" ], - "layout": "IPY_MODEL_b96775d8306849e6929d1565f36905cc" + "layout": "IPY_MODEL_f21c0c6379d74898ac6aadcb6fc14a8a" } }, - "9db61482ec0349e48d5b7ea0abe7a455": { + "38b3054ad59549e4b4f2de4697139a87": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2382,13 +2396,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_561ce5b2a5cb4b73b79e65649f717c94", + "layout": "IPY_MODEL_0adb304bf90f4079a4031caea1cfb924", "placeholder": "​", - "style": "IPY_MODEL_60b96dbb352549c4a8be44f2b7e58027", + "style": "IPY_MODEL_40021e0b59fe4e1e9bac351dbec57c6c", "value": "Downloading: 100%" } }, - "d4319560e75e4f2b8e0a08ed51236f4d": { + "7d90af87c9574f5ca21fca058c39bf02": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -2404,15 +2418,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_caec2fe41ae044b9aa5f983799041d91", + "layout": "IPY_MODEL_ed169fd606274f2ebbb3e8f32ab42431", "max": 1920, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_372a6b4d550145a1a18243918b34b377", + "style": "IPY_MODEL_304e9682570b4abeb1719001c04449d6", "value": 1920 } }, - "c54ff0533893489886d4e5f42c089864": { + "fee75343289f42fb8d6dfb4bf26fe368": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2427,13 +2441,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_7ab33c4be8454daf98c86aff05d14966", + "layout": "IPY_MODEL_16c0017f65b649f5ac5bebf1c955a1fd", "placeholder": "​", - "style": "IPY_MODEL_8b205b8a31754b038e3c90234c0f0ba0", - "value": " 1.92k/1.92k [00:00<00:00, 51.3kB/s]" + "style": "IPY_MODEL_5e2c207db5424f91829bf5c52040a9f2", + "value": " 1.92k/1.92k [00:00<00:00, 48.3kB/s]" } }, - "b96775d8306849e6929d1565f36905cc": { + "f21c0c6379d74898ac6aadcb6fc14a8a": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2485,7 +2499,7 @@ "width": null } }, - "561ce5b2a5cb4b73b79e65649f717c94": { + "0adb304bf90f4079a4031caea1cfb924": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2537,7 +2551,7 @@ "width": null } }, - "60b96dbb352549c4a8be44f2b7e58027": { + "40021e0b59fe4e1e9bac351dbec57c6c": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2552,7 +2566,7 @@ "description_width": "" } }, - "caec2fe41ae044b9aa5f983799041d91": { + "ed169fd606274f2ebbb3e8f32ab42431": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2604,7 +2618,7 @@ "width": null } }, - "372a6b4d550145a1a18243918b34b377": { + "304e9682570b4abeb1719001c04449d6": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -2620,7 +2634,7 @@ "description_width": "" } }, - "7ab33c4be8454daf98c86aff05d14966": { + "16c0017f65b649f5ac5bebf1c955a1fd": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2672,7 +2686,7 @@ "width": null } }, - "8b205b8a31754b038e3c90234c0f0ba0": { + "5e2c207db5424f91829bf5c52040a9f2": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2687,7 +2701,7 @@ "description_width": "" } }, - "78d4e56cedd24c158e32f8c4ca061e75": { + "8011d68253ac4080a637659ef3383dc4": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -2702,14 +2716,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_660b0d137ed6440eaec4b614edcfe6be", - "IPY_MODEL_0c318128b3794483b12795e1e0bc54ac", - "IPY_MODEL_cbacee0f58b0487397e221873f3d383a" + "IPY_MODEL_e928540e99564d808cb2d12c92daa498", + "IPY_MODEL_fc9a3c4ae0a947ec91a227360a80f602", + "IPY_MODEL_f91dcd9f30c743d69f9d4b7e8d1beba5" ], - "layout": "IPY_MODEL_00ad3a57fd1c4a119248499c170a78ab" + "layout": "IPY_MODEL_6ede83f870a24e71b5182fcc458cdc42" } }, - "660b0d137ed6440eaec4b614edcfe6be": { + "e928540e99564d808cb2d12c92daa498": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2724,13 +2738,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_3435da3dd0404ae8ab0961731a9a0401", + "layout": "IPY_MODEL_c9974003727a401797953ef2885db5a2", "placeholder": "​", - "style": "IPY_MODEL_50343a8f410344c799b8abb5253dac33", + "style": "IPY_MODEL_77a361d1ff214e8799891bbeb28a0789", "value": "Downloading: 100%" } }, - "0c318128b3794483b12795e1e0bc54ac": { + "fc9a3c4ae0a947ec91a227360a80f602": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -2746,15 +2760,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_fd03191952134e42a881743e5c51d2db", + "layout": "IPY_MODEL_27f6f437c5264368bc2c679942ad1e53", "max": 83316686, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_ba7d97dcd55943e996ab08c25c7f8239", + "style": "IPY_MODEL_e7728d9c55e44274966f8f6dbc445c54", "value": 83316686 } }, - "cbacee0f58b0487397e221873f3d383a": { + "f91dcd9f30c743d69f9d4b7e8d1beba5": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -2769,13 +2783,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_bc19cd2362504c05882bee1ad32fc4dc", + "layout": "IPY_MODEL_2b2d7912186a49dd9891ae12c77482c7", "placeholder": "​", - "style": "IPY_MODEL_3e667b4863c3479cb0cce455558e0ff4", - "value": " 83.3M/83.3M [00:01<00:00, 56.8MB/s]" + "style": "IPY_MODEL_1600b9cd09c446e581b7912e35c9f56e", + "value": " 83.3M/83.3M [00:01<00:00, 60.9MB/s]" } }, - "00ad3a57fd1c4a119248499c170a78ab": { + "6ede83f870a24e71b5182fcc458cdc42": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2827,7 +2841,7 @@ "width": null } }, - "3435da3dd0404ae8ab0961731a9a0401": { + "c9974003727a401797953ef2885db5a2": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2879,7 +2893,7 @@ "width": null } }, - "50343a8f410344c799b8abb5253dac33": { + "77a361d1ff214e8799891bbeb28a0789": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -2894,7 +2908,7 @@ "description_width": "" } }, - "fd03191952134e42a881743e5c51d2db": { + "27f6f437c5264368bc2c679942ad1e53": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -2946,7 +2960,7 @@ "width": null } }, - "ba7d97dcd55943e996ab08c25c7f8239": { + "e7728d9c55e44274966f8f6dbc445c54": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -2962,7 +2976,7 @@ "description_width": "" } }, - "bc19cd2362504c05882bee1ad32fc4dc": { + "2b2d7912186a49dd9891ae12c77482c7": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3014,7 +3028,7 @@ "width": null } }, - "3e667b4863c3479cb0cce455558e0ff4": { + "1600b9cd09c446e581b7912e35c9f56e": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -3029,7 +3043,7 @@ "description_width": "" } }, - "3f152784ff7947668e1eb4d890c31043": { + "28004251b0e44a6c9dfa7ce1b30dcb18": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -3044,14 +3058,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_92bc59fb29444d99b5420ea92b63d873", - "IPY_MODEL_e89ebbf536a7415d92cdb9bb0e40bd23", - "IPY_MODEL_9157ace3987147e8afd845b0b4de5365" + "IPY_MODEL_e98cf7a63c814ffd94f69928f0700ebf", + "IPY_MODEL_6a4dee55cbae4959bd7fe3c4d92242b1", + "IPY_MODEL_8dba487876124827919079519406ecb8" ], - "layout": "IPY_MODEL_1349e97c6e10422ab22d2df65f62f236" + "layout": "IPY_MODEL_5c211704f90946afbae2f66a7586ce70" } }, - "92bc59fb29444d99b5420ea92b63d873": { + "e98cf7a63c814ffd94f69928f0700ebf": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -3066,13 +3080,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_87ca9dd3c5cf4bf5b6a3d9afb2b97ad7", + "layout": "IPY_MODEL_aba21021d3bb4565a58ffa40049810db", "placeholder": "​", - "style": "IPY_MODEL_117925349b764bc883f076c76855b146", + "style": "IPY_MODEL_f7812fa7fbf744c1b261b985d085e28e", "value": "Downloading: 100%" } }, - "e89ebbf536a7415d92cdb9bb0e40bd23": { + "6a4dee55cbae4959bd7fe3c4d92242b1": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -3088,15 +3102,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_0b96234b8a464e6098f2f1f9aae445e2", + "layout": "IPY_MODEL_d7071582bfbe4ec4b2c3c9843e5481ae", "max": 1921, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_c8c29f7f5dbe45798166423d21d0479a", + "style": "IPY_MODEL_0d80273cabbc42ba9a408fb1144151c9", "value": 1921 } }, - "9157ace3987147e8afd845b0b4de5365": { + "8dba487876124827919079519406ecb8": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -3111,13 +3125,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_b1f39d703abf405188d7a8c99500077b", + "layout": "IPY_MODEL_67fcc38a1e5d4eb39381685447e397de", "placeholder": "​", - "style": "IPY_MODEL_5333f14482954ab58224e858cd3144d3", - "value": " 1.92k/1.92k [00:00<00:00, 6.93kB/s]" + "style": "IPY_MODEL_0b4bf8076fdf4d19843a3246c8bd61ac", + "value": " 1.92k/1.92k [00:00<00:00, 63.2kB/s]" } }, - "1349e97c6e10422ab22d2df65f62f236": { + "5c211704f90946afbae2f66a7586ce70": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3169,7 +3183,7 @@ "width": null } }, - "87ca9dd3c5cf4bf5b6a3d9afb2b97ad7": { + "aba21021d3bb4565a58ffa40049810db": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3221,7 +3235,7 @@ "width": null } }, - "117925349b764bc883f076c76855b146": { + "f7812fa7fbf744c1b261b985d085e28e": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -3236,7 +3250,7 @@ "description_width": "" } }, - "0b96234b8a464e6098f2f1f9aae445e2": { + "d7071582bfbe4ec4b2c3c9843e5481ae": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3288,7 +3302,7 @@ "width": null } }, - "c8c29f7f5dbe45798166423d21d0479a": { + "0d80273cabbc42ba9a408fb1144151c9": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -3304,7 +3318,7 @@ "description_width": "" } }, - "b1f39d703abf405188d7a8c99500077b": { + "67fcc38a1e5d4eb39381685447e397de": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3356,7 +3370,7 @@ "width": null } }, - "5333f14482954ab58224e858cd3144d3": { + "0b4bf8076fdf4d19843a3246c8bd61ac": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -3371,7 +3385,7 @@ "description_width": "" } }, - "275133746d524f099c8ec736f157a1bd": { + "d182e37b4a404158bee8446fc2728bd9": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -3386,14 +3400,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_f7dbef43a8c14f77bbcca6a02a02970b", - "IPY_MODEL_543a7cfb2e4b49d39cd35f63d49a7386", - "IPY_MODEL_cf9bc7d009994525b9a4edbdd02e291d" + "IPY_MODEL_603e99f45afb4910a99f7684ffd21b6a", + "IPY_MODEL_d13ba6030aff42bca48c72ff071c44c0", + "IPY_MODEL_a899f4bc6ed842d397723cca582669e6" ], - "layout": "IPY_MODEL_f5f78e586cd24028b83887ded99f43bc" + "layout": "IPY_MODEL_a02030ba8f324d93a7ed6cc793d70a3b" } }, - "f7dbef43a8c14f77bbcca6a02a02970b": { + "603e99f45afb4910a99f7684ffd21b6a": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -3408,13 +3422,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_bdbd0f99d45d4c86b6b5a69e11feec51", + "layout": "IPY_MODEL_b26354d0278f447d92c7e1ad4c211d64", "placeholder": "​", - "style": "IPY_MODEL_4db259c505014ab68783a3ff2a128afe", + "style": "IPY_MODEL_3bd33a372aad4c438f64d73c97f14c6a", "value": "Downloading: 100%" } }, - "543a7cfb2e4b49d39cd35f63d49a7386": { + "d13ba6030aff42bca48c72ff071c44c0": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -3430,15 +3444,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_86bfddc1dfe44f2d8f96ccbd0dcebb2a", + "layout": "IPY_MODEL_c8e0c9a60ef34d2caee9d55a3c21c3d4", "max": 5534328, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_621c3ec473b3414a95f6b0f7df2898ea", + "style": "IPY_MODEL_764aa53d75324d73ab06936c52fd8fc8", "value": 5534328 } }, - "cf9bc7d009994525b9a4edbdd02e291d": { + "a899f4bc6ed842d397723cca582669e6": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -3453,13 +3467,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_a78cb85112ad404ca6172b216b679767", + "layout": "IPY_MODEL_341615c971b04033b7293d82fc40f35c", "placeholder": "​", - "style": "IPY_MODEL_7e432a87cb0d4571bdc52cfcaae702b7", - "value": " 5.53M/5.53M [00:00<00:00, 13.3MB/s]" + "style": "IPY_MODEL_17856a72e4e948039a66c51e8244cb50", + "value": " 5.53M/5.53M [00:00<00:00, 21.7MB/s]" } }, - "f5f78e586cd24028b83887ded99f43bc": { + "a02030ba8f324d93a7ed6cc793d70a3b": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3511,7 +3525,7 @@ "width": null } }, - "bdbd0f99d45d4c86b6b5a69e11feec51": { + "b26354d0278f447d92c7e1ad4c211d64": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3563,7 +3577,7 @@ "width": null } }, - "4db259c505014ab68783a3ff2a128afe": { + "3bd33a372aad4c438f64d73c97f14c6a": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -3578,7 +3592,7 @@ "description_width": "" } }, - "86bfddc1dfe44f2d8f96ccbd0dcebb2a": { + "c8e0c9a60ef34d2caee9d55a3c21c3d4": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3630,7 +3644,7 @@ "width": null } }, - "621c3ec473b3414a95f6b0f7df2898ea": { + "764aa53d75324d73ab06936c52fd8fc8": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -3646,7 +3660,7 @@ "description_width": "" } }, - "a78cb85112ad404ca6172b216b679767": { + "341615c971b04033b7293d82fc40f35c": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3698,7 +3712,7 @@ "width": null } }, - "7e432a87cb0d4571bdc52cfcaae702b7": { + "17856a72e4e948039a66c51e8244cb50": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -3713,7 +3727,7 @@ "description_width": "" } }, - "a88fb04c89834c48b922f6ff14632c87": { + "41eb32a6fef141ff9cc3ce6e4d771822": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", @@ -3728,14 +3742,14 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_4176f6e114d04cc3af8fd00c9405ab48", - "IPY_MODEL_c7250d3a8d044265a1c3d098585a0117", - "IPY_MODEL_cf5c362276004feab43dce3cc80ea945" + "IPY_MODEL_0d10fb0edc9144b1a1fc1f2c9e322410", + "IPY_MODEL_32accb0adfa24c62a75c15c8ec88df8c", + "IPY_MODEL_bf299285318b4a04a88569cc581ecd75" ], - "layout": "IPY_MODEL_9a8a9f130bf544949914b972e1cb302f" + "layout": "IPY_MODEL_ac2950d08fc145ba9eb9cf5824b1ee18" } }, - "4176f6e114d04cc3af8fd00c9405ab48": { + "0d10fb0edc9144b1a1fc1f2c9e322410": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -3750,13 +3764,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_1697e1466f514b89b6fae0edf8f48bd7", + "layout": "IPY_MODEL_d33fba0d78fb41f983c55f5cd2a0a740", "placeholder": "​", - "style": "IPY_MODEL_9aa6ef23552e4b91ad9ca6c897c17579", + "style": "IPY_MODEL_fd47487fc8734594823f8afa00c4239d", "value": "Downloading: 100%" } }, - "c7250d3a8d044265a1c3d098585a0117": { + "32accb0adfa24c62a75c15c8ec88df8c": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", @@ -3772,15 +3786,15 @@ "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_a260382718bd4998a96013e8643f7589", + "layout": "IPY_MODEL_23d4e25ec6c541818d5927b69576d278", "max": 128619, "min": 0, "orientation": "horizontal", - "style": "IPY_MODEL_44cd14b01a854294b283129db1e6beab", + "style": "IPY_MODEL_54d9456703324160aced03ee5fef2943", "value": 128619 } }, - "cf5c362276004feab43dce3cc80ea945": { + "bf299285318b4a04a88569cc581ecd75": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", @@ -3795,13 +3809,13 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_80ca456de9084ef18dc13c369f127486", + "layout": "IPY_MODEL_bacfb50c001047c4824a05c9f2ee2e40", "placeholder": "​", - "style": "IPY_MODEL_19d13680d11f48d6938e52743c7f4275", - "value": " 129k/129k [00:00<00:00, 249kB/s]" + "style": "IPY_MODEL_c53a1cf68fcd4388abf1f0379891089a", + "value": " 129k/129k [00:00<00:00, 155kB/s]" } }, - "9a8a9f130bf544949914b972e1cb302f": { + "ac2950d08fc145ba9eb9cf5824b1ee18": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3853,7 +3867,7 @@ "width": null } }, - "1697e1466f514b89b6fae0edf8f48bd7": { + "d33fba0d78fb41f983c55f5cd2a0a740": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3905,7 +3919,7 @@ "width": null } }, - "9aa6ef23552e4b91ad9ca6c897c17579": { + "fd47487fc8734594823f8afa00c4239d": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", @@ -3920,7 +3934,7 @@ "description_width": "" } }, - "a260382718bd4998a96013e8643f7589": { + "23d4e25ec6c541818d5927b69576d278": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -3972,7 +3986,7 @@ "width": null } }, - "44cd14b01a854294b283129db1e6beab": { + "54d9456703324160aced03ee5fef2943": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", @@ -3988,7 +4002,7 @@ "description_width": "" } }, - "80ca456de9084ef18dc13c369f127486": { + "bacfb50c001047c4824a05c9f2ee2e40": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", @@ -4040,7 +4054,7 @@ "width": null } }, - "19d13680d11f48d6938e52743c7f4275": { + "c53a1cf68fcd4388abf1f0379891089a": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", From 8b5ed07299f04ffafa3b6604d633a10c8289cba2 Mon Sep 17 00:00:00 2001 From: Rhenan Date: Sat, 29 Oct 2022 01:54:53 -0400 Subject: [PATCH 012/112] doc: add hf.co/pyannote/segmentation to readme (#1127) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1f1340cdd..1824144e8 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ ```python -# 1. visit hf.co/pyannote/speaker-diarization and accept user conditions (only if requested) +# 1. visit hf.co/pyannote/speaker-diarization and hf.co/pyannote/segmentation 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 From 85bc1012082d59e1e1d3d685fa95a00872514c50 Mon Sep 17 00:00:00 2001 From: Atai Barkai Date: Wed, 9 Nov 2022 01:53:56 -0800 Subject: [PATCH 013/112] setup: add support for soundfile 0.11 (#1140) Fixes #1069 #1096 Related to #347 --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 5c991ead4..48b585c20 100644 --- a/requirements.txt +++ b/requirements.txt @@ -13,7 +13,7 @@ pytorch_lightning >=1.5.4,<1.7 pytorch_metric_learning >=1.0.0,<2.0 semver >=2.10.2,<3.0 singledispatchmethod -soundfile >=0.10.2,<0.11 +soundfile >=0.10.2,<0.12 speechbrain >=0.5.12,<0.6 torch >=1.9 torch_audiomentations >= 0.11.0 From d966b518b0d6383c827a5e9a978516652f871a27 Mon Sep 17 00:00:00 2001 From: Yoyoma22 <74927546+Yoyoma22@users.noreply.github.com> Date: Mon, 14 Nov 2022 04:43:08 -0500 Subject: [PATCH 014/112] fix(setup): use utf-8 encoding MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes #1142 Co-authored-by: Andre.Bonin Co-authored-by: Hervé BREDIN --- setup.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/setup.py b/setup.py index 2069c946a..3fa457d60 100644 --- a/setup.py +++ b/setup.py @@ -5,10 +5,10 @@ from pkg_resources import VersionConflict, require from setuptools import find_packages, setup -with open("README.md") as f: +with open("README.md", mode="r", encoding="utf-8") as f: long_description = f.read() -with open("requirements.txt") as f: +with open("requirements.txt", mode="r", encoding="utf-8") as f: requirements = f.read().splitlines() try: @@ -21,7 +21,7 @@ ROOT_DIR = Path(__file__).parent.resolve() # Creating the version file -with open("version.txt") as f: +with open("version.txt", mode="r", encoding="utf-8") as f: version = f.read() version = version.strip() @@ -35,7 +35,7 @@ version_path = ROOT_DIR / "pyannote" / "audio" / "version.py" -with open(version_path, "w") as f: +with open(version_path, mode="w", encoding="utf-8") as f: f.write("__version__ = '{}'\n".format(version)) if __name__ == "__main__": From 789b8d476639d7218ac0f203090cab1735872b07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 28 Nov 2022 09:26:06 +0100 Subject: [PATCH 015/112] Update stale.yml --- .github/stale.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/stale.yml b/.github/stale.yml index dc90e5a1c..3cb76e884 100644 --- a/.github/stale.yml +++ b/.github/stale.yml @@ -1,7 +1,7 @@ # Number of days of inactivity before an issue becomes stale -daysUntilStale: 60 +daysUntilStale: 180 # Number of days of inactivity before a stale issue is closed -daysUntilClose: 7 +daysUntilClose: 30 # Issues with these labels will never be considered stale exemptLabels: - pinned From a1e99ee55036b79900f0b24b6e907edef43bab33 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 29 Nov 2022 18:14:49 +0100 Subject: [PATCH 016/112] doc: describe offline use (#1169) * related bugs: #1119 #1128 #1130 * related discussions: #1123 #1103 #1126 #1121 --- FAQ.md | 25 ++++ README.md | 17 +-- tutorials/applying_a_model.ipynb | 163 +++++++++++++++------- tutorials/applying_a_pipeline.ipynb | 186 +++++++++++++++++++------ tutorials/assets/download-model.png | Bin 0 -> 482731 bytes tutorials/assets/download-pipeline.png | Bin 0 -> 385069 bytes 6 files changed, 284 insertions(+), 107 deletions(-) create mode 100644 FAQ.md create mode 100644 tutorials/assets/download-model.png create mode 100644 tutorials/assets/download-pipeline.png diff --git a/FAQ.md b/FAQ.md new file mode 100644 index 000000000..a2d3e95ba --- /dev/null +++ b/FAQ.md @@ -0,0 +1,25 @@ +# Frequently asked questions + +## How does one capitalize and pronounce the name of this awesome library? + +📝 Written in lower case: `pyannote.audio` (or `pyannote` if you are lazy). Not `PyAnnote` nor `PyAnnotate` (*sic*). +📢 [Pronounced](https://www.howtopronounce.com/french/pianote) like the french verb *pianoter*. *pi* like in **pi**ano, not *py* like in **py**thon. +🎹 *pianoter* means *to play the piano* (hence the logo 🤯). + +## Can I use gated models (and pipelines) offline? + +**Short answer**: yes, see [this tutorial](tutorials/applying_a_model.ipynb) for models and [that one](tutorials/applying_a_pipeline.ipynb) for pipelines. + +**Long answer**: gating models and pipelines allows [me](https://herve.niderb.fr) to know a bit more about `pyannote.audio` user base and eventually help me write grant proposals to make `pyannote.audio` even better. So, please fill gating forms as precisely as possible. + +For instance, before gating `pyannote/speaker-diarization`, I had no idea that so many people were relying on it in production. Hint: sponsors are more than welcome! Maintaining open source libraries is time consuming. + +That being said, this whole authentication process does not prevent you from using official `pyannote.audio` models offline (i.e. without going through the authentication process in every `docker run ...` or whatever you are using in production): see [this tutorial](tutorials/applying_a_model.ipynb) for models and [that one](tutorials/applying_a_pipeline.ipynb) for pipelines. + +## **[Pretrained pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) do not produce good results on my data. What can I do?** + +1. [Annotate](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/prodigy.md) dozens of conversations manually and separate them into development and test subsets in [`pyannote.database`](https://github.com/pyannote/pyannote-database#speaker-diarization). +2. [Optimize the hyper-parameters](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/voice_activity_detection.ipynb) of the pretained pipeline using the development set. If performance is still not good enough, go to step 3. +3. Annotate hundreds of conversations manually and set them up as training subset in `pyannote.database`. +4. [Fine-tune](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/training_a_model.ipynb) the models (on which the pipeline relies) using the training set. +5. [Optimize the hyper-parameters](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/voice_activity_detection.ipynb) of the pipeline using the fine-tuned models using the development set. If performance is still not good enough, go back to step 3. diff --git a/README.md b/README.md index 1824144e8..8c5a13d72 100644 --- a/README.md +++ b/README.md @@ -84,20 +84,9 @@ pip install pyannote.audio ## Frequently asked questions -#### How does one capitalize and pronounce the name of this awesome library? - -📝 Written in lower case: `pyannote.audio` (or `pyannote` if you are lazy). Not `PyAnnote` nor `PyAnnotate` (*sic*). -📢 [Pronounced](https://www.howtopronounce.com/french/pianote) like the french verb *pianoter*. *pi* like in **pi**ano, not *py* like in **py**thon. -🎹 *pianoter* means *to play the piano* (hence the logo 🤯). - -#### **[Pretrained pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) do not produce good results on my data. What can I do?** - -1. [Annotate](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/prodigy.md) dozens of conversations manually and separate them into development and test subsets in [`pyannote.database`](https://github.com/pyannote/pyannote-database#speaker-diarization). -2. [Optimize the hyper-parameters](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/voice_activity_detection.ipynb) of the pretained pipeline using the development set. If performance is still not good enough, go to step 3. -3. Annotate hundreds of conversations manually and set them up as training subset in `pyannote.database`. -4. [Fine-tune](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/training_a_model.ipynb) the models (on which the pipeline relies) using the training set. -5. [Optimize the hyper-parameters](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/voice_activity_detection.ipynb) of the pipeline using the fine-tuned models using the development set. If performance is still not good enough, go back to step 3. - +* [How does one capitalize and pronounce the name of this awesome library?](FAQ.md) +* [Can I use gated models (and pipelines) offline?](FAQ.md) +* [Pretrained pipelines do not produce good results on my data. What can I do?](FAQ.md) ## Benchmark diff --git a/tutorials/applying_a_model.ipynb b/tutorials/applying_a_model.ipynb index 2319ab064..e035d0654 100644 --- a/tutorials/applying_a_model.ipynb +++ b/tutorials/applying_a_model.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -34,17 +34,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": null, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -62,24 +62,25 @@ "source": [ "## Loading models from 🤗 hub\n", "\n", - "Pretrained models are available on [🤗 Huggingface model hub](https://hf.co/models?other=pyannote-audio-model) and can be listed by looking for the [`pyannote-audio-model`](https://hf.co/models?other=pyannote-audio-model) tag." + "A bunch of pretrained models are available on [🤗 Huggingface model hub](https://hf.co/models?other=pyannote-audio-model) and can be listed by looking for the [`pyannote-audio-model`](https://hf.co/models?other=pyannote-audio-model) tag." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['pyannote/segmentation',\n", - " 'pyannote/embedding',\n", + "['pyannote/Segmentation-PyanNet-DIHARD',\n", " 'pyannote/TestModelForContinuousIntegration',\n", - " 'pyannote/Segmentation-PyanNet-DIHARD']" + " 'pyannote/embedding',\n", + " 'pyannote/segmentation',\n", + " 'pyannote/brouhaha']" ] }, - "execution_count": null, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -87,35 +88,36 @@ "source": [ "from huggingface_hub import HfApi\n", "available_models = [m.modelId for m in HfApi().list_models(filter=\"pyannote-audio-model\")]\n", - "available_models" + "list(filter(lambda p: p.startswith(\"pyannote/\"), available_models))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "To load the speaker segmentation model, \n", + "Official [pyannote.audio](https://github.com/pyannote/pyannote-audio) models (i.e. those under the [`pyannote` organization](https://hf.co/pyannote) umbrella) are open-source, but gated. It means that you have to first accept users conditions on their respective Huggingface page to access the pretrained weights and hyper-parameters. Despite this initial process, those models can perfectly be downloaded for later offline use: keep reading this tutorial until the end to learn how to do that.\n", "\n", - "* accept the user conditions on [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation).\n", - "* login using `notebook_login` below" + "For instance, to load the speaker segmentation model used in this tutorial, you have to visit [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation), accept the terms, and log in using `notebook_login` below:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "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" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1b7ac613e9e841c8903dc4932e183006", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value='
, resolution=, duration=5.0, warm_up=(0.0, 0.0), classes=['speaker#1', 'speaker#2', 'speaker#3'], permutation_invariant=True)" ] }, - "execution_count": null, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -219,17 +228,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": null, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -250,7 +259,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -259,7 +268,7 @@ "(11, 293, 3)" ] }, - "execution_count": null, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -279,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -305,17 +314,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": null, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -336,17 +345,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABi4AAAGZCAYAAAAetMkNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRnUlEQVR4nO39d4BcZ30v/r/PzBbVXTWrS7bcezfG9B4cIBiSbygJgUASHCAJl0vKJTfB5JcLCfkmuSR8IQkhEBISnEu/dNOMqS7ggo17U+/Srtq2Ob8/ZndVLFvS7qxmVnq9YHjOnPKcz7bDaN7znKcoy7IMAAAAAABAC6g0uwAAAAAAAIARggsAAAAAAKBlCC4AAAAAAICWIbgAAAAAAABahuACAAAAAABoGYILAAAAAACgZQguAAAAAACAltE21gNrtVrWrFmTmTNnpiiKRtYEAAAAAABMMmVZpre3N4sXL06lMvZxE2MOLtasWZNly5aN+cQAAAAAAMCxZ+XKlVm6dOmYjx9zcDFz5szRArq6usZcAAAAAAAAMPn19PRk2bJlo/nBWI05uBi5PVRXV5fgAgAAAAAASJJxTy9hcm4AAAAAAKBlCC4AAAAAAICWIbgAAAAAAABahuACAAAAAABoGYILAAAAAACgZQguAAAAAACAliG4AAAAAAAAWobgAgAAAAAAaBmCCwAAAAAAoGUILgAAAAAAgJbR1uwCAACaplZLyqGkNnRAu8/62uDe5aJIKm17H0U1qVSHn1f3WV80sMahpHddMtQ3vGK479FzFPsvP6HyEJvL+j5lrb48+nx43X7Hj5x3n/OP7D+6PEZj+v4d4TFHfI4x9F9tTyrtw23b3rbSnlR8fggAAODxCC4AgDHbsrM/Nz60OZt39mfLjv5s2z2QPQND6R+spX+oVm/3Xd5n3VBZpkhSFEWKJJWiGH0vuSiKVIbfD68URSpFkWqlSHW4HSrL9A3W0jcwNNruGW4HamXKsszyYkP+ef4ns6J9a7JrS9LXu38IUQ5N3DemqAyHGiMhR+WAsKPtsYHH7JOSE5+SzF6R9KxOHr4hWXt7sn1VUhuYuFppjqLy2FCj2pG0Tx1+TDugPWBdUan/HidJtS3Zsz1Dc0/Pux69ILet2ZHe3QPp2TOYWlnWH7UyHW2VdE9tz+xpHZk1rSOzp7Vn7ozOzJvRkXkzOjN3RkfmTq+3tbLMnoFa9gwMDT9q2TM4lMGhMkPDf2NDZX253n/ysouWpFJpYGgHAAActwQXAMCY3be+N1f/+4+bXcZB/VrbF7Jiyw3j62RkRMVIW5bDwcdg/fF4ylr9cSSBw/qfJnd/4fHraJ96wCiGA0c27PP8CUcTHOKN5aKy/0iK/UZVDLePGVlR7u13ZL/R5cN02CM0jmAkR6P7PJJBJOVQMjRQ/x0oawfZXquPohkdSTN+1SSXDl2Rjw28JY/3c960oz/Jzoadc1+/cOHiVI50ZAoAAMBBCC4AgDFb0DUlFy2flbnT65/UnjW9PVPaquloq6SzrZKOtko6qsPtAcvVokiZ4Swg5eidiWplOby+HH0+8qnuoVoyVJapFMmUtmo62yuZ0l5NZ9vetq1aSSVlKu/7vaRMrp31m1l2yQtzyeknprOjY/8goqjWR0McGFCMrD+UWm1viLHvaI7a4D7t4HCIMbjP+n1vQTWYDPYn6+9IVt6Y9K5Nps5Jll+RLHtSMmdFMnNx/VP1TE6jvycDw2HG4N5QozaYDA1vG+xLBvckA7uSgT3JwO7h5ZF2eLl/Z5Ky/nuaMhnsS38tKW77RH6h+oNsu+R3c8b5l2fGlLa0VyvDo5eK9A3Usm13f7btGsjWXf3ZurM/m3f2Z/OO/mza0ZfNO/qzeWdftuzsT6UoMrW9ms72aqYM/51Naa+krVIZHf1UFKkvV+qjogAAABrFv4ABgDE7ad70fOZNT212GY91z5eTcmP2lO1557qnZM8X+zLzGw/m15+6Im9+9inpbKs25jyVSlLpSNIx/r5Oe974+6A1NfL35HH81w8fydKf/DTPqt6W18x/IMXJPz/mvsqyTCGIAAAAmsisgADAseXh7ybXviZJsvvkF+ZXn3ZmFndPSe+ewfzdN+7LS9//vdyzrrfJRULjDAzV8m8/eCQ31M5NkhQ3/0vyyTckX/uT5Pb/k2x58IgmSxdaAAAAzVaU5RH8K2YfPT096e7uzvbt29PV1dXougAAjtyOjckHLk92bU5O+7nk5f+UTJ2VWq3MF+9Ym3d+/s5s2dmfKe2V/OUvnp+XXrik2RXDuP3D9Q/kL758dy6esi6fztsOvlP3suTK9yZnjn0kBgAAwKE0KjdwqygA4Njx9WvqocWCc5Nf/tf6hNZJKpUiL7lgcZ588ty87b9uzQ33bcrvfeLW3LFqe/7oyjPTVjUIlcnrEzc+miR5xYuen1T/Ptn8QDJtbrLtkWTNrcm625PtK5NPvDp5/VeT5Zc3t2AAAIBDEFwAAMeG7auTWz9eX37x/x4NLfZ1wszOfPTXn5S//to9+cC3H8g/f/eh9A/V8mcvPffo1goNsqFnTx7evCtFkbzw3EXJ1F977E79O5PPXJ387PPJF96avPE7SbX9qNcKAABwuHy8EAA4Ntz+iSRlcuLTkmWXPe5u1UqRP3jhmfn7V12UJPnYDx7J9x/YdJSKhMa68eEtSZKzFnale+rjhBEd05OXvK8+CmPDXcn3/+4oVggAAHDkBBcAwORXlsmt/1FfvvBVh3XISy5YnF+6ZGmS5Gt3rp+oymBC3fzw1iTJk1bMeeIdp81Jfu7d9eXr31ufsBsAAKBFCS4AgMlv1U3J5vuT9mnJ2S897MOeefoJSZKbH9kyUZXBhLpzzfYkyYXLZh165/Nfkax4ZjK4J/nS79cDPwAAgBYkuAAAJr+R0RZnvzTpnHnYh1160uwkyV1rerKjb3AiKoMJU5Zl7lnXmyQ5Y+Fh/N4XRfLiv02qHcn9X0/u/eoEVwgAADA2ggsAYHIry+S+6+rL5/3SER26qHtqls6emlqZ3ProtsbXBhNoXc+e9OwZTLVS5OQTph/eQXNPSZ782/Xl77x34ooDAAAYB8EFADC5bX046VmVVNqT5Vcc8eHnLO5Kkty7vrfBhcHEGhltcfK86elsqx7+gVf8Tn3UxepbklW3TFB1AAAAYye4AAAmt4e/W2+XXJJ0HOanzvdx6vwZSZL7N+5oZFUw4UaCi9MP5zZR+5pxQnLOy+vLN/5Tg6sCAAAYP8EFADC5PfL9envSU8d0+GhwsUFwweTy8OZdSZJT5h15YJcn/Va9vfPTyY6NDawKAABg/AQXAMDktu6OervkkjEdfuoJ9U+rPyC4YJJZvW13kmTp7GlHfvDSS+p/M0P9ya3/3uDKAAAAxkdwAQBMXkMDyca768sLzhlTF6fMr39affPO/mzd2d+oymDCrd5aH3GxZPbUsXVw8Wvr7a3/WZ/kHgAAoEUILgCAyWvTfUltIOmYmcw6cUxdTOtoy8KuKUmSR7bsamR1MGHKshwdcbFk1hiDi3OuStqmJpvuSdb8uHHFAQAAjJPgAgCYvNb/tN4uOCcpijF3s6C7Hlxs6NnTiKpgwm3Z2Z89A7UkyaJZU8bWyZTu5PQX1Jfv/VqDKgMAABg/wQUAMHltuKveLjh7XN3Mn9mZJFnf2zfeiuCoGBltMX9mZzrbqmPv6NTn19v7r2tAVQAAAI0huAAAJq/N99fbeaePq5sFXfXgYqMRF0wSq7YO3yZqrPNbjDj1ufV29Y+TnZvHWRUAAEBjCC4AgMlr8wP1du6p4+pmwcz6rXbW9xhxweSweus457cY0bU4OeHMJGXy6A/GXxgAAEADCC4AgMmpVku2PFhfnnPyuLqa3zVyqygjLpgcRm4VtXT2tPF3tuzyervyh+PvCwAAoAEEFwDA5NSzOhnck1Taklknjqur+V0jk3MbccHk0LBbRSXJ8ifX25U3jr8vAACABhBcAACT05bh20TNXpFU28bV1citojYYccEkMTriYry3ikr2jrhY85NkwN8AAADQfIILAGBy2nRfvZ17yri7GrlV1KYd/RkYqo27P5hoq7fuStKgERdzTk6mn5AM9Sdrbx1/fwAAAOMkuAAAJqd1d9TbBeeMu6s50zrSVimSJJt2uF0Ura13z0B69gwmacDk3ElSFHtHXTxqngsAAKD5BBcAwOS0/qf1dsG54+6qUilywszhCbrNc0GLG7lN1Kxp7ZneOb7bpI0anefiR43pDwAAYBwEFwDA5FMbStbfVV9eeF5Dutw7Qbd7/NPaVo9MzN2I0RYjRkZcrPxRUpaN6xcAAGAMBBcAwOSz5cFkcHfSPq1+f/4GWDAy4qLXiAta26qJCC4WXZBUO5Ndm5PNDzSuXwAAgDEQXAAAk8/qH9fbBecklWpDuhyZoNuIC1rdyK2ils6e1rhO2zqTJRfXl1ea5wIAAGguwQUAMPmMvLE6cnubBlgwc+RWUUZc0NpGbxU1u4EjLhITdAMAAC1DcAEATD6PDk8g3MDgYmTExfpeIy5obau2TcCtopK9f0+rb2lsvwAAAEdIcAEATC67tyUbhifmXv7khnU7Mjn3eiMuaHEjIy6WNnrExchE95vuS4YGGts3AADAERBcAACTy4PfTlImc09NZsxvWLd7bxVlxAWta8/AUDbtqIdrDR9x0b006ZiZ1AZM0A0AADSV4AIAmFzu/Uq9Pf2FDe125E3gzTv7s7t/qKF9Q6OMTMw9raOaWdPaG9t5USQnnFFfHhnVBAAA0ASCCwBg8qjVkvu+Vl8+48qGdt09rT1dU9qSJCu37mpo39AoD27cmSQ5ae70FEXR+BPMP6vebry78X0DAAAcJsEFADB5bLw72bU5aZ+eLGvc/BYjls+dliR5dLPggtZ0/4YdSZJT58+YmBOMBBfr75yY/gEAAA6D4AIAmDxW3VRvl1ycVNsa3v3yOcPBxRbBBa1pJLg4baKCi0UX1NvVP56Y/gEAAA6D4AIAmDxW3Vhvlz1pQrpfJrigxd2/cYJHXCy6MCkqSe+apGfNxJwDAADgEAQXAMDksermerv0sgnpfmTExSpzXNCCyrLMAxN9q6jOGcn8s+vLq2+ZmHMAAAAcguACAJgcdm/bO2HwBAcXDwxPgAytZOWW3dnRN5iOaiUnzp0+cSdacsnwCX80cecAAAB4AoILAGByGPn09+wVyfR5E3KKcxZ3J0ke2rQz23cPTMg5YKx+/OjWJMk5S7rS0TaBL+NXPKPe3vvViTsHAADAExBcAACTw8jE3BM0v0WSzJnekWVzpiZJfrp6+4SdB8biJ8PBxUXLZk/siU57QVJpTzbdm2y8d2LPBQAAcBCCCwBgclg5PDH3BN0masQFS2clSW5duW1CzwNH6ifDv5MXLZ81sSea0pWc/Mz68k8/NbHnAgAAOAjBBQDQ+vp3JY98r7584lMm9FQjwcVPHt02oeeBI9G7ZyB3rulJklx84gSPuEiSC15Vb2/5aDLktmkAAMDRJbgAAFrfwzckg3uS7mXJ/LMn9FSXrZiTJLnxoc0ZqpUTei44XD96cEuGamVOnDstS2ZNnfgTnvULyfT5yY51yd1fmPjzAQAA7ENwAQC0vnu/Um9P/7mkKCb0VOcu7srMKW3p2TOYO9eY54LW8N37NyVJnnrqxExM/xhtHcklr60v3/Tho3NOAACAYYILAKC1lWVy71fry6e/cMJP11at5PIVc5Mk339g84SfDw6lLMt8596NSZKnnnKUgoskueR1SVGpj3had8fROy8AAHDcE1wAAK1t/U+TntVJ+7TkpKcflVM+5RTBBa3j7nW9eXDTznS0VfKM049icNG9NDn7qvryt//i6J0XAAA47gkuAIDWNnKbqJOflbRPOSqnHLkdz00PbUn/YO2onBMezxdvX5skedbpJ2TmlPaje/Jn/VGSoj7PxZqfHN1zAwAAxy3BBQDQ2kZvE/VzR+2Upy+YkXkzOrJ7YCi3rtx21M4LBxocquWTt6xKkrz4gsVHv4ATzkjO+3/qy9/8X/VbtwEAAEwwwQUAMD6D/cnt/yfZvrrxfe/YmKy6ub582gsa3//jKIoiVwzPJfD9BzYdtfPCga67a33W9ezJ3Okd+blzFjSniGf9UVJpS+6/Lrn5X5pTAwAAcFwRXAAAY7d7W/LvL08+/RvJR38+6d/Z2P7v/XKSMll0QdJ1dD9tPjrPxf3muaA5yrLMB69/IEnyqictT2dbtTmFzD0lec6f1Je/+N+TGz9k5AUAADChBBcAwNjd8+Xk4Rvqy1sfrr+p2ag3NMsyuenD9eWRCYKPopHg4icrt2ZX/+BRPz988+4NuX3V9kzrqObXn3pSc4t5yu8ml/x6kjL50tuTz70lGdjT3JoAAIBjluACABi7C1+VPOd/Ji/486SoJLf9Z/Ltv2hM33d/MVl7a9I2Jbn4tY3p8wgsnzMtS2ZNzcBQmR88YNQFR98/Xv9gkuQ1V5yYuTM6m1tMpZK8+G+T572r/rd+678nH35+cveXjL4AAAAaTnABAIzPM34/ecrvJC/66/rz6/8i+cEHxtfnPV9OPv2b9eVL35BMnzu+/sagKIr83DkLkyT/+oNHjvr5Ob7dtnJbbnx4S9qrRV7/1BXNLqeuKJKnvTX51U8lU2cn625PPvGq5JO/ngzsbnZ1AADAMURwAQA0xqWvT57xB/Xlr/6P5LNvTvp2HFkfQwPJdX+a/Ocrk4Fd9Qm5n/+uxtd6mH79qSelUiTfuXdjbl+1rWl1cPz50A310RYvuWBxFnRNaXI1BzjlOcnV302e/Ob6pN13fib5t5fX57wBAABoAMEFANA4z37H8CS+Rf1WMh96TrL1MEYrbF+VXP9XyT8+M/ne++rrLvvN5JX/kVTbJ7TkJ7JszrRcdeGSJMk1n78ztZpb4jDxVm7ZlS//dF2S5DeednKTq3kc3UuTF747+bXPJ51dyaZ7kp2bml0VAABwjBBcAACNUxTJM96evO4LycxF9Tcz33d+8h+vTDbee/Bjfvqp5ANPSb7158mGO5Mp3ckvfyx50f/b1NBixB9eeWamd1Tz40e35dM/Wd3scjgOfOiGBzNUK/O0U+fl7MVdzS7niZ301OTXv5T8yieTeac2uxoAAOAYIbgAABrvpKclr/9qsvD8+vN7v5z849OTH34wGRqsr+vrTT77puSTr0/6ticLz6tP/Pu7tyZnv7RppR9oQdeU/M5zT0uS/MWX707PnoEmV8SxbNOOvlx708okyZuedUqTqzlMC89Lllzc7CoAAIBjiOACAJgYs09Mrr4hefON9XviD+5JvvJHyd9fnHzm6uTvL0lu/XhSVOpzY/zmt+oT/06b0+zKH+P1T12Rk+dNz6YdffnLL9+dsnTLKCbGR773UPoGa7lg2axcccrRn5QeAACgFQguAICJdcIZya9+OnnR3yTT5ibbHklu+89kx/qke1nyui8mz/njlrgt1OPpaKvknb9wTpLk4z96NH/6uTuFFzTcxt6+fOz79TlhfvuZp6QoiiZXBAAA0BxtzS4AADgOFEVy2RuSC16V3P6JZNvK+r3xT3xa0j6l2dUdlmeefkL+/Kpz8yef+2n+7YePZNGsKXnTs9zTn8Z5z5d+lt6+wZy7pCsvOHtBs8sBAABoGsEFAHD0dExLLn19s6sYs1998okZGKrlXf/3rrz3K/dk7vSOvOKy5c0ui2PAtTc9mk//ZHWKIvmzl56bSsVoCwAA4PjlVlEAAEfg15+6Im942ookyR9+6o686p9+mM/dujrbd5u0m7G5fdW2/Mnn7kySvO15p+fi5bObXBEAAEBzGXEBAHCE/ueLzkpnWyX/cP0D+cGDm/ODBzenWily2Umz87yzFuT5Zy/IiXOnN7tMJoFNO/ry2//+4/QP1vK8s+bnzc92+zEAAICiHOPMkj09Penu7s727dvT1dXV6LoAAFremm278583Ppov3bE2D2zcud+20+bPyPPPXpCXX7wkp86f2aQKaVX9g7V88+4N+f994a6s3rY7J82dls+95Wnpntq6k9QDAAAcSqNyA8EFAEADPLp5V77+s/X5+s/W50cPbclQbe9LrIuWz8r/c8myXLhsVmZ0tmXJ7KmpmsPguLN990C+fc+GXHfX+lx/z8b09g0mSU6aOy0fft1lOeWEGU2uEAAAYHwEFwAALWr7roF8+94N+b+3rcm37tm4X4iRJNM7qjlrUVdmTevInOntWTZ7Wp5++gm5cNms5hTMhKjVytyzvjc/eGBzvv6z9bnxoS0Z3Od3Yd6MzvzypUvz2886JTOnGGkBAABMfoILAKCllWWZHQM7UqTI1LapqVaqzS6pKTb07slnf7I6n7t1TTb09qVn90D6BmsH3XdmZ1tmTGnLtI5qZnS2ZXpnW9qqlYy8XLtw2ayctmBmFszszIKuKZk1rT0dbZW0VytpqxQpiv1HcYwcd+B6GqMsy/QN1tKzZyC9ewazbVd/Htm8K49s3pU7Vm/PzQ9vSc+ewf2OGbmF2PPPXpALls5KxcgbAADgGCK4AACa7p4t9+T3vvV76ah2pLPamWpRzc6Bnent7832/u0ZrO1903ZKdUqmtU9Le6U9uwZ3pVJU0tXRNfqY0TEjlaKSIvU3cosUqf937xvyxch/9nkjvkiRaqWaSlFJtai3I49qUR3tryEa0FVZJtt2DWTLzv70D9ayq38oW3b25aFNu1Ib08uyvUVVK0mlqH+PhsoyQ7UyRVFfVy3qAUa1UqRSJNXhoKNaFKlUkmpRqR97mF9jMdxfZfhnNLLuwJqSMmWZlMNf+77rRr4fZcrR5frWkdClqG8p63uUwxv3a/fpP6Pry/3O99h+9+/jwHUZXjfSZ7nfuYqRpRzOj6u9WsmiWVNy4pxpWTFvRmZN2zuyolGB0t76y+z70n7kebm3+tHvz8hxZcr9nh+sn2L4d2rk77NSVPZfN7x89QVXp63S1pCvCQAAmJwalRv4lwUAMGY7B3Zm9Y7Vh7XvnqE92TO0Z7912/u2T0RZk1L73Mb215aDv9AbGn4MNPZ0T6w4oJ0EijSu3PVJ1m9LbtzWoA5b1BsveGOzSwAAAI4RggsAYMzOmHNG/uPn/yN9Q33pH+rPQG0g09unZ2bHzHR3dmdW56xUikp2DuzMrsFd2TmwMwO1gUxtm5qyLNPT35Oevp5s79+eHf07HvNJ8AOXH7Nt+JPhtbKWwXIwtbL2mMd4jXFw6v59ZAL6KJNaWQ4/kqHa8HKtvm+lUh9NkdT3G9k+VKuPFBgqy9Rq9WNrw8tD5fAogoO8Y18kB3yaP8Pf+31K2nd5+JiRQQXF6P/sk2Pss7IoDly//0iOkV2LFClTHtD33oP39lM8tr/RkTvDFR5ktMhoYFHs00exb5BRH5Uy8vNoqxRpq1bGFHI04vdixN6vY/9RSfuuH3n+mO37fh+Gt+07Umn07yy14d+7Wmqp7R2xMfw3WEmlYV8PAABwfBNcAABjNr19es474bxD7tdR7cjszD4KFQEAAACTnY9FAQAAAAAALUNwAQAAAAAAtAzBBQAAAAAA0DIEFwAAAAAAQMsQXAAAAAAAAC1DcAEAAAAAALQMwQUAAAAAANAyBBcAAAAAAEDLEFwAAAAAAAAtQ3ABAAAAAAC0DMEFAAAAAADQMtrGemBZlkmSnp6ehhUDAAAAAABMTiN5wUh+MFZjDi42b96cJFm2bNm4CgAAAAAAAI4dvb296e7uHvPxYw4u5syZkyR59NFHx1UAMHn19PRk2bJlWblyZbq6uppdDtAErgOA6wDgOgAkrgXA3uvAXXfdlcWLF4+rrzEHF5VKfXqM7u5uFyM4znV1dbkOwHHOdQBwHQBcB4DEtQBIlixZMpofjJXJuQEAAAAAgJYhuAAAAAAAAFrGmIOLzs7OvPOd70xnZ2cj6wEmEdcBwHUAcB0AXAeAxLUAaOx1oCjLsmxATQAAAAAAAOPmVlEAAAAAAEDLEFwAAAAAAAAtQ3ABAAAAAAC0DMEFAAAAAADQMgQXAAAAAABAyxBcAAAAAAAALUNwAQAAAAAAtAzBBQAAAAAA0DIEFwAAAAAAQMsQXAAAAAAAAC1DcAEAAAAAALQMwQUAAAAAANAyBBcAAAAAAEDLaBvrgbVaLWvWrMnMmTNTFEUjawIAAAAAACaZsizT29ubxYsXp1IZ+7iJMQcXa9asybJly8Z8YgAAAAAA4NizcuXKLF26dMzHjzm4mDlz5mgBXV1dYy4AAAAAAACY/Hp6erJs2bLR/GCsxhxcjNweqqurS3ABAAAAAAAkybinlzA5NwAAAAAA0DIEFwAAAAAAQMsQXAAAAAAAAC1DcAEAAAAAALQMwQUAAAAAANAyBBcAAAAAAEDLEFwAAAAAAAAtQ3ABAAAAAAC0DMEFAAAAAADQMgQXAAAAAABAy2hrdgEAAExia36SfPN/JbXBpBxKarUkZVKWY2xzdI4/XOUR7DuiqCRFMdxWkhR711Wqw8vV4eVqUqkcZF11eP+24Ud7fV2lLam2J22dyYwFyYwFGdi5Lf+xbnE+uenE7B4YylCt3O+RJNVKkaKot9WiSGW4HVlXFEmlKFIURSrDy7WyzOBQmYGhWgaH+yrLMrUyKVOmHP52lmV50O/owb51B+558H0Or6+D7Xngfgfv6yDHHeY5D3bsgYqi2Gf5gG2Pt99j+jj4UU/c377r999x/20Hr+FAjznX4/S/7/r/euMVWdA15XH7BACAwyW4AABg7HZtSe6/rtlVHNfak7yybMtXBv4wd9TOaXY5HMdGgjIAABgvwQUAAGM3/+zkqg/uM0pgeGRBijG0GeNxY+xnQowMQ6jtvzza1oZHpgzt05YHWTe8b21w72NooL6tNpj070x2rE92rM/ue76Rqdmdf+n822w8/40Z6F6RsnNGirYpGepamv6ZJ6aW+pvKtbLMUC2joyeGhkdQ1Mrh0RS1+nKtLFMpirRXK2mrFmmr1Nsiw4NJipHlfdY9waf8H8/B9jmcfh478uCxOz3R6ITH73ts/YzY9237xw7OKA+67cDd9t928GOOZL/DOebQNZUH3XbguebO6Hj8kwMAwBEQXAAAMHZdi5ILX93sKo5bG3v78rTbvpSPtL03T6neleW3/e1jd+pakpz3S8lT35pMm3PUawQAADhSggsAAJik7lyzPX1lR94z65r836c8kKy7I9n2aDKwqz4qY8uDSc/q5HvvS+74ZPKrn0rmn9XssgEAAJ6Q4AIAACap1dt2J0nmz52TXPFzj92hf1fywDeT6/402fJA8vnfTd7wtcO7jxMAAECTVJpdAAAAMDart9aDi8Wzph58h45pyVkvTl73xaR9WrLqxuSeLx3FCgEAAI6c4AIAACapNcMjLpbMfpzgYkTXouSy36gv3/ofE1wVAADA+AguAABgkhq5VdSSxxtxsa8LXllv7/tasnvbxBUFAAAwToILAACYpA55q6h9LTgnOeGsZKg/ufcrE1wZAADA2AkuAABgEhocqmVdz54kydJD3SpqxJkvqreCCwAAoIUJLgAAYBLa0NuXWpm0VYqcMKPz8A4648p6e/83ksH+iSsOAABgHAQXAAAwCW3ZWQ8e5kzvSKVSHN5Biy9Ops9P+nqSB789ccUBAACMg+ACAAAmoa279gYXh61SSc55WX35jv+agKoAAADGT3ABAACT0MiIi9nTjiC4SJLzX1Fvf/aFZNeWBlcFAAAwfoILAACYhLbuHMOIiyRZcnGy4LxkcHfyww9MQGUAAADjI7gAAIBJaMuugSTJ7OntR3ZgUSTP+sP68o/+Menf1eDKAAAAxkdwAQAAk9DoiIsjvVVUkpzxomT2SfVJuu/6XGMLAwAAGCfBBQAATEJbhifnnn2kt4pK6pN0X/ir9eVbP97AqgAAAMZPcAEAAJPQmOe4GHHB8CTdj3wv2bGxQVUBAACMn+ACAAAmoS3DwcXssdwqKklmLU8WXZCUteTerzSwMgAAgPERXAAAwCS0ddc4R1wkyZkvrrd3/J8GVAQAANAYggsAAJhkyrLM1p0DScY4x8WI81+RFNXkoeuTVbc0qDoAAIDxEVwAAMAks3XXQPqHakmSE2Z0jr2j2SfWw4sk+f77GlAZAADA+AkuAABgklmzbXeSZN6MznS0jfMl/RVvrrc/+0LSs3aclQEAAIyf4AIAACaZddv3JEkWdU8Zf2cLz02WX5GUQ+a6AAAAWoLgAgAAJpm1PfXgYmEjgoskOf2F9Xa1eS4AAIDmE1wAAMAks257/VZRDRlxkSSLL6y3a29tTH8AAADjILgAAIBJZu3oraKmNqbDhefX260PJ7u3NqZPAACAMRJcAADAJNPQOS6SZNqcZNaJ9eW1tzWmTwAAgDESXAAAwCQzMuKiYXNcJMmCc+vtpvsa1ycAAMAYCC4AAGASKcsyaxs9x0WSdC+ttz2rG9cnAADAGAguAABgEtm+eyB7BmpJkgVdjQwulgyfQHABAAA0l+ACAAAmkZHbRM2d3pEp7dXGdTwy4mL7qsb1CQAAMAaCCwAAmETWTcT8FknSNXKrKMEFAADQXIILAACYREZGXDR0fotk762ietYktaHG9g0AAHAEBBcAADCJjEzM3fARFzMWJkU1qQ0mOzY0tm8AAIAjILgAAIBJZO+Ii6mN7bjalsxcVF/uMUE3AADQPIILAACYREZHXHQ1eMRFss8E3Ssb3zcAAMBhElwAAMAkcv+GHUmSFSdMb3znI/NcbDfiAgAAaB7BBQAATBLbdw1kfU9fkuS0+TMaf4KukeBiVeP7BgAAOEyCCwAAmCTu3dCbJFkya2pmTmlv/Am6l9XbHsEFAADQPIILAACYJO5ZVw8uTl8wAaMtEreKAgAAWoLgAgAAJom9wcXMiTnB6OTcRlwAAADNI7gAAIBJoCzLfOueDUmSi5bPnpiTdA0HFzs3JIN9E3MOAACAQxBcAADAJHDnmp6s2ro7U9ureebpJ0zMSabNSdqm1peNugAAAJpEcAEAAJPAl3+6NknyrDNOyNSO6sScpCiS2SfWl7c+PDHnAAAAOATBBQAAtLiyLPPln65Lkrzw3IUTe7LZK+qt4AIAAGgSwQUAALS4+zfsyIMbd6ajWslzzpw/sSebfVK9FVwAAABNIrgAAIAW96kfr06SPPXUuZk5pX1iTzZnZMTFQxN7HgAAgMchuAAAgBbWNziU/7p5ZZLkFZctn/gTGnEBAAA0meACAABa2H/+6NFs2dmfhV1T8ryzJvg2UcneOS62PJyU5cSfDwAA4ACCCwAAaFF3rtmev77u3iTJW55zatqqR+Hl++wTk0pb0t+bbF818ecDAAA4gOACAABa0NfuXJdX/OMP07tnMBctn5VXPeko3CYqSdo6k/ln1ZfX3nZ0zgkAALAPwQUAALSQWq3M+75+X37r327Jjr7BXHHy3Hz015+UaqU4ekUsvKDerrv96J0TAABgmOACAABaRFmW+cNP3Z6//Xr99lCve8pJ+dgbnpTuqe1Ht5BFw8GFERcAAEATtDW7AAAAoO6vvnpP/s8tq1KtFHnPy87LL1+2rDmFjAQXK3+UDPYnbR3NqQMAADguGXEBAAAt4KPfeygf+PYDSdLc0CJJllySzFiY7N6a3Pvl5tUBAAAclwQXAADQZN/42fq86wt3JUn++/NPb25okSTVtuTCV9eXb/xQc2sBAACOO4ILAABoooc37cxbr701ZZm86knL85bnnNrskuoueV1SaU8eviF54JvNrgYAADiOCC4AAKBJ+gaHcvW/35LePYO55MTZedcvnJOiKJpdVt3sE5PL3lBf/uLbk/6dza0HAAA4bgguAACgST783Ydy97rezJ3ekQ/8ysXpaGuxl+fP+qNk5uJkywPJp38rGRpsdkUAAMBxoMX+ZQQAAMeHtdt35++/cX+S5I9fdFYWdE1pckUHMXV28osfSqodyd1fSD7zRuEFAAAw4QQXAADQBH/+hZ9l98BQLjtpdl520ZJml/P4Tnpa8ssfSyptyU8/mVz7q8nQQLOrAgAAjmGCCwAAOMq+ftf6fPGOtalWilzTSvNaPJ4zrqyHF21Tknu/nHz3b5tdEQAAcAwTXAAAwFG0dvvu/OGnbk+S/MbTV+Scxd1Nrugwnfmi5BfeX1/+1ruT6/8qGdjT3JoAAIBjkuACAACOkv7BWt788R9n887+nL2oK//teac3u6Qjc94vJU/6rSRl8q0/T/7uouT7f5/s3NzsygAAgGNIUZZlOZYDe3p60t3dne3bt6erq6vRdQEAwDFl046+/N4nfpLv3b85M6e05Yu/8/Qsnzut2WUdubJMbvvP5Jv/K+lZVV9XaUvmnpYsOLvezlqWLDgnWXh+Uqk2t14AAOCoaVRu0NbAmgAAOM7UamVueXRrLlw2K+1Vg3kfzy2PbMmbP/6TrOvZk6nt1fz9qy6anKFFkhRFcuGrk3Nentz+ieTmf0nW3pZs/Fn9sa/OrmT5k5MTn1qf5HvRBUm1vTl1AwAAk4YRFwAAjNkdq7bnJe//bqZ3VNM1tT1DtTK1Mpk5pS2XnDg7Tz11bi5aNjvL50xLpdLiE1BPkB8+uDm/9uEb0z9UyyknTM8//OolOW3BzGaX1VjbVyXr70o23JlseSjZ9kiy+sdJX8/++7VPr4/EmLkgmX5CUhtK+nfWH+1TkiWXJssuTxadn7R1NudrAQAAxqxRuYHgAgCAMfvqnevyR5+6PVt3DTzhfvNmdGbp7Kk5a9HMdE1pz+kLZubMRTNz6vwZ6Ww7Nm8lVKuV+eQtq/Ku/3tndvYP5Xlnzc/7XnlRpnceJ4Oea0PJujuSR76XPPy9ertn2+EdW+1MFl+YdC1Jps7e++hanCw4N5l7yv63oBoaTMohYQcAADSZ4AIAgJZQq5W5f+OO9A3UUqkklaLIup49+dGDW/Ld+zfmvvU70jdYO+ix1UqRU06YnjMXduW0+TMyZ0ZHZk3tyKxp7emeOvyY1p6ZnW0pitYfsTFUK3PH6u35xs/W5zM/WZ1VW3cnSZ566tx8+LWXZUr7sRnSHJZaLdlwV7LlgWTHhmTnxqTSnnRMrz92bU5W3ZSs/FF9+Ym0TanPpdE+JenrTTY/kNQGklnL6+s7picdM+pt54z6LaumzkqmzEo6Z9bXT+muP586u95fWauHH7Whejs0UF/XNqX+qB4ngdNYDeypB0eT4O8UAICJI7gAAKDpdvTvyCO9jxx0W61WSy219A0O5r4NvdmyYyCrtvRl90AtD2/uzcObd2RH39D+B5UHvulZf16tFJneUc2MKe2Z0dmeKe2VtFcraatU0l4t0lappK1apK1aSUelkrbq8PNKMbpftbL/e6pFihTFyBmSFMU+y/U5qGu1MrWyfvurWq1MLUlZlsO3xCozOFRmR/9gdu4ZTM+ewdy7vjc7+wZHzzG9sy2vuHRZXnbxklQa9IbuZAhwxqMok2xfmWy4uz5Co6+3fsupPduTntXJlgeTwT1NKKyaVKck7R1JpSOpVJJU6m1R3fu8GFk3vL6o1EeHFMXw/tV9thX77L/P+kqxT18H2796kHMXGf1t3u93pNivecyT0X0Psq42OPwYSob6k4HdyeDuejuwp/5z2NOb7NqQ7N6ek996d9qnz2vQNxwAgMnI5NwAADTd7Rtvzxu//sYjP7AjyaJk+hEcMpRk+/DjMRuGkjzx3aomXluSJY/9mq5dm1z7xWYUdAxqT7JgdrOr2Edt+DF4qB33P+RYUSSZmmTqtCTTct3Gu7Jw+jOaXBQAAMcCwQUAAGPWUe3IwukLH7O+LMtUi2qKokilqKRIkVpZS62spUyZSlEZXV+mHD0myejzffsaKsvUavW2HB4BUaZMhtuyrB+1t48MbxvucXR5bPYdiVHss6ZI/cPplaI+eqOtWh8BctjGU1STHPjzmQyesOayzN4fxEFGHYxsHxmovt/+2btcHvD8kNuGn5cHPB8t6yD7Pqbux+u30Yq9349ieGRHURl+vnd0SXHC6RNcBwAAxwvBBQAAY3bpwktz3S9d1+wyAAAAOIZUml0AAAAAAADACMEFAAAAAADQMgQXAAAAAABAyxBcAAAAAAAALUNwAQAAAAAAtAzBBQAAAAAA0DIEFwAAAAAAQMsQXAAAAAAAAC1DcAEAAAAAALQMwQUAAAAAANAyBBcAAAAAAEDLaBvrgWVZJkl6enoaVgwAAAAAADA5jeQFI/nBWI05uNi8eXOSZNmyZeMqAAAAAAAAOHb09vamu7t7zMePObiYM2dOkuTRRx8dVwHA5NXT05Nly5Zl5cqV6erqanY5QBO4DgCuA0DiWgC4DgB7rwN33XVXFi9ePK6+xhxcVCr16TG6u7tdjOA419XV5ToAxznXAcB1AEhcCwDXASBZsmTJaH4wVibnBgAAAAAAWobgAgAAAAAAaBljDi46Ozvzzne+M52dnY2sB5hEXAcA1wHAdQBIXAsA1wGgsdeBoizLsgE1AQAAAAAAjJtbRQEAAAAAAC1DcAEAAAAAALQMwQUAAAAAANAyBBcAAAAAAEDLEFwAAAAAAAAtQ3ABAAAAAAC0DMEFAAAAAADQMgQXAAAAAABAyxBcAAAAAAAALUNwAQAAAAAAtAzBBQAAAAAA0DIEFwAAAAAAQMsQXAAAAAAAAC2jbawH1mq1rFmzJjNnzkxRFI2sCQAAAAAAmGTKskxvb28WL16cSmXs4ybGHFysWbMmy5YtG/OJAQAAAACAY8/KlSuzdOnSMR8/5uBi5syZowV0dXWNuQAAAAAAAGDy6+npybJly0bzg7Eac3Axcnuorq4uwQUAAAAAAJAk455ewuTcAAAAAABAyxBcAAAAAAAALUNwAQAAAAAAtAzBBQAAAAAA0DIEFwAAAAAAQMsQXAAAAAAAAC1DcAEAAAAAALQMwQUAAAAAANAyBBcAAAAAAEDLEFwAAAAAAAAto63ZBQAAAJPYri3JPV9KaoPDj6G9y2UtKcv924w833dbbZ9t5WO35YD9yuH99t0/Zb2efdfvt+4giuLAFS22PYfY3uz6Gri9fWpy8rOSFc/IkSjLMqu27s4jm3dl046+7OwfzO7+oezsG8qugcEMDJYZGKplsFZL/2A5etpKkVSKIkWRFEWx93lGnhcH7HfA8332qxTZp5+DHJfh55X9j2urFKlUilQrSbVSSbXYZ7mS4X0qqVSSalGkrVqkWqmko1pJR1slnW31drBWpm9gKH2DtewZbvsGa6PramWZoVqZWpnUamWGyjK14b+JIsPfg+HvS5H6k5E6i9HvVzH64+psq2ZGZ1u6p7bntAUzMqW9ekQ/MwCAwyG4AAAAxq5ndfK5Nze7Co4FN/x18gvvTy5+zWHt/s271+edn78zK7fsnuDCeDwdbZW84tJl+eMXnSXAAAAaSnABAACMXWdXctrPJZW2pFLd2xbVepuRj6NX9mmHH9n3eXGI7fvskwP6GzlHss/y8PN9l/dzwCiMx4zKONT2RvQxEecY5/GHdY5xbj/YPmtvSx74RvKltydnvSSZOuuxx+zj1pXbcvW//zj9g7V0VCtZPndaFnR1ZnpHW6Z1VDOtsy1T26vpaKukvVpJR7VIW7WSYriaWlmmHB6BMPK8VtZHcJTlPs+zd7/9nh+43+Mdd5DtZZn6qIdamcFaOToiYrBWjo6IGKod8Bjef2CoTP9QLf2Dw4+hWtoqRTrbKulsr9bbtko626rpbK+PzmirjowMKVKt7B0lMvKTqf8o6nXt+72pbytHf1xlytRqSd9gfUTL5p192bSjP//2w0eyaUdf/r9XX5xK5WB/awAAR05wAQAAjN3sE5Nf+a9mV8FkV6sl77sg2f5oPcQ4+ZlPuPtff+2e9A/W8pwz5+f9r74o0zr80/ZoK8syX//Zhrzp47fkyz9dl7/86t35H1ee1eyyAIBjhMm5AQAAaK5KJVl8YX153e1PuOtDm3bmhvs2pSiSa15yjtCiSYqiyPPPXpD3/tL5SZJ/vP7B/OjBzU2uCgA4VniFBwAAQPMtOj/52eeTtU8cXHzlp+uSJE8/7YQsnzvtaFTGE3jZRUuzcsvudLZV8qQVc5pdDgBwjBBcAAAA0HwLL6i3hxhxccfqbUmSp5wyd4IL4nD97nNPa3YJAMAxxq2iAAAAaL6F59bbTfclQ4OPu9sdq7cnSc5f0n00qgIAoAkEFwAAADTfjIVJpT0ph5Id6w66y9ad/Vm5ZXeS5BzBBQDAMUtwAQAAQPNVKknXovry9tUH3eXONT1JkpPmTkv31PajVRkAAEeZ4AIAAIDW0LW03vYcPLhYs70+2mL53OlHqyIAAJpAcAEAAEBr6Fpcbx8nuNi0oy9JcsKMzqNVEQAATSC4AAAAoDV0L6m3j3OrqE29/UmSeTM7jlZFAAA0geACAACA1jB6q6hVB9280YgLAIDjguACAACA1nDIERfDwcVMwQUAwLFMcAEAAEBr6BoOLh5njouRERfzjLgAADimCS4AAABoDSPBxY4NyWD/YzZvElwAABwXBBcAAAC0hunzkmpnkjLpXbvfpv7BWrbtGkjiVlEAAMc6wQUAAACtoSiSrsX15QNuF7V5Z320RbVSZNbU9qNdGQAAR5HgAgAAgNbRvbTeHjBB94aekdtEdaRSKQ7dz91fTK791eSBbza6QgAAJpjgAgAAgNYxOkH3qv1Wr92+O0myqHvqofvoWZt8+o3Jz/5v8m8vSx78doOLBABgIrU1uwAAAAAY1T0cXBww4mLNtj1JksWzphy6j+//fdLfu/f5x16anH1VcvnVyf3XJYsuTM58cVLxWT4AgFYkuAAAAKB1jMxxsX0cIy5W31xvr/yr5DvvTXZuTO76bP0x4klvTH7+veOvFwCAhvPxEgAAAFrHvDPq7drbkrIcXb1m+8iIi0MEF7Vasv6u+vJJT0veeEPySx9JVjyzvq4yPLH3jf+Y3Pu1RlYOAECDCC4AAABoHUsuSSptSe+aZNujo6vXbquPuFjcfYhbRW1/tH6bqEp7Mu+0pGtRcu7Lk9d+Pvn9B5L/uSF58pvq+379mnrQAQBASxFcAAAA0Do6ptXnoEiSR384unpkjotFhxpxMTLa4oQzk2r7/tumz6vPa/HMP0imdCcb7kzu+WKDCgcAoFEEFwAAALSW5U+ut/dflyTZtKMvG3qHbxV1qBEXG+6stwvOfvx9ps5OLn1Dffmmfx5PpQAATADBBQAAAK3l3JfX2zs/k2xflTd//MeplcmKedMzb0bnEx+76b56O+/0J97v0l9PUiQPfjvZ8tB4KwYAoIEEFwAAALSWJZckJz09qQ2mvOlfcvMjW5Mkf/+qi1KpFE987GhwcdoT7zdrebLi6fXlu90uCgCglQguAAAAaD2XvC5JUt75mQwNT6B9ygkznviYskw2319fnnuI4CJJznxxvRVcAAC0FMEFAAAAree0FyTVzlS2Ppgzi5XpqFYypf0Q/4TduTHp60lSJHNOPvQ5zvj5evvoD5Ktj4y7ZAAAGkNwAQAAQOuZ0pWc9vwkyZvaPpfuae0pisO8TdSs5Un7ISbxTpJZy5KTn5WkTG760LjKBQCgcQQXAAAAtKZn/mHKFPmF6g9yXse6Q++/4a56e6iJufd1+W/X2x9/LOnfeeQ1AgDQcIILAAAAWtOi87N99nlJkjPaDiO4eOT79XbZkw7/HKe9IJm9ItmzPbntE2MoEgCARhNcAAAA0LJ2tnUnSea37XriHctyb3Bx4lMO/wSVSvKk36ov/+gf6/0AANBUggsAAABa1o5KV5JkXvUQt3Ha8mCyY11S7UiWXHJkJ7noV5KOGcmme5IHvzXGSgEAaBTBBQAAAC2rp5iZJJld7HjiHe/4P/V2+ZOT9qlHdpIp3cmFr64v/+gfj7BCAAAaTXABAABAy9pazkiSzMoTBBe1oeTH/1Zfvug1YzvRk95Yb+/9arL5gbH1AQBAQwguAAAAaFlbatOTJDPK3sff6YFvJj2rkimzkrN+YWwnmndqfaLulMlNHx5bHwAANITgAgAAgJa1cageXEwf6tl/w40fSv7qtGT1j5NbPlpfd8Erk/YpYz/ZZb9Rb2/7z2Swb+z9AAAwLoILAAAAWtbKPfUgYurg9r0rd2xMvvT2ZOeG5PO/m9z7lfr6i187vpOd8txk5uJk95bkni+Pry8AAMZMcAEAAEBL+v79m3Ln1rYkBwQXt3xk7/L6O5LaYLL0ScmCs8d3wmpbcsEr6ss//dT4+gIAYMwEFwAAALScBzfuyO9de2u2lfVbRVX3bEvKsr5x3e2PPeCScY62GHHOy+vtfV9L+p5gQnAAACaM4AIAAICW80/feTAbe/syb/6i+oqhvmRgV31503319vxXJosuTM58cXLuLzbmxAvPS+ackgzuqYcXAAAcdYILAAAAWs7d63qTJL/13POSakd95a7NydBgsvmB+vPn/M/kjdcnr/x40j61MScuiuTMn68v3/vVxvQJAMAREVwAAADQUsqyzP0b6rdpOm3hzGT2SfUND30nefeipDaQtE9LupZMTAGnvaDe3n9dUhuamHMAAPC4BBcAAAC0lLXb92RH32DaKkVOmjs9WXh+fcNX/zgZ6q8vD+xOKhP0T9rlVySdXfURHmtvm5hzAADwuAQXAAAAtJT7hkdbnDRvejraKsmi4eBiz7a9O13yuokroNqeLH9yffnRH07ceQAAOCjBBQAAAC3lZ2t7kiSnzZ9RX7HwvP13eOFfJs9/18QWsezyertScAEAcLS1NbsAAAAA2Nd37t2YJLnkxNn1FYsuTCptSW0wmXVicvkb65NoT6SRERcrb0zKcuLPBwDAKMEFAAAATVeWZf731+/Lrv7BfP+BzUmS5561oL5x2pzk1dcmG+9Nznjh0QkRFl+cVDuS3rXJujv23q4KAIAJJ7gAAACg6e5Z35v3feO+0ecr5k3PinnT9+5w6vPqj6OlY1pyxpXJXZ9Lbv244AIA4CgyxwUAAABN9a/ffzgv/N83jD5f0NWZ3/+5M5pY0bCLXlNvb/tE0r+zubUAABxHBBcAAAA0zZptu/POz985+vy/Pe/0/OCPnpufP29RE6sadspzkjknJ3u2JT/+WLOrAQA4bgguAAAAaJqPfO+h/Z4/7bS5qVRaZCLsSjV5yu/Wl7///mSwv7n1AAAcJwQXAAAANEVZlvnC7WuTJNM6qnnumfNzwdJZzS3qQBe8KpmxIOlZlfz0k82uBgDguCC4AAAAoCnu27Aja7fvSWdbJT/+k+fnw6+7LG3VFvtnavuU5Mm/XV/+7v9OarWmlgMAcDxosVeEAAAAHC++fc+GJMmTT56bKe3VJlfzBC59fdLZlWy6J7nnS82uBgDgmCe4AAAA4KgryzKf/cmaJMmzzzihydUcwpTu5LI31Je//s5ksK+59QAAHOMEFwAAABx1tzyyNXet7UlnWyVXXbSk2eUc2tP+W32ui833J9/4s2ZXAwBwTBNcAAAAcFTt6BvMOz5zR5LkpRcuzqxpHU2u6DBM6U5e9Nf15R+8P7npw82tBwDgGCa4AAAAxmX77oE8tGlns8tgkli1dVd+6YPfz73rd+SEmZ15+8+d0eySDt9ZL0me/vb68hffltz0z82tBwDgGCW4AAAAxuyG+zbmGe/9Vv77f92asiybXQ4tbuWWXXnZB76fu9f1Zt6Mznz4tZdm/swpzS7ryDznfyZXvKW+/MX/ntz4oebWAwBwDBJcAAAAY3bGgpnpGxzKjx/dlm/8bEOzy6GF9Q0O5Tc/dnM29vbljAUz87m3PDXnL53V7LKOXFEkL/jz5Cm/W3/+pbcn3/u7RHAHANAwggsAAGDM5ndNyeuesiJJ8qef+2nWbd/T5IpoVf90/YO5e11v5k7vyEdff1mWzJra7JLGriiS5/9Z8tS31p9f9yfJPz83+cnHk8H+ppYGAHAsEFwAAADj8qZnn5KT503Pmu178qK/uyEf+8HDWbt9d7PLooVcf+/GvO8b9yVJ/vQlZ2dR9yQOLUYURfK8a5IX/mVS7UxW35J87k3JPzwtWXtbs6sDAJjUinKMN6Lt6elJd3d3tm/fnq6urkbXBQAATCIrt+zKb/zrzblnfe/ouiWzpuaCZd05f+msnL+0O+ct6c7MKe1NrJKjbahW5oPfvj9/+/X7MlQrc9WFi/O3r7gwRVE0u7TG6l2f3PrvyQ8/mOzcmLRNSS6/OrnsDcms5c2uDgDgqGlUbiC4AAAAGqJvcCj/+aNH88kfr8pda3pSO8i/NNoqRaa0VzNnekfOWDgzpy+YkTMXduXyFXMyv2uSTdLMQe3oG8xnfrI6a7ftzg33bcodq7cnSV520ZL8xS+el862apMrnEC7tiSfuTq576vDK4rklGcnl74hOePKpHIMf+0AABFcAAAALax3z0DuWLU9t63anttXbcvtq7Zn9bbHv31UR7WSy0+ek5dcsDgXLpuVE+dOO7bf4D4Grdq6K9fetDIf+8Ej2b57YHT9jM62vPMlZ+eXLll67I20OJiyTO75cvKjf0geun7v+vlnJ89+R3LKc5OOac2rDwBgAgkuAACASaVnz0B29Q1l98BQVm3dlYc27cyPH9mau9f15u51vfvtWymSpbOn5ZQTpufi5bPznLPm5+xFXcfHG98toizLXHfX+ty+anu6prZlUffUbN7Rl227B3Li3GnZsWcw23cPZNuugdyzvjffvX9TRv51uWLe9Dzt1HlZPmdaXnLB4izsPk5H02x5KLnlo8nNH0n66iNPUlSSuacmC89PFp639zF1dlKdhLdS2701ueOTyca7kxf9dbOrAQCaTHABAAAcM+5d35uv/nRdvn73hjy4YUd6+wYfs8+MzrZMaa/mzIUzs2zOtDzrjBPytFPnZXpnWxMqPvaUZZnbV23PDfdtzIObduZbd2/I1l0Dhz5wH087dV5+5fLlecE5C1OtCJlG7d6afO/vkls/nuxY/zg7Fcmck5NF5w+HGucn02Yng/1J/85k8/3Jpnvrc2hUO+qPto5k9opk4bnJgnOTGQvqk4YfDUOD9VEl1/9l0tdTX/e7tyZzVhyd8wMALUlwAQAAHJPKsszGHX15cOPO3Lu+N9+5d1O+d/+m7B4Yesy+HdVKls2ZmnOXdOfUE2bkxHnTs3zOtCyeNSVzp3d68zzJ4FAtSbKzfygzO9vSN1jLQ5t25qFNO/Pgxh15cNPO+mPjjvTueWxg9MJzFqajrZK123dnsFZmzrSO7OwfzKypHZk1rT3dU9szb0ZnXnDOgpw4d/rR/vImn971ybo7knW31du1tydbHmhM39Pm1cOPKd3JlK6kc2b90THcds7Y+7x6YOB3wN9KbXDvY2ig3vb11OtfdVOy8kdJ/476viecmVz8a8mFr66PHAEAjluCCwAA4LixZ2AoD23amZ19g3lk867csXp7vnXPhjyyedcTHjezsy1dU9szc0pbuqa0p2tqvZ01rSPzZnZk3ozOzJranq6p7ema0p4p7ZXR21GNvI1bFEmRYr8PshdFUhTFQfcp9jl433X79juyf4q9H5Af2acsy5SpT5WQMilTplZmv/VlfUPKJL17BrN5R1827ejPlp196e0bzI49g9k9MJT71u/IjQ9tSf9weFEpctBJ00d0VCt5/tkLcsbCmdm0oy/nLu7OL1+27DB+QozLYH99VMb6nw6HGrcn636aDOwaHlkxpT6SYd7pycxFw2FCf337pvvqx22+PylrR7fuaXOT5/5pctGvJZXK0T03ANCSBBcAAEDT3b/1/rz2K6896uctiiIpk1pZZqgsM1QrU6vtfT7ypn8jNbi7wzQxI0YqRVKpFKkWRaqV4UdRpFIpUjkO5hEpJuj7+oTnnOjva1nWA42yNvwoU6QcXa4nXcPPR1KvQxY9+j/DCVtRn6Oj0la/TVVl/zk5PnfV5zKzY2ZDvywAYHJpVG7gZrAAAMCYDZVD6envaXYZe428tzpBXR9LasOPgZEFjg/FAe0hlY99OtSfDD12tFPZpHgPADj2CC4AAIAxO6n7pHz+qs8f1XM25c3RcZ5y9DZPBzwfWVFmeJTIsANvHzV6e6kJ/tT+GAfkj/18TfhZNuWcR/n72izT28xxAgA0huACAAAYs85qZ1Z0r2h2GQAAwDHE7FkAAAAAAEDLEFwAAAAAAAAtQ3ABAAAAAAC0DMEFAAAAAADQMgQXAAAAAABAyxBcAAAAAAAALUNwAQAAAAAAtAzBBQAAAAAA0DIEFwAAAAAAQMsQXAAAAAAAAC1DcAEAAAAAALSMtrEeWJZlkqSnp6dhxQAAAAAAAJPTSF4wkh+M1ZiDi82bNydJli1bNq4CAAAAAACAY0dvb2+6u7vHfPyYg4s5c+YkSR599NFxFQBMXj09PVm2bFlWrlyZrq6uZpcDNIHrAOA6ALgOAIlrAbD3OnDXXXdl8eLF4+przMFFpVKfHqO7u9vFCI5zXV1drgNwnHMdAFwHANcBIHEtAJIlS5aM5gdjZXJuAAAAAACgZQguAAAAAACAljHm4KKzszPvfOc709nZ2ch6gEnEdQBwHQBcBwDXASBxLQAaex0oyrIsG1ATAAAAAADAuLlVFAAAAAAA0DIEFwAAAAAAQMsQXAAAAAAAAC1DcAEAAAAAALSMMQcXH/jAB7JixYpMmTIll1xySW644YZG1gW0sGuuuSZFUez3WLhwYbPLAibQd77znbzkJS/J4sWLUxRFPvvZz+63vSzLXHPNNVm8eHGmTp2aZz3rWbnzzjubUywwIQ51HXjd6173mNcHT37yk5tTLDAh3vOe9+Syyy7LzJkzM3/+/Fx11VW555579tvHawI4th3OdcBrAji2ffCDH8z555+frq6udHV15YorrsiXv/zl0e2Nei0wpuDi2muvzVvf+tb88R//cX7yk5/k6U9/eq688so8+uijY+kOmITOOeecrF27dvRxxx13NLskYALt3LkzF1xwQd7//vcfdPt73/ve/M3f/E3e//7356abbsrChQvz/Oc/P729vUe5UmCiHOo6kCQvfOEL93t98KUvfekoVghMtOuvvz5vfvOb88Mf/jDXXXddBgcH84IXvCA7d+4c3cdrAji2Hc51IPGaAI5lS5cuzV/8xV/k5ptvzs0335znPOc5eelLXzoaTjTqtUBRlmV5pMVdfvnlufjii/PBD35wdN1ZZ52Vq666Ku95z3uOtDtgkrnmmmvy2c9+NrfeemuzSwGaoCiKfOYzn8lVV12VpP5pisWLF+etb31r/vAP/zBJ0tfXlwULFuQv//Iv88Y3vrGJ1QIT4cDrQFL/dOW2bdseMxIDOHZt3Lgx8+fPz/XXX59nPOMZXhPAcejA60DiNQEcj+bMmZO/+qu/yutf//qGvRY44hEX/f39ueWWW/KCF7xgv/UveMEL8v3vf/9IuwMmqfvuuy+LFy/OihUr8spXvjIPPvhgs0sCmuShhx7KunXr9ntt0NnZmWc+85leG8Bx5tvf/nbmz5+f008/Pb/5m7+ZDRs2NLskYAJt3749Sf3NisRrAjgeHXgdGOE1ARwfhoaG8olPfCI7d+7MFVdc0dDXAkccXGzatClDQ0NZsGDBfusXLFiQdevWHWl3wCR0+eWX52Mf+1i++tWv5kMf+lDWrVuXpzzlKdm8eXOzSwOaYOT//702gOPblVdemY9//OP55je/mb/+67/OTTfdlOc85znp6+trdmnABCjLMm9729vytKc9Leeee24SrwngeHOw60DiNQEcD+64447MmDEjnZ2dufrqq/OZz3wmZ599dkNfC7SNtbiiKPZ7XpblY9YBx6Yrr7xydPm8887LFVdckVNOOSX/+q//mre97W1NrAxoJq8N4Pj2ile8YnT53HPPzaWXXpoTTzwxX/ziF/Pyl7+8iZUBE+Etb3lLbr/99nz3u999zDavCeD48HjXAa8J4Nh3xhln5NZbb822bdvyqU99Kq997Wtz/fXXj25vxGuBIx5xMW/evFSr1cckJBs2bHhMkgIcH6ZPn57zzjsv9913X7NLAZpg4cKFSeK1AbCfRYsW5cQTT/T6AI5Bv/M7v5PPf/7z+da3vpWlS5eOrveaAI4fj3cdOBivCeDY09HRkVNPPTWXXnpp3vOe9+SCCy7I+973voa+Fjji4KKjoyOXXHJJrrvuuv3WX3fddXnKU55ypN0Bx4C+vr787Gc/y6JFi5pdCtAEK1asyMKFC/d7bdDf35/rr7/eawM4jm3evDkrV670+gCOIWVZ5i1veUs+/elP55vf/GZWrFix33avCeDYd6jrwMF4TQDHvrIs09fX19DXAmO6VdTb3va2vOY1r8mll16aK664Iv/0T/+URx99NFdfffVYugMmmbe//e15yUtekuXLl2fDhg358z//8/T09OS1r31ts0sDJsiOHTty//33jz5/6KGHcuutt2bOnDlZvnx53vrWt+bd7353TjvttJx22ml597vfnWnTpuXVr351E6sGGumJrgNz5szJNddck1/8xV/MokWL8vDDD+cd73hH5s2bl5e97GVNrBpopDe/+c35j//4j3zuc5/LzJkzRz9N2d3dnalTp6YoCq8J4Bh3qOvAjh07vCaAY9w73vGOXHnllVm2bFl6e3vziU98It/+9rfzla98paGvBcYUXLziFa/I5s2b82d/9mdZu3Ztzj333HzpS1/KiSeeOJbugElm1apVedWrXpVNmzblhBNOyJOf/OT88Ic/dA2AY9jNN9+cZz/72aPPR+azee1rX5uPfvSj+YM/+IPs3r07b3rTm7J169Zcfvnl+drXvpaZM2c2q2SgwZ7oOvDBD34wd9xxRz72sY9l27ZtWbRoUZ797Gfn2muvdR2AY8gHP/jBJMmznvWs/dZ/5CMfyete97ok8ZoAjnGHug5Uq1WvCeAYt379+rzmNa/J2rVr093dnfPPPz9f+cpX8vznPz9J414LFGVZlhPxBQAAAAAAABypI57jAgAAAAAAYKIILgAAAAAAgJYhuAAAAAAAAFqG4AIAAAAAAGgZggsAAAAAAKBlCC4AAAAAAICWIbgAAAAAAABahuACAAAAAABoGYILAADgkK655ppceOGFzS4DAAA4DhRlWZbNLgIAAGieoiiecPtrX/vavP/9709fX1/mzp17lKoCAACOV4ILAAA4zq1bt250+dprr82f/umf5p577hldN3Xq1HR3dzejNAAA4DjkVlEAAHCcW7hw4eiju7s7RVE8Zt2Bt4p63etel6uuuirvfve7s2DBgsyaNSvvete7Mjg4mN///d/PnDlzsnTp0vzLv/zLfudavXp1XvGKV2T27NmZO3duXvrSl+bhhx8+ul8wAADQ0gQXAADAmHzzm9/MmjVr8p3vfCd/8zd/k2uuuSYvfvGLM3v27PzoRz/K1VdfnauvvjorV65MkuzatSvPfvazM2PGjHznO9/Jd7/73cyYMSMvfOEL09/f3+SvBgAAaBWCCwAAYEzmzJmTv/u7v8sZZ5yR17/+9TnjjDOya9euvOMd78hpp52W//E//kc6Ojryve99L0nyiU98IpVKJf/8z/+c8847L2eddVY+8pGP5NFHH823v/3t5n4xAABAy2hrdgEAAMDkdM4556RS2ftZqAULFuTcc88dfV6tVjN37txs2LAhSXLLLbfk/vvvz8yZM/frZ8+ePXnggQeOTtEAAEDLE1wAAABj0t7evt/zoigOuq5WqyVJarVaLrnkknz84x9/TF8nnHDCxBUKAABMKoILAADgqLj44otz7bXXZv78+enq6mp2OQAAQIsyxwUAAHBU/Mqv/ErmzZuXl770pbnhhhvy0EMP5frrr8/v/d7vZdWqVc0uDwAAaBGCCwAA4KiYNm1avvOd72T58uV5+ctfnrPOOiuvf/3rs3v3biMwAACAUUVZlmWziwAAAAAAAEiMuAAAAAAAAFqI4AIAAAAAAGgZggsAAAAAAKBlCC4AAAAAAICWIbgAAAAAAABahuACAAAAAABoGYILAAAAAACgZQguAAAAAACAliG4AAAAAAAAWobgAgAAAAAAaBmCCwAAAAAAoGX8/wFqlZQ/bA3JugAAAABJRU5ErkJggg==", "text/plain": [ - "" + "" ] }, - "execution_count": null, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -356,13 +365,71 @@ "output = inference.crop(AUDIO_FILE, Segment(10, 20))\n", "output" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Offline use\n", + "\n", + "Gating models allows [me](https://herve.niderb.fr) to know a bit more about `pyannote.audio` user base and eventually help me write grant proposals to make `pyannote.audio` even better. Please fill this form as precisely as possible. \n", + "\n", + "For instance, before gating `pyannote/segmentation`, I had no idea that so many people were relying on it in production. Hint: sponsors are more than welcome! maintaining open source libraries is time consuming.\n", + "\n", + "That being said: this whole authentication process does not prevent you from using official `pyannote.audio` models offline (i.e. without going through the authentication process in every `docker run ...` or whatever you are using in production).\n", + "\n", + "* Step 1: download the `pytorch_model.bin` model\n", + "\n", + "![](assets/download-model.png)\n", + "\n", + "* Step 2: load the model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# look ma: no hands! \n", + "offline_model = Model.from_pretrained(\"pytorch_model.bin\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# just checking weights are the same...\n", + "import torch\n", + "for weights, offline_weights in zip(model.parameters(), offline_model.parameters()):\n", + " assert torch.equal(weights, offline_weights)" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.9.13 ('pyannote-mps')", "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.9.13" + }, + "vscode": { + "interpreter": { + "hash": "36a3a48a52702f18671693adf589423ec3f7db45d50f6ee539f1b0696bb58d43" + } } }, "nbformat": 4, diff --git a/tutorials/applying_a_pipeline.ipynb b/tutorials/applying_a_pipeline.ipynb index e436c7327..c1080071d 100644 --- a/tutorials/applying_a_pipeline.ipynb +++ b/tutorials/applying_a_pipeline.ipynb @@ -19,25 +19,24 @@ "source": [ "## Loading pipeline from 🤗 hub\n", "\n", - "Pretrained pipelines are available on [🤗 Huggingface model hub](https://hf.co/models?other=pyannote-audio-pipeline) and can be listed by looking for the [`pyannote-audio-pipeline`](https://hf.co/models?other=pyannote-audio-pipeline) tag." + "A bunch of pretrained pipelines are available on [🤗 Huggingface model hub](https://hf.co/models?other=pyannote-audio-pipeline) and can be listed by looking for the [`pyannote-audio-pipeline`](https://hf.co/models?other=pyannote-audio-pipeline) tag." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['pyannote/speaker-diarization',\n", + "['pyannote/overlapped-speech-detection',\n", + " 'pyannote/speaker-diarization',\n", " 'pyannote/speaker-segmentation',\n", - " 'pyannote/voice-activity-detection',\n", - " 'pyannote/overlapped-speech-detection',\n", - " 'philschmid/pyannote-speaker-diarization-endpoint']" + " 'pyannote/voice-activity-detection']" ] }, - "execution_count": null, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -45,35 +44,36 @@ "source": [ "from huggingface_hub import HfApi\n", "available_pipelines = [p.modelId for p in HfApi().list_models(filter=\"pyannote-audio-pipeline\")]\n", - "available_pipelines" + "list(filter(lambda p: p.startswith(\"pyannote/\"), available_pipelines))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "To load the speaker diarization pipeline,\n", + "Official [pyannote.audio](https://github.com/pyannote/pyannote-audio) pipelines (i.e. those under the [`pyannote` organization](https://hf.co/pyannote) umbrella) are open-source, but gated. It means that you have to first accept users conditions on their respective Huggingface page to access the pretrained weights and hyper-parameters. Despite this initial process, those pipelines can perfectly be downloaded for later offline use: keep reading this tutorial until the end to learn how to do that.\n", "\n", - "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization).\n", - "* login using `notebook_login` below" + "For instance, to load the speaker diarization pipeline used in this tutorial, you have to visit [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization), accept the terms, visit [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation) (used internally by the speaker diarization pipeline), accept the terms, and log in using `notebook_login` below:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "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" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9466934e67254fe6a7ff67b727a3f3ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value='
" + "" ] }, - "execution_count": null, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -210,17 +217,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": null, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -245,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -271,32 +278,121 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": null, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "vad = Pipeline.from_pretrained(\"pyannote/voice-activity-detection\")\n", + "vad = Pipeline.from_pretrained(\"pyannote/voice-activity-detection\", use_auth_token=True)\n", "vad(audio_in_memory)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Offline use\n", + "\n", + "Gating models and pipelines allows [me](https://herve.niderb.fr) to know a bit more about `pyannote.audio` user base and eventually help me write grant proposals to make `pyannote.audio` even better. Please fill this form as precisely as possible. \n", + "\n", + "For instance, before gating `pyannote/speaker-diarization`, I had no idea that so many people were relying on it in production. Hint: sponsors are more than welcome! maintaining open source libraries is time consuming.\n", + "\n", + "That being said: this whole authentication process does not prevent you from using official `pyannote.audio` models and pipelines offline (i.e. without going through the authentication process in every `docker run ...` or whatever you are using in production).\n", + "\n", + "* Step 1: download `config.yaml` of [`pyannote/voice-activity-detection`](https://hf.co/pyannote/voice-activity-detection) pipeline\n", + "\n", + "![](assets/download-pipeline.png)\n", + "\n", + "* Step 2: download the `pytorch_model.bin` model\n", + "\n", + "![](assets/download-model.png)\n", + "\n", + "* Step 3: edit `config.yaml` to point to the local model\n", + "\n", + "```diff\n", + "pipeline:\n", + " name: pyannote.audio.pipelines.VoiceActivityDetection\n", + " params:\n", + "- segmentation: pyannote/segmentation@Interspeech2021\n", + "+ segmentation: pytorch_model.bin\n", + "\n", + "params:\n", + " min_duration_off: 0.09791355693027545\n", + " min_duration_on: 0.05537587440407595\n", + " offset: 0.4806866463041527\n", + " onset: 0.8104268538848918\n", + "```\n", + "\n", + "* Step 4: load the pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# look ma: no hands!\n", + "offline_vad = Pipeline.from_pretrained(\"config.yaml\")\n", + "offline_vad(audio_in_memory)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# just checking output is the same\n", + "assert (vad(audio_in_memory) == offline_vad(audio_in_memory))" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.9.13 ('pyannote-mps')", "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.9.13" + }, + "vscode": { + "interpreter": { + "hash": "36a3a48a52702f18671693adf589423ec3f7db45d50f6ee539f1b0696bb58d43" + } } }, "nbformat": 4, diff --git a/tutorials/assets/download-model.png b/tutorials/assets/download-model.png new file mode 100644 index 0000000000000000000000000000000000000000..4ca5350f537969f2f3ba1e6e7f6315acd8555474 GIT binary patch literal 482731 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 literal 0 HcmV?d00001 diff --git a/tutorials/assets/download-pipeline.png b/tutorials/assets/download-pipeline.png new file mode 100644 index 0000000000000000000000000000000000000000..9336b47b1da0e6ae7aa1556d713a9576cbbdfc9f GIT binary patch literal 385069 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

@PFGf$Kc!qw&USJCx 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

-iZ8a`7hl* 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%0Ab{GciL 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

3I&e=>Qw8H_lzUnU08RG;56zg%e@K zQfDSgVEPlhg<;+3ZZmk}Af=>^c1#{aS$r+9FxoIOR?G+mbSp z)cF5`#^)NC8hU3du3_<(voE9S^5SD0b*}H^Ct($99j(Tg%GJBGG!+aP_0!4tBtFD| zMBty^EgSGyG8bU4IlF8EF82f^> z1Mbr}wMkb7ZxvS@cM@im7NZC`Nz|Ezbe6n<#kJu>@B`mnAiP7$+Ar8cZr3saKq;RC z61dU!Og|Lmn!GYj?jX)k_&dSB2vSCPmyN|%dtTQ_k*=z7ugbbb_XDa5<>nRIs&*-6 zn7Tyh{fSJ9D9=Z$l;Rhf+g2WVf|>4}BPawW312=Ui^|9hKLgY$CE1umvRIvq~QN zZjn;WDz0bxFD*Mp|zQPlPU$lDiB)X|G_ zzB+0hjtIlYJL21}Q(1c;-y{cyA`xjwv>tXK=)>}a$meIrS15&(R)&?7WULWQK$mw`PNJQ9-b6sG7qNss=mJg{z^1pb z=@Dcv)vJuy!Y?M}7T&?OuE2Jf)Spl9qiG@&(7BJ2o3u0>;P^%&`F00oqCJ zr-Q|H`?iWdz|;YL&$`iM=hbV;;p>x0(FV8kYT22-RwY%gW-mSf--2qerr}dT zKUamL|NHY&0=5g)mg4@~^M)RPT7+}2kke6(`zBv*-I^ut`A*?ly}$+HFc=SHTs=p= zb4qk>+=)`!I4P2jr2*UuaV9vQu@~#1Jc(Z93^BUpyZ=xvvs-z}L^IE_)C$^oRDUtj zY15UF(Ee2@okDbf&gAr(`?NM$W*uef?2gn33zaDT*Zk##(`?^21>jk7oTX66s-z$t zZY(lSecUK^NfNtVyPqyWq(SN?z?;=KXf3m8L>|fh(_EG2Fw|%Mn;0(AL#q(G!mBu1H5P^H(zwm|uE2l}M(H~7wBF~O#eW@Ncg@9h*awRTZ*!&6*{17Hwb(rF ztDMo3xS{b-@|`|(Bd4x0X}iZ3)WfN4%2_AkWOAXaOq!nk3i(UB1Lom4{NHh$SjLd^ z{MurtP#}@S>-%~Fg^v%20~`j}UNx-IvK;v@*!(>0df(<XkI_ms9)de;BM5V@`Fj@tw2l`?0>;Gw4XegNxsp!a|buVQ5>3ltNylfNssMrx$z zvlp$Y%SMN%#BK$^%1)>nUoK1PJP))<3s1QE^|iZKk(%>IT-gWOe`f)ZVA4t4S2^hu zF4M(Gp8rVTxiQJoaFi2BO2b`aP)k~ff1lHYFAswVXk4r5`f7H2qj0mz6jaiE0W7~u zgEcFx?M%|qA?|$JF|XO)al9PhBpiL?zN*oz>rpOLPd@b0cSn5|OCmXkh%e)G&+lNv{{?T-roHX{*j?t3-G%FI zt+rAKwx@4&c78F>Z>qrz{S!qE^9kBU9NOO5F@QpK9e0}jVIouszBGJ;v;yA15`W2P z?cxSa_ps zTt#tJ*I2_-T`PAG03XizZ|xEd9G~uOr?-o^a>a7GyeCRX4}t(I_UYZn+KN`GgGo!P z6K2N&dWxFkRCN&2ZvRu;*&2u3tCVGJXU-2JPtRKWK&dm*47<%e#uV2LwX?f>L)U8j zQ%lMHp>C?Nx~r8dV7w{9#ey@nM!w%N>}WabxP5LRm%|1_^T};mY$&xfHWU}icu9%* zo=Gem24S(NbY;Pe_xAW~T4I_8l>4mQ-L^phtKbf3O1J5v;|Y&mn@ex)YLb`k?UL?| zq_X`sH9nEWF%ca3C;n#_N$3Ie`6@!R?XeTVY6#9no^~{X(MBh9-9@QAlo|}j-ihB* zUyi`kcHK)bIlH^qAk45H9h;TqrTGKj?yWZ4`~Fz(d>FUh1;;FhYZ$)0zPu+{`tzAg zDmYo{EqY|c=%!hP$Q+Z&Zdc4*4jc_dmGv-Yta(!PD+p=iWq`F~T3^Fi1Le{sblBkq z^qu<4kbRqa?sz#rXOI27xqvz1De)4M@~Te+vr*Q+_o46L4FkK5?5(;#XI{Y(XO{3o z2Tw(V5FlaPcejU7&VkXO%YKb0qvX5XJiQ5)@BLYeL|x(q zC`bY`p0H8%U-If96&&hv^q`z%IM1i_FeiC8; z(z^2B**?zkYgqL%R|dCymB&Q&-hc${?V1H2GtO8)JAC~*78hDl_{fLgdvdWepEgJ3 zU6G7ZnpCOCK`?S^4iDwYfPzZCUhTdJ$fSvgMw~sTu2H;+5Gql^)6k*xVV5NHI7)|B zX)7Q^I3SupxNqpG;3uu0I{CrS{RS6;QaK-5oE{zT zC(zzJafLIMKG2=D8Ir4P{x!Fc4xLaDXqlmH$F<@;)9 z6^@RHijO@Nf=hKmuw>U?X(E+jbB;EYQNn4!Fz5aF#~oh6yc9>6O!zDX6k%!&o1HP$ zQjIb{*spMNx-R=&fDOAF8`vn{hH}NNt#v5TGbL^_0^(BG>l4xecg%_5H}_Y^W?@d4 zwn<1Yy<*v3NvYCm^QxCB~PLiIXk7^pf~=Lut)@J&qeDM zVt@w9E4n_@6SrZvW+N7}8vgig#xeKA`DX~us&=^x);v)p=HXlgmtO%vXszR=`F%9` zj3M1Gca!ZHp2n+{7u?9T8;(!3c1p0lkxdPo6{U`IN zTSLHeIUd6wA8(Cx&bZ%8K5;*;o+GZ2PuyBSwrU9?hIEe z2P7g(?hu5ym(aUdY33|K_}5uhOU*UXJjup8ucu>AJay_pM6J-Z-*(I{o9bKu?|u2n zoPua!Rw=K($C+$sxq|fulh0zX9NjkKgtc4{=qJ{I4jEK@QLyk8^{loY0QAz!WOkW! z*J!_voWH1MudOiO8pi~%mSTBLdfh#N`apRatxt7Vj=T13XCw4b|DufE!S@mUvPSS| z++5SY@FA5U3wt_OpV@ZrHsp5L_1^>xv9Qr5Z;V_}x28{|2C<=@o!oMg=c2YfoKsFb z6*X#$-Gz!IfmY_kL)!7&W{vfisTleiAv?SkJn6=S@TIV^qN99bbm3$4xjwxBoS8*8 z_}3jW)by+0+e>Cb7RyCkX!yjVeo)ui zhm-sqatoVn-OnO~e%TPQ1Yoa>v4P8RM)^WV=PYCgM{fxZ;PJHUMPwbS^tz!Ey=T+! zgKKuXDX~~>lJj~w(HXU$#V?{Cv3F z^Yzqfvf&5k5}|>UO*^(Nq9_)ygCRIuiAO4AH4bb~MO;F`$l9ZV>uL3%;Z!z1&NemO z*|y&!7`9Fv3jeXm`@HoD?E_8BxunjcyrPL|7Be*OaQ6BI?PiFH zHH~@Qpm|o_&%u#+3QF32ZA50gE~;-+_((YgllJVwW+mhvxBmW>+A+`Rc&>*XfIS0z z`pCd92FO3Ncd)#x5u}J5j!kO&6PKJDG1San{4gga?sG%K74O|{fIPo>Jop}u*u(s} zDWzu@4xq_S@5B>$RWe;Q1iKEbpdgdRo2+ujI=n*7@iB<*8MOH{Eb5f`>Ye~aI&}+7 zCq4o0hlRf!s2Z{I z4X&(Xp8x^BlIz5)+NK}Qp-5->try`TxirE}t$Vqk#YHx^){N)~*&H<6hwBaf-RF#X z9D_3IM8`PwCEJ5Y%1Sp5oP`Xl+XQ<~Y)T^b;Lsx`Al!){bQ3;f)+0*{_yvE@Y2f?V z$sW8(r0)BLvP@rN^f_BFc8o0{&HiEH}k@NQPZ6cR&ug7JT45W$GRSWoIX1vnXOJXQII^05;TZdq` zuztoq&AX-|tvNdo<|H`s`(&5j7^#B1l88~eL#k|$+w~-}ef&a2{fkR)uT13Sdjnwq z%?UHyfkOL%%axHCJ6dN5$}#<3wqwMZf*#xJ=5GqgD8flb4c$=liDx8`2Ww}qC}GPi zyhhgH5`&yh{D$_VGI%Oft)6vMRt%1nUNWDfb zq!nCwgftE>7;nsI803bX)O~uzDn-4|WLzwE=Im+b1r2ep&)c=SnGJTms~g1awTAX? z>fFlAESL;i;fNr}?)+5Q-Rj=v6H*#qpb~#H9`$ooaA)2f^sJ`e5hJx8>4uc{Vk_~t z2HldlN+3W7E8PqMYV$t zx8WIfwI0rI=6;JG8}JoL-_lYG#cZw4GOr!T9?|y8It_%=tlL-BJ*~fJwN!GUBbqy! z{IwS5vW2BjjgPmR{e^`!@D{GFU1r+eUku(xv0AV{T{JS&PPm@_Xh-_W&OXE1s`jP) zj>i_pCIUy}~o&Azlv4k4&v>$-x`f*-?BI0l2RxJAo^_N&aP2v|` zp2#yKVwYqyb6B9OIWz@F-qiBK^1eM;z_7Vb<^TrQbF3D*h04olQ#w`TE(-kdudpO#jrE@MlSxZlYoM(KNztr-3 zP-mx1tuKOIXJeWadVf1C+H3{J$#VXzEgDbg3bwU7+T@2PP>fHW8;Y?p?Ta;F?j#THB4k?)!BfG_@}x#-6#?>z1Gj zSnHPan((JdtoF$8cg5mkQyx*ZQBaeudy<$drLhx&UqWog8u+i1OLAf!ho;f=!;Ygd zN$@I>VIe2L8ENC7uG1IKZgXL0Rs^_qt3(j9oNk@i6hNat^iOo<~XDx!ff$fdu8 zOj*}>_lkO=UVF!EeOu?h{vFwhg_2X0lkToLxknK9RUaFA+`0H*L5Ritk!-n`U|pVD z_RGhE4;i6AwSf=@rw&GuV_YHn}O+h+u& z{Q_bwmb2nzGJYRwNwk&PVQyo|+=DZ{U_R(by3jh&o)Ges(|6~l%djsw@Os(Ln2xm2 z{5VkC@?!P&?OJ=RrVio(xwN<%gnlZx5H5BFilCX^j_ zk@pvPpv#~7+$#dgX1I-O=RRU6o$mYSgQW!zNO%<&Lk*ksXip8Jzy@6X&R{qn-a5)0 zS!gKTGarGWD9exgg&4zqr`E^2ph(qOJlq9?sx!*tp?BWp^?G|yc_?K+U^;kNj~ba? zx3SlIC2v^Y`504IJ~kd@=NP|U2a0G}dR+*$(-(8EcRAJ4A>{jRrX(i63rGxkxE?BR zvh9-G`@@-hgpT@+CG-pEV(MNc#N(fMK3f#UM}2scd8ozm^Z>S<@=~_dtDS$Hwf24j zT)sYCjA~f-BXRC=%eWNx5%!e#{>gwGjqisF5B zsXJ9=e0X@ceA;+h2U+2mx3*h>dC92E`1;^$&B+@~GCHj&Yh9S}FF0T3ihzK35A(7SVlJp$*ba+6zB4KxK z^`jw?+WO1pqsQ zxwA957gwu-0>_<|l0j3Rqf+#?MZn-dB!gBt^V06NX-+>goXHq~u)JWjXd9bx7*x1Ej-x0i)t zEQG<#b6rS>b3UQ)A9Eo83S{!$S}2R|RqPt!_5*CN&}5E1;p+GfR{rbA{1Jq;W(pIW z!X`FC&u9P48cw3qmoBs=ny~$b5)c7cF7-k|=}*sf+z$v^CcH(T3@j}QqvWxV;uAuO zG6s$GaK6h-Xu?pazDa8kjoW%)7lw7Oo1cndmTH&hLkQ+)20`a9eeyy>CNSU={su+1 ziS9afxFxd;5-R+Hxz$S~;Mes%CZ`r&Ti7BKRH2t&J)5HmS7eh8@}GTpw5UQPphQ!f zZIx39J>`3@TOw?8%Z{5p|9+i_IDHL{_uO{7zAhZJYujm@Ed)1zSGqh3ogtzGniV99Uwsu2oxw>hS&U)uB)ybOdX8%{OH1!0hi+ol@*rfH|EDcZg z_z3wIWzW-v1kXF#3O9#{#3*MFnKWlF`Wvc|%!g=Wi6>p%4!!m}Yu+pIwj5%%yrHrtF5aoxP;*G; z?cua!+JUb2g`*(~2b%h$E~evdnv}ro5bMPV4d>yab2SQ+!A8VstJmk1r-~uO+gsJE zS>_MZc<8S)v1q{?HPKvj3JwO4aLX^XSubPopcgOzF0bu&RFEtRRT=+>!Ud<=^2XHE z)Fhi)b-p+)H`^Bxatu2`_n;@u4CYnYn;ZpX4GxT&K_ z;BtC&xjLFFXlPLW_H8?;E2QyL?du@#YxR!prG3^@dhG|u1#8a}@L44W2swSVwYB5= zt6zl@v~$RX0*5Uo(%B&^Q#PLWS>HnnRr*~0k!Vr+v-^iwcRUobiihpRqB{FY*4X>O zMx7znd%wNXj9gcUDHn=+58^uyp~-R)%ksX|sqIN^y?|XEDHV<>+FzzHMI4&uv`*?+ zKFu5IOC}A;b4p0o)3YWFEK4nB?fp}&qWP>z-_a2#Nd;SR-|OvZ(cwvVC&O>QohB8$ zjvtWKc^4TfDT(I~&@6<_%}X54$%TZcetG5Z?JL^Q5HU2(QV0%{M?A7P*ztIT7D$?q zY^o5!xwDFUO*r_uIc7RzqulN_UyA7w^%H$pLiZ8TZjC$2TyPPLkWtv8{oL~g%heX- z0meZk(N)YOR{kiK<-`|}T2J%6$`Oo@9?!{grmX%AP8&!2e!3qsqo$hN!GsoNokGRy zx=4xfq=Ucv8L>qarE;iqI8YvEQo*#1>#UssvHjj}>GJd;EOH4VVs&RA{By9KhIv|J zGxvG@!Yrf^>Am3n45RU+Ih1Pxsgt0|Wwp9!a9nuz&b!yxW#ifF!=z)PNC)uw6tg=` zL{dKNzO84BbbKY*O#2X~vFQFpTVp&lhP&S{)tOoA9Pji%+Qbpo6)>9lNDv?U}y z+^iysxkvlsyO~Ejo}axm7!eRJNNd?vvU}d9&ncQOsasn6F2O-|d3lbeKgqQC9`UTG zJrq0jbrF^EmSw8j;vXD&BIIOlbtA9FVYj`uKM#bOz~+Fe_Rp@XM}1sO6WreUETR}V ziLsPPUO)T1V~K&oxZ778f99F~+NcA&`s+RP8!~LJASM*g_pH$RMQgT&4sbuyWv#ay z`w+>hygF)wv}uXCHEV0R#f@?>i^TyATErO@^3<@mmME%l8Q{9qoweS+A7(smzt7(R z)ixDRp->cEopw75<(e;P&~Y)&h+m9v5R9@Jr<5rap0hWaH;v!2Xg=Nh6>Vp@BYohq z?#?4WZ$%#8RvigKka)mH*VY0pW+o0F*tB%kJIppx!X`@pMUCCSQ@7YAdRZgRns91d zV{6O`P#Y6MXTet3IMxHcVu7Bmb6i>Y;+i#hS=1r+l z*v1YJW5ilP#%I!>^fMTN1E}HgllfW;xFlXg_gjtu(Io2zoQ}uwr|azicu6fq#a#~~ znJgYHkx0CwRigHz9U2wW!SzHMja{&15|W;>hbSC}S>lKCM#nJj&UOM|eo?2xV;QBq zLZ@^6_c7MZ{XIDCh%FPfdYr)X9R((xwu67TcK3#5;~Ir^=S#zhO`|1XA5P79Je9n< zO|u16N8{bwA1N6tjZOy_xm^D6uSWr{R_6)vlKk5g2~(Y;Mzkq*vLgdAG)qyC|%D|~?91k_~PyRCjGL|2p5|FlJ5 zb#)!DPn3#fxEHCub(Fb5KqGO*i+PO4CuI2rOC3r_?^hjoOKqwc^~Ndrxn{5p*BlDX zSWI`%8k0Nkdw{Omu){Mrv`V#MrlzeBdg2#8TuWi6v!J&aW}objl)?=J$6oPrITB&aLW(0)13mLFHoEeYPOCB~|V$91&IZb|P}eV7T~Vtwyp z@(sq?)p#E5TUopJ)9<+;(|??(e_e1yzJoT_a6Yw#@zAS6OGoDyg4tTRug+Ux8mife z%sq1#n9C^#DCOA}40o$|wjX21L-;5EMp&_MN1UO8@RM`8;LP`vp<_E3HNl~f#>$I{ zeau%;g^};YeOR`ahH{X@>@=g#eoJL>%q8_2>!QW8-M!U%V!E6xpn%A0piC%^G}yl$ zrs0yLSRt%<0Bc%i_t-tdMf$$Y)RZ_*rP1t%`;*ES#Y7?FzweQ+)can-{e7Yp9|||> z=$Ev=OOOe6YRXKkezVoceLO6h+vsWVUPTFGzW%|=a!{#f@G#N$-T>^A?XkXqSW^gN zierC&+*F%maj}&e1ZpI+Sf*YjflpkC#<0MoR^5Dd6!E0TX;E%h*B4?#_%xNe;)YHE zi-+=)%~$Rtzt#rcH<{8?rV&OaQR8&_^SFQZ{*9>M6DF2RQE~8Fa))NvSvk6-c}d9R zZL0%@W|9^^qq5lT=lV-VN}SW&iQgWEwBN)#rR*SG;}hl7Qj+HquL@EkN!knsCX+}i zvdI_tjxiHT3chv6GU}xcWajfVjHZhz=L69AicL6~JX74x@`h>vSqn0}?--*A(fKJw zzvZ-Yw$EUf@%7IeU5uINNGTZ}DMBFXGW}Zy{TIILqb>e!BE)Dsd4?)#jmM-;(xC`A zZo=5L({VK<`9)7;m5o_(L?+-R-Pl13;|a!$~gLC`zl`GUESiosuZx7AE3B^k7CJ#y*bQ_qCi(m z?fZyH>ku$pQC8+q(aD$nTW~I4(%9`DsP_Oyz;VVIY&Q8^!C+0^X!?-{)-bjPzONy3af$N( zWR{F^HBxNgAM#{ENW_6wmJRLj}?`!NiTUXkh-eP|I5KeHMadGIJ zYrheNKU@1|_h6<^@WRaD|AAWY_=RCAidYl1cUu`%ETd}$@$sqFf`Ze58YkTn5yF3^ zqMA$6kVMMO{CGOW)sA_tiN3D77s}?_R>5TPV9XUJZCY9EcrdLTM*829p?_oTV1MbM zD|BQQ8!q=3wvUp+h9L-3_1#nj_(*t>Z6^4lzXT-1m^BAT%AEbQ{o%f*i~9|Z{fgW! zxZ#3?gX#bugLCMEh{N=SBgpZ*N>d=Cn z6U6wQ+bL_BI5#&hS?*Tn?`{OJ!T*f0Yo-d?hcR>KJorcM@JI0w*kyva2$u7_MJ}tE z-{tB{Mtmjlu@w}yyHs>&*2r&>K~~oEMU?p+^U*lpYYjGXh|YN10fd=Qe8^D$BeT35 zm&xksruo1$UlSy%544(#^#d6`~hB=IN(=RE~fc5-i#_`C&Cz28&-OTf!HfXa9W8~J}3^S^ApL_X&N zU6D2VqHWU3-eBcc&j?EIa$!Qa21TQS3AUe6WMpzbVFa{1@egI?{Y#05Rr|?d=guds z?nfaQpFM*p?tO_FjLEoe-5*}JwOPZAlU!&tXnJFv*9COKN$j)raGO4A#d`Ud^8iav z!Mq)umCBP3ir3@rKNdMu$`Jo1%A)xuDWfY%aM9MfD*d#PW8Oi5z&_yl`cK*$gta2! zaZ}F)vCLkn_hFI+=Ls9)E&z-WJa&>8o7rEPL(Pn+JPkTMy@O)C6A`FbT$*+RGUqFU z3uxw;@^rT=So@6{lgYMN?xp{^MNw z;}H8>l-)@F3wgJY7jhPSqAeMsI8w}BEnUYRPH}PqdUQ9`lcNUGTJ^Rfn$uwI0EhEe zNFY~}#WI5{sK4-sA2<^$u0S$rgwFdxQmsnY$7TM2_)OLPW?p5F@O6vO5YS*bZGg>U zk?ipV*odSpVz|1>dRzT!4&3anal0{Nx83%q!ae>WFTbrm7*HYlP8(^eI*J$P-?s+7 zLB0dz`_o=$$B9VBs>M_KI5LOh;`S&wJ1#$8^05ZOBx%y-BiL zP1{YOYe=l^Uv9g9hVx$+4(^ZzAnQgiaF~*zGtsRP-=?V`S93j}K2g2Pf`HeFFfhK)%C@Y#NX!%hZ%x_CI;toO>73kU_M>f z>qEI^@M&8g`N@P5FFM~k+!&!O*D%~CBT*E_uJK*SpKoptdE()F)&1MrpmS8{^=UiTRbZhDmx8Nym&j7 z>3oGO2Z}Re>WslHSE!-{uAqf@ALagoJ(>AAO)R6S$k>_YvMV%2I3dl=&EiCwtl`k+ zYlcb+LDRt>Z8aKY+PN0oQ3gB}A%oaJL`5)0LRuP)=Tp3#E;e}&HtGjx!&e2TOmh3wo2k_UQk9SnCus0o;Chr_=DQ z=ffr0clVfGny2_(sbmVDj&I0$jeTG8Zqt8nbZ8$d9i}py`R+<(eyzXg_;TZY{|UW! z09pO`_hkZx*e!mP*cMb)QW?J>pw^5!?cY7je;I}UtgqQn@Oa>uTOP1I-hVd!j96gQ zF>Y`;Jw<`DssX>V^iOjpIvUxD(KJXP@lLOYPN#z!9CMfc3=ZmRrJ`=Si{3iA1oPFg zli(`JV81VQu^*pkd*#14Qm)a+vCeRHd1<)XWP1s25k{tRPW>g}Nznd-68xFDtdz)d zlMj)mSjR&NlBn!%QpYN7Wb9!VpLNuD7pH}B9MgXam-{F<1Qf zfX}ACby@{_4rC;BC!}+Gqsbkve+ilC2UAPGFEJzcaL5Y8;g!uP(Chj7Ukb&4pMZZJ z#XCr#*h5OtdHnoI!_ct8LB1Ry98FEzDpF(tn@AF4EgPcTA)lvQ0q%#%^4F#2*-VM- zvNEZT=RG=3ZzUxqyZte2cF)JU+no3KNu4iGcbLx!NlA^^5dH~&pcjB9(#OBoqkm7e z!w%@41eNp=;|Lr&pAbf}I=uw{hO(G}XOfV)#eS};q2(}C<*lsU-Kn&nQUWPD%T3-z zOckywBaW>@tw;vkKcSjzbl|)-;JDWQKs*BF!|>vD*UJ+-Au{>1^d!@IY#ZS9V=Qw=X`qxg>+V zWNlJ2|9NTtdXuub;qD=&vu@y^2wZ_5Gr!RbNthrl{%P0b_qj_5QcN84_I^zugZe{%g;H3+-40I_-t^%?$kEMLFM*!P zLtceyD^zlu?xb`!47H*no=>gwwnD9vhF4RgTz@3nt&%z(2woz2yngh@IUd{A<%Wod z7jMOsaKxaAl5;u43;A|yk4D1E{LOyZ_Nt+90(B8h}!VpL%Rm`(o=vZl0bd(Lk#&W4q5a-Ss^LJS^Fr@Z) zSzb61S=CKAaYbNsKM# zb%3TLlPQ)M_$jK-&UjgI512_K&+F23|KS6<`h!H2$z>M>r!Y{LzYC?T_wzRGoKdt+MUPPd-_xkmi|$Hw7L7zXDX zUKPy$GP2PqkX|zwa*pUBUhtn?oB& z1pM`_p=QDVud=I-igN4vfHYD=gERv;q=a-gqjboSDo9Cp3lb92q0-$opmc+XC?y~b zLo+ne`OSUTdVRgf^{$UUW}S!goSA*j*?a$fXP>&^#ZRKhfrWUtS;?*{?uFv$nkU8l zAOQ$Dwe5Z&#|mNcJ_tkYzmxPT4B7H6JptBzVfyixEK$nGh!xH0I?W019dPi|MH$)_ zLYRuZb4>B6NCc<_es7X%|8W-e$0LHAUWl)(GQ=o$(*lnaZ_vf27m}mVuvjtGCI&nz z_SlVZV~Ku7ZBXs=g6{n)(d#01|BEAMbMQer`pVUvaARE>`0}4Gq|DA%7po~6n*VL2 z`_nXe5Kvom%Lha8GHViel*tw9*IALX6oS7IA54un5eTu0iZdlwp*N>f1B_H@+EMlp zL0k2qEGkK@ofL&;w}WKcp9?7Al4|}9X@8p7e-rzBDDwIi)xm~q$57!S9)HAr7j4mj z)!*pY*ap-amVAGT^S?xfE+OVVHLHgJXTsbT2SD6WnrV(G{Zel3;oyS$Jx53rXY;w= zJT0G=x13oP?FM|@G2(a+2dFlxTQ^wsM3_vq7GA`tgPSJEj%z)mnFj>ayX$lW(^?;L zQ-T#jorY^jT06md@Qz8S zMvSSh$_`+x^UcGFWghS^im~sFGCYR(!S8_tI{!2T zZp5+ZEtC;mjow4i7|)A|##CjpZ5_m}Lxd6K5FjkOxj6*Zf&qq9vo4O{#CBH0>?wr2^w5$(j$+1yRje&xY*pPVgs-0d8!Qj#W1+rpL79-YxSjc* zHkSqmf^NN-sP|kcuPw+Zt~BxapQ8Wd${FSaJ14;6E0dlE*fSRI_XPwM4oA#bMFT_D zG4=9)g_7D*seq0fZ;r{L$oxWs>+*7C=>XWu9ciT+KUS_rD(1|AwR5ft8Q6I-ye#vH zuyx&%tWgcD2WddPCB}ukg@5(2xTqOy5wZ-iNy%&jl&<{i+?hbUMmmY_gnFaH!%FIp zn^D#RWa}p=p4=#Y0xA?e0X*93l?$7*wLD&R2_5!m)XSPulWjlaGZ1_r@vZ9PLlR@x z55tW|(8ULDfkH%O))OE7o&qdHJtg7a{pett3R(r8k0=pD$!<;!D}8t=?A@|x9@ZiR z)y){OW135MJ1Lu4F=MuM**WD;^zAPOXC#k=0=B?@JV5R$x2~3H7U^02rKcw`I9R^0 zsEhJLc!KWOd7eF#pR*rjooCHnBnDimBExp;M)0ERC*fk zb)nE<3)YQ$L|sVJ2#@>*_5% zFC#w9!D4g$nm5YGP`V14u5PfsUxCjbj}D3BvEt-ZCP(1M3buDGjBIEaiCyp>0J`Ao zHu5w+VW{*J*>8q`7-^uO5d1ia3(P+xA%4ZhW!&D4Z?(F^)1&8Detd?TIFS1TQ12~8 z65ycquIYtwqf7)URSNgI9_6J7w`5DT8Z9ekq++6; z?vq^&3{no&KkyFfq8vJf%5rMg9g^0$59;A*>w*`KEn`KtNwM}R=w62$3C(aj+0`nc z0DTNRJkL->gW93-x~s?Zp{-yucCn(ea05$h#;tTdDM#D7ej)tvY!;=AYQ!a|pB8=| z$oG?8{F+$pLd~F;U9}Iq9rB@~7!rcRF;bX|xX-;%ptoXJ;J#wl2*|vy80AURO*TA9 zgoy@Rsi$HZ@T&;Mz*k)O@E&l!SXyw5-%VE7MCy`Nrh#BfQk}HXjdHy}casoQH=9^R znWn`rZ&=2aM4!5P>D;A}WEvws&={{ZO9*r=i3&y&kUQS1>XdNJ3N|T^-GOC;oHyC( zYJ8OUmbt#!!|Ebe)Z!8~Z{S6LtCbCE26bRCw}{B(Ac3_0n09GLP$Cjc^C~U33(axu zv$nrE`1p*SgL9)O;t|&kU$(l8>K)7LP=Bn=N>QfSA12-s=vwT)_jxd}J9mbxBfn3n zgQ{O~byXZIU6egWvpcuBNZMNtNDMJzBo+39NW&?Hb=7hhMyx^&nu_L?(q$==4Irms zjzH_n(paw_(;6+dLG?{vVyBj(6t|{;fK?GSnOExt24eWvW*&Yuk^iJuU!#IR#nhV_ zgMcR!38k8WiAb?=aU5p3U5;zeFb-?@9WH_$XQdk*#wT`U1o*yL4&6b71P~E9nGoYw zEkuF!;!f%T=Ch%BSm_c#1T6y^c*uEspw0Jwc12f_C)$Tn1me26Yw3oyHkj#1HocG* zq|gx81Jv%4-gRH>1z-hr8XGYCPtqhdcDeC|VCR2=CK=unHMpT!f9WF`q%?L|1|faN zS$u*ZM7pZ9SVd&SMLO-H*7jsRDjo-kL8?K$v$jl_F^=}Ac4(#1O~m6hR%^D|@i5`R zGriPvRxSIr-ox;6Ze4F=>f*wHc11z<*9u4Aj?2_Yg>FS3n>|O*N7&r^#Voz88Hgp+ z@CLRfxo?qKc%LE zFmFp)wf=aX8Ap#O0Ep zCc&Q&3FRwDlDFC4Svmz)+mveQYQORu;KtgVg|5 zbIRaw>c?hgE~SSsK4H)(D7C+*Z&YwYPx$N5<+~S`mSa#`^m-~oq7u+=0EPe&f>i-E z>_jm-my@7*T0z+k6Ed*6g z64pPq1Y(6m!i(AMZ##2!kz`;Cl!hw1E>2)I9}Bu9eQhT#YAFFkdTF8nTerZd11`^Z zM`hsbDfWE)O_35hPGsZ9l~uS#WQ@5Nvgh?<#C6$bY1T&U*;M-rVi~XwpVLy#*N=Bc zM#B7#&_lJ16F#*!bP7BROAJA2@Xy?(AES%;2C5iVgF)@WO-nuW&yx-wVLNI+D(ZG| zPm&EgQ_R^m!P=MxiIc<&=Y^0{3dk`8<;Lb3Ny!O)TFYk0W)5XM)cpl2L=`DZx#bXt4&rj3;gR(|e9D%ytlH99DKpnl>J{e?E&I^FO(XqOAW0Dd z@&SdSm1%awMxC^}H{KZJX9c(D>16}Cza_0Fl?0%K8VCZLO_~-}(wN81 za&d%)=D~ia)iBoY`CxusCav$R{+jtfw<)x{DPp>g@(&gJV(;F-YJRCFBDY@Dzcp&4 z-kU>D>L%~#f5@1@_~0T)4p3AUzq9KDpT5T=jvKPcHf%qZg`y;z!2MZT6NlYce}z^| z*>TJBfwvI+qEfjl39SntoNGjVOAjFGr2!ZBm{fW<;#YC(Y-p~(Gj+F6|0pvMRId0) z=0(W+zROr~Kv~JaU>e#y+d2!(shi31y>d|I_eMu_Z5KUlwiq@~Zz=o;Fd38MWl7b{ z_i`;qJ1@n(XPm^wIxDo+=2gp=H`?6)DxbkZU=r@9Di|($)3C{c(Z8gvgXyYIVI=5j zVxTHbVr%U>BE-f@|K@g?uR^ancDoyOqt1T5CPKQ=i!n}6KY(9BnI*X z07Kj~_Q%caxOFkq_Ob;r@?eX?5W+&;$5uv?D4NVlhhLABXBzcKdd<_~5L=ah>exRd zoc&OUA+A?WpBR53A^+`C{|`in(WvZc4jfh~4MoS(-Zg0+-X5dN6ib!^U~({a zt12$^EVl!oNJw}+O0rT~D@<8Nw1mncwVE=~)~s8vuqiw8BVQHdgI{sNqbpN;d>V2)x+JIuy!9FkG;ilaEFF-qatQtx zb4Bd1A<7tlo~6ssAm8B9Od}){!wAs)tfUTP$17lrShS<|^H}WjfkU=?d*p-M3o&A6 zOpYckik2~90ICrg(^S+DyO_CQp~$%*XpL*ap=j_>`aq{uKMib zJAST5QvkrNPy--??x0p{Mi*#ot;>>nb9l6nH?@-YJ#Xse=vCq71O0s7(k6}kQb_ff zj#lfF2uGr5>lcy$!J6sKDlg2OcyjaOjCtKs+FI|^mC!I8!Y4r?4{XvFK z=jECaygHC0MsN14&ne7HGKfKt8l`Dt zFP*No1l}|l0WvCqB+|_v!g4P%%<`v{%5GiD_jkn++3Agr(zcX-qx>e7>x8_#-5omXHyOXg!S-vi;J&z|6F5&RYBx{L~1v19o_YpCKw66CYK|we`K4va07-!%}(W2CUdY@ zC(XvyszVPy+i6eDsbx>Hu8+^^`<3l~QCcfpA?B$2hWt@+x3Z(i4snoNL;l{*6E#Pt z++>cbn1yc-6Axli!@Bzgqdg?Q`ZeZQtV&@Bp6$_@d!Nes8rV0OKE3j?+VC{&sqKjK zZGz*X*^WPu*b|DpdQfk#4g-boh6u1x{5UXc`x2$Uloe3t^~>-jaD1jN`yf);P@NMucv`<3kP*9LH6&^9zs zL!4hZ78Q+-?X0J>Q9ETX9VR7gOlE%^N>Emz)%BcvArn6X=W5Y#|4tdgk))(8ppe*$ z$D8J4Z8}2L5X)mdx<9M;((FTQs6&^+AseJ#I`dY-_{sz5hh8x|#V#nw_%s+h9R1?* z9USiov)7Setx$HtH{{;xn9cR+X>UEhH8h|C9;+CC+P2?8c}DklgTm^M8LAIKt83b| z4ppC{#54C!ABHXC8C;NF%Kw92BNW~r4}hsrj#p2^iFQr5kx?hu2b>3>r>E&8v=?fy z^Db-#3@S0-hLh#{UE7h>(C7;>Y_i$4$|;&|pL5xDqWwP0AR?ABK7FGf*+M(yTB5NH zEfTaOX=v`RUFD=;?dT$P?$hnZA=GxQp{na<|7w%|5 zlCUr{+lf0`+!X`(s9|o6o);OpFWfrL#LW-2G6wIfiNc5xx)Dh+W+#~lrBXaLs=pDvi#QnRB z+{LJvkiMeHuU*%he?Z*7WC^Y@C3xj-3yr>a5cc0>jD~ojYFl&BBs-jY3B)sYlE`}U=K=1dCuI}`D zout6t(UWXV7c5^Ac3~)Jd#>I?!!vxwwu3mp5tb!NSH!45Y%`WqX6Iv^OL8O_{g&Sa z`Ul~V{1YXkJ^lUv-pGHoezjbyF)v?tWO4Hf2fw`AU7^#=fHK?Mk?^ot51F;Mp&wF~ z>yu5TdP#aoI4Sqd1q<4DNJ;Kwm0WJI*iPR0`Z5u|tvPpZ)jwH~&G@RUp4O+4q_J^p zx$&Au_}k;NI0Qb7JJ;0dTt`E3et)f=#lZP*EPI4gJ;OPiwmwF$ZCZ2(B#dE0B+64f zZ)pz6w@VIq^poCkz2uHQ^@K#FCTmSJ9$pdRV%z4XNJMWZrHJP3S1W{J_E5TF0cgaSzfgT z+KxQna<6tT+}NGxCxQMDzYyzs%CeVX#^)v(Ba<#wIXn?E`>UkajjEL&VM|80fbwYIoqA%9+K#VDD_ZsgQ105PHbsF)%%SP)IxgM!d%DN5 z!%7c7+izZ+VD7ZSJ|A}y^1IpU?zN?frcl^Sl?e5pO9tikjtFuWowm5L9?Za6+Z!u+ zSV>9x*0dMZVeHrY`&WtP Date: Fri, 2 Dec 2022 14:55:36 +0100 Subject: [PATCH 017/112] feat: add pipeline adaptation tutorial --- tutorials/adapting_pretrained_pipeline.ipynb | 744 +++++++++++++++++++ 1 file changed, 744 insertions(+) create mode 100644 tutorials/adapting_pretrained_pipeline.ipynb diff --git a/tutorials/adapting_pretrained_pipeline.ipynb b/tutorials/adapting_pretrained_pipeline.ipynb new file mode 100644 index 000000000..325d939a9 --- /dev/null +++ b/tutorials/adapting_pretrained_pipeline.ipynb @@ -0,0 +1,744 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true, + "authorship_tag": "ABX9TyMc87txSanOjHXPQP0Zpu9J", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "gpuClass": "standard" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Adapting pyannote.audio 2.1 pretrained speaker diarization pipeline to your own data\n", + "\n", + "> \"How I reached 1st place at Ego4D 2022, 1st place at Albayzin 2022, and 6th place at VoxSRC 2022 speaker diarization challenges\"\n", + "\n", + "[pyannote.audio](https://github.com/pyannote/pyannote-audio) is an open-source toolkit written in Python for speaker diarization. \n", + "\n", + "Version 2.1 introduces a major overhaul of the default speaker diarization pipeline, made of three main stages: speaker segmentation applied to a short sliding window, neural speaker embedding of each (local) speakers, and (global) agglomerative clustering.\n", + "\n", + "Despite its decent out-of-the-box performance, the default pipeline may suffer from the domain mismatch problem (common to most machine learning models) and not perform well on your own data. This tutorial will guide you through two recipes to adapt it to your own data and (hopefully) get better performance. Depending on the number and duration of labeled conversations, you may either focus on optimizing hyper-parameters or additionally fine-tune the internal speaker segmentation model." + ], + "metadata": { + "id": "npzkG4poB2BH" + } + }, + { + "cell_type": "markdown", + "source": [ + "⚠ Make sure that you switch to a GPU runtime (Runtime > Change runtime type). \n", + "If you don't, everything will be extremely slow." + ], + "metadata": { + "id": "pnaQ4JSLF8Ms" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Installation\n", + "\n", + "Let's start by installing `pyannote.audio` 2.1.1 (and `rich` for pretty progress bars)." + ], + "metadata": { + "id": "CZjbjOBBDrdm" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_kYxY82Jzz3s" + }, + "outputs": [], + "source": [ + "!pip install -qq pyannote.audio==2.1.1\n", + "!pip install -qq rich" + ] + }, + { + "cell_type": "markdown", + "source": [ + "⚠ Restart the runtime (Runtime > Restart runtime). \n", + "If you don't, `pyannote.database` will throw an error below." + ], + "metadata": { + "id": "ndQ10VIf2W1c" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Data preparation\n", + "\n", + "First things first: we need data... Annotated data! Ideally, lots of annotated data! \n", + "\n", + "For the purpose of this tutorial, we will rely on the AMI-SDM (single distance microphone) corpus. \n" + ], + "metadata": { + "id": "lz-b8j6RD7H6" + } + }, + { + "cell_type": "code", + "source": [ + "# download AMI-SDM mini corpus\n", + "%cd /content/\n", + "!git clone https://github.com/pyannote/AMI-diarization-setup\n", + "%cd /content/AMI-diarization-setup/pyannote/\n", + "!bash download_ami_sdm_mini.sh" + ], + "metadata": { + "id": "uSQVKFDC0cOe" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!PYANNOTE_DATABASE_CONFIG=\"/content/AMI-diarization-setup/pyannote/database.yml\" pyannote-database info AMI-SDM.SpeakerDiarization.mini" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wTKkOeMr2QUL", + "outputId": "d9cc39fd-4cc2-44fe-a922-533370221d31" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92m\u001b[1m\u001b[4mtrain\u001b[0m\n", + " 28 files\n", + " 8h46m annotated\n", + " 6h11m of speech (71%)\n", + " 112 speakers\n", + "\u001b[92m\u001b[1m\u001b[4mdevelopment\u001b[0m\n", + " 3 files\n", + " 0h56m annotated\n", + " 0h40m of speech (72%)\n", + " 12 speakers\n", + "\u001b[92m\u001b[1m\u001b[4mtest\u001b[0m\n", + " 3 files\n", + " 0h56m annotated\n", + " 0h39m of speech (70%)\n", + " 12 speakers\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Note that we use a \"mini\" version of AMI-SDM so that the tutorial can be run in half an hour but the full version is also available for you to get better results. \n", + "\n", + "If you want to try it, replace `download_ami_sdm_mini.sh` by `download_ami_sdm.sh` and `AMI-SDM.SpeakerDiarization.mini` by `AMI-SDM.SpeakerDiarization.only_words` and you are good to go! " + ], + "metadata": { + "id": "09LrQFIfp0zC" + } + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "os.environ[\"PYANNOTE_DATABASE_CONFIG\"] = \"/content/AMI-diarization-setup/pyannote/database.yml\"\n", + "from pyannote.database import get_protocol, FileFinder\n", + "dataset = get_protocol(\"AMI-SDM.SpeakerDiarization.mini\", {\"audio\": FileFinder()})" + ], + "metadata": { + "id": "l6V8Exw41XBp" + }, + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Pretrained pipeline\n", + "\n", + "Let's start by running the pretrained pipeline on the test set and evaluate its performance.\n", + "\n", + "Official [pyannote.audio](https://github.com/pyannote/pyannote-audio) pipelines (i.e. those under the [`pyannote` organization](https://hf.co/pyannote) umbrella) are open-source, but gated. It means that you have to first accept users conditions on their respective Huggingface page to access the pretrained weights and hyper-parameters. \n", + "\n", + "To load the speaker diarization pipeline used in this tutorial, you have to \n", + "* visit [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization) and accept the terms\n", + "* visit [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation) (used internally by the speaker diarization pipeline)and accept the terms\n", + "* log in using `notebook_login`" + ], + "metadata": { + "id": "HivpZEgZEVAu" + } + }, + { + "cell_type": "code", + "source": [ + "from huggingface_hub import notebook_login\n", + "notebook_login()" + ], + "metadata": { + "id": "FbXEQUGXscTQ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from pyannote.audio import Pipeline\n", + "pretrained_pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization\", use_auth_token=True) " + ], + "metadata": { + "id": "l7eN_Y792Cxt" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# this takes approximately 2min to run on Google Colab GPU\n", + "from pyannote.metrics.diarization import DiarizationErrorRate\n", + "metric = DiarizationErrorRate()\n", + "\n", + "for file in dataset.test():\n", + " # apply pretrained pipeline\n", + " file[\"pretrained pipeline\"] = pretrained_pipeline(file)\n", + "\n", + " # evaluate its performance\n", + " metric(file[\"annotation\"], file[\"pretrained pipeline\"], uem=file[\"annotated\"])\n", + "\n", + "print(f\"The pretrained pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lDIIp7iaICUC", + "outputId": "b4880a85-692b-470d-f133-d95128bdecd9" + }, + "execution_count": 32, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The pretrained pipeline reaches a Diarization Error Rate (DER) of 32.5% on AMI-SDM.SpeakerDiarization.mini test set.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "file[\"annotation\"]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 147 + }, + "id": "r4UydYQkKsxW", + "outputId": "7069d8e5-7dc7-4701-bcd5-1663998cfd1d" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "source": [ + "file[\"pretrained pipeline\"]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 147 + }, + "id": "s4C7xMQlKwVX", + "outputId": "930c571f-069b-44ad-f87e-ce8d471176a6" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 14 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Fine-tuning the segmentation model\n", + "\n", + "When a sufficiently large training set of labeled conversations is available, fine-tuning the internal speaker segmentation model may lead to significant performance boost. \n", + "\n", + "Starting from the pretrained model..." + ], + "metadata": { + "id": "qrYuCLLUKALA" + } + }, + { + "cell_type": "code", + "source": [ + "from pyannote.audio import Model\n", + "model = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)" + ], + "metadata": { + "id": "jeUDgr4f55v6" + }, + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "... we prepare it for fine-tuning on the training dataset:" + ], + "metadata": { + "id": "SAyCf7ontua_" + } + }, + { + "cell_type": "code", + "source": [ + "from pyannote.audio.tasks import Segmentation\n", + "task = Segmentation(dataset, \n", + " duration=model.specifications.duration, \n", + " max_num_speakers=len(model.specifications.classes), \n", + " batch_size=32,\n", + " num_workers=2, \n", + " loss=\"bce\", \n", + " vad_loss=\"bce\")\n", + "model.task = task\n", + "model.setup(stage=\"fit\")" + ], + "metadata": { + "id": "Kk_a7ABQ6PPH" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "The actual training is done with [`lightning`](https://github.com/Lightning-AI/lightning):" + ], + "metadata": { + "id": "TgobhVTKt9sH" + } + }, + { + "cell_type": "code", + "source": [ + "# this takes approximately 15min to run on Google Colab GPU\n", + "from types import MethodType\n", + "from torch.optim import Adam\n", + "from pytorch_lightning.callbacks import (\n", + " EarlyStopping,\n", + " ModelCheckpoint,\n", + " RichProgressBar,\n", + ")\n", + "\n", + "# we use Adam optimizer with 1e-4 learning rate\n", + "def configure_optimizers(self):\n", + " return Adam(self.parameters(), lr=1e-4)\n", + "\n", + "model.configure_optimizers = MethodType(configure_optimizers, model)\n", + "\n", + "# we monitor diarization error rate on the validation set\n", + "# and use to keep the best checkpoint and stop early\n", + "monitor, direction = task.val_monitor\n", + "checkpoint = ModelCheckpoint(\n", + " monitor=monitor,\n", + " mode=direction,\n", + " save_top_k=1,\n", + " every_n_epochs=1,\n", + " save_last=False,\n", + " save_weights_only=False,\n", + " filename=\"{epoch}\",\n", + " verbose=False,\n", + ")\n", + "early_stopping = EarlyStopping(\n", + " monitor=monitor,\n", + " mode=direction,\n", + " min_delta=0.0,\n", + " patience=10,\n", + " strict=True,\n", + " verbose=False,\n", + ")\n", + "\n", + "callbacks = [RichProgressBar(), checkpoint, early_stopping]\n", + "\n", + "# we train for at most 20 epochs (might be shorter in case of early stopping)\n", + "from pytorch_lightning import Trainer\n", + "trainer = Trainer(accelerator=\"gpu\", \n", + " callbacks=callbacks, \n", + " max_epochs=20,\n", + " gradient_clip_val=0.5)\n", + "trainer.fit(model)" + ], + "metadata": { + "id": "f_bVYrNo6TmI" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# save path to the best checkpoint for later use\n", + "finetuned_model = checkpoint.best_model_path\n", + "\n", + "# uncomment to download the checkpoint\n", + "#from google.colab import files\n", + "#files.download(finetuned_model)" + ], + "metadata": { + "id": "830LvZfdd3Rn" + }, + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Optimizing the pipeline hyper-parameters\n", + "\n", + "The pretrained `pyannote/speaker-diarization` pipeline relies on its own set of hyper-parameters adapted to the internal `pyannote/segmentation` pretrained model:" + ], + "metadata": { + "id": "2NVGAIMd-uPI" + } + }, + { + "cell_type": "code", + "source": [ + "pretrained_hyperparameters = pretrained_pipeline.parameters(instantiated=True)\n", + "pretrained_hyperparameters" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8OUIBHP7-xk_", + "outputId": "20b3af76-d2d3-4bf9-eb58-2589f8e86939" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'segmentation': {'min_duration_off': 0.5817029604921046,\n", + " 'threshold': 0.4442333667381752},\n", + " 'clustering': {'method': 'centroid',\n", + " 'min_cluster_size': 15,\n", + " 'threshold': 0.7153814381597874}}" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "There is no reason the above hyper-parameters are optimal for the newly finetuned speaker segmentation model. Let's optimize them:\n", + "\n", + "* `segmentation.threshold` ($\\theta$ in the [technical report](https://huggingface.co/pyannote/speaker-diarization/resolve/main/technical_report_2.1.pdf), between 0 and 1) controls the aggressiveness of speaker activity detection (i.e. a higher value will result in less detected speech); \n", + "* `clustering.threshold` ($\\delta$ in the report, between 0 and 2) controls the number of speakers (i.e. a higher value will result in less speakers).\n", + "* `segmentation.min_duration_off` ($\\Delta$ in the report, in seconds) controls whether intra-speaker pauses are filled. This usually depends on the downstream application so it is better to first force it to zero (i.e. never fill intra-speaker pauses) during optimization.\n", + "* `clustering.centroid` is the linkage used by the agglomerative clustering step. `centroid` has been found to be slightly better than `average`. \n", + "* `clustering.min_cluster_size` controls what to do with small speaker clusters. Clusters smaller than that are assigned to the most similar large cluster. `15` is a good default value.\n", + "\n", + "We start by optimizing `segmentation.threshold` by assuming that the subsequent clustering step is perfect (cf. `OracleClustering`)." + ], + "metadata": { + "id": "y1rRE4NqJmb5" + } + }, + { + "cell_type": "code", + "source": [ + "# this takes approximately 5min to run on Google Colab GPU\n", + "from pyannote.audio.pipelines import SpeakerDiarization\n", + "from pyannote.pipeline import Optimizer\n", + "\n", + "pipeline = SpeakerDiarization(\n", + " segmentation=finetuned_model,\n", + " clustering=\"OracleClustering\", \n", + ")\n", + "# as reported in the technical report, min_duration_off can safely be set to 0.0\n", + "pipeline.freeze({\"segmentation\": {\"min_duration_off\": 0.0}})\n", + "\n", + "optimizer = Optimizer(pipeline)\n", + "dev_set = list(dataset.development())\n", + "\n", + "iterations = optimizer.tune_iter(dev_set, show_progress=False)\n", + "best_loss = 1.0\n", + "for i, iteration in enumerate(iterations):\n", + " print(f\"Best segmentation threshold so far: {iteration['params']['segmentation']['threshold']}\")\n", + " if i > 20: break # 50 iterations should give slightly better results" + ], + "metadata": { + "id": "FSWW7bIphgAI" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Then, we use the optimized value of `segmentation.threshold` and optimize `clustering.threshold`." + ], + "metadata": { + "id": "pAUx-1Pw3Uc9" + } + }, + { + "cell_type": "code", + "source": [ + "best_segmentation_threshold = optimizer.best_params[\"segmentation\"][\"threshold\"]" + ], + "metadata": { + "id": "CSzOWLL5Q29-" + }, + "execution_count": 26, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# this takes approximately 5min to run on Google Colab GPU\n", + "pipeline = SpeakerDiarization(\n", + " segmentation=finetuned_model,\n", + " embedding=pretrained_pipeline.embedding,\n", + " embedding_exclude_overlap=pretrained_pipeline.embedding_exclude_overlap,\n", + " clustering=pretrained_pipeline.klustering,\n", + ")\n", + "\n", + "pipeline.freeze({\n", + " \"segmentation\": {\n", + " \"threshold\": best_segmentation_threshold,\n", + " \"min_duration_off\": 0.0,\n", + " },\n", + " \"clustering\": {\n", + " \"method\": \"centroid\",\n", + " \"min_cluster_size\": 15,\n", + " },\n", + "})\n", + "\n", + "optimizer = Optimizer(pipeline)\n", + "iterations = optimizer.tune_iter(dev_set, show_progress=False)\n", + "best_loss = 1.0\n", + "for i, iteration in enumerate(iterations):\n", + " print(f\"Best clustering threshold so far: {iteration['params']['clustering']['threshold']}\")\n", + " if i > 20: break # 50 iterations should give slightly better results" + ], + "metadata": { + "id": "M_pQkyQ5RCjl" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Finally, we use the optimized values of `segmentation.threshold` and `clustering.threshold` to evaluate the performance of the finetuned pipeline:" + ], + "metadata": { + "id": "BDA2XT-wAzDO" + } + }, + { + "cell_type": "code", + "source": [ + "best_clustering_threshold = optimizer.best_params['clustering']['threshold']" + ], + "metadata": { + "id": "GBJv2j1U_5mj" + }, + "execution_count": 28, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# this takes approximately 2min to run on Google Colab GPU\n", + "finetuned_pipeline = SpeakerDiarization(\n", + " segmentation=finetuned_model,\n", + " embedding=pretrained_pipeline.embedding,\n", + " embedding_exclude_overlap=pretrained_pipeline.embedding_exclude_overlap,\n", + " clustering=pretrained_pipeline.klustering,\n", + ")\n", + "\n", + "finetuned_pipeline.instantiate({\n", + " \"segmentation\": {\n", + " \"threshold\": best_segmentation_threshold,\n", + " \"min_duration_off\": 0.0,\n", + " },\n", + " \"clustering\": {\n", + " \"method\": \"centroid\",\n", + " \"min_cluster_size\": 15,\n", + " \"threshold\": best_clustering_threshold,\n", + " },\n", + "})\n", + "\n", + "metric = DiarizationErrorRate()\n", + "\n", + "for file in dataset.test():\n", + " # apply finetuned pipeline\n", + " file[\"finetuned pipeline\"] = finetuned_pipeline(file)\n", + "\n", + " # evaluate its performance\n", + " metric(file[\"annotation\"], file[\"finetuned pipeline\"], uem=file[\"annotated\"])\n", + "\n", + "print(f\"The finetuned pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ir1VUqNEimcN", + "outputId": "d8edfb16-8f97-4d84-d4d2-3066d8b7c791" + }, + "execution_count": 35, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The finetuned pipeline reaches a Diarization Error Rate (DER) of 26.6% on AMI-SDM.SpeakerDiarization.mini test set.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "file[\"finetuned pipeline\"]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 147 + }, + "id": "LFvNtdZTBDZh", + "outputId": "f72da25d-7df7-4d8f-97b1-b5ca0f2febe7" + }, + "execution_count": 37, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "source": [ + "file[\"annotation\"]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 147 + }, + "id": "odzLUrqaBHgV", + "outputId": "1864ccc7-076e-41bf-ba63-13df32d57fda" + }, + "execution_count": 38, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 38 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Conclusion\n", + "\n", + "In just about half an hour (and 6 hours of training data), we managed to reduce the diarization error rate from 32.5% to 26.6%.\n", + "\n", + "[Yours truly](https://herve.niderb.fr) used this very recipe for their submissions to several speaker diarization benchmarks organized in 2022. I reached:\n", + "\n", + "* 6th place at [VoxSRC 2022](https://mm.kaist.ac.kr/datasets/voxceleb/voxsrc) speaker diarization challenge\n", + "* 1st place at [Ego4D 2022](https://ego4d-data.org/) audio-only speaker diarization challenge\n", + "* 1st place at [Albayzin 2022](http://catedrartve.unizar.es/albayzin2022results.html) speaker diarization challenge\n", + "\n", + "The [technical report](https://huggingface.co/pyannote/speaker-diarization/resolve/main/technical_report_2.1.pdf) contains a detailed description of the pipeline, as well as an extensive evaluation of its performance on multiple benchmarking datasets.\n", + "\n", + "For technical questions and bug reports, please check [pyannote.audio](https://github.com/pyannote/pyannote-audio) Github repository so that my (or anyone's) public answer benefits other people as well. \n", + "\n", + "For scientific consulting enquiries, please contact [me](herve@niderb.fr)." + ], + "metadata": { + "id": "muYEOZ36VJo5" + } + } + ] +} \ No newline at end of file From e469e066b7da846368351eaf0ba5f2ed7f3b5fde Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 2 Dec 2022 14:58:52 +0100 Subject: [PATCH 018/112] doc: add link to adaptation tutorial --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 8c5a13d72..40c195b88 100644 --- a/README.md +++ b/README.md @@ -67,6 +67,7 @@ pip install pyannote.audio - Pipelines - Available pipelines explained - [Applying a pretrained pipeline](tutorials/applying_a_pipeline.ipynb) + - [Adapting a pretrained pipeline to your own data](tutorials/adapting_pretrained_pipeline.ipynb) - [Training a pipeline](tutorials/voice_activity_detection.ipynb) - Contributing - [Adding a new model](tutorials/add_your_own_model.ipynb) From 840562795e0ff62c510129fd2e61c4441c62aa10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 2 Dec 2022 15:14:08 +0100 Subject: [PATCH 019/112] doc: add "How I reached..." blog post --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 40c195b88..7930683f0 100644 --- a/README.md +++ b/README.md @@ -75,6 +75,7 @@ pip install pyannote.audio - Adding a new pipeline - Sharing pretrained models and pipelines - Blog + - 2022-12-02 > ["How I reached 1st place at Ego4D 2022, 1st place at Albayzin 2022, and 6th place at VoxSRC 2022 speaker diarization challenges"](tutorials/adapting_pretrained_pipeline.ipynb) - 2022-10-23 > ["One speaker segmentation model to rule them all"](https://herve.niderb.fr/fastpages/2022/10/23/One-speaker-segmentation-model-to-rule-them-all) - 2021-08-05 > ["Streaming voice activity detection with pyannote.audio"](https://herve.niderb.fr/fastpages/2021/08/05/Streaming-voice-activity-detection-with-pyannote.html) - Miscellaneous From 23cb4d65174cd479161a0599d0f91f37ee41a462 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 2 Dec 2022 15:25:59 +0100 Subject: [PATCH 020/112] doc: update "bad result" FAQ --- FAQ.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/FAQ.md b/FAQ.md index a2d3e95ba..700b63746 100644 --- a/FAQ.md +++ b/FAQ.md @@ -18,8 +18,8 @@ That being said, this whole authentication process does not prevent you from usi ## **[Pretrained pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) do not produce good results on my data. What can I do?** -1. [Annotate](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/prodigy.md) dozens of conversations manually and separate them into development and test subsets in [`pyannote.database`](https://github.com/pyannote/pyannote-database#speaker-diarization). -2. [Optimize the hyper-parameters](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/voice_activity_detection.ipynb) of the pretained pipeline using the development set. If performance is still not good enough, go to step 3. -3. Annotate hundreds of conversations manually and set them up as training subset in `pyannote.database`. -4. [Fine-tune](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/training_a_model.ipynb) the models (on which the pipeline relies) using the training set. -5. [Optimize the hyper-parameters](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/voice_activity_detection.ipynb) of the pipeline using the fine-tuned models using the development set. If performance is still not good enough, go back to step 3. +1. Manually annotate dozens of conversations as precisely as possible. +2. Separate them into train (80%), development (10%) and test (10%) subsets. +3. Format the data in [`pyannote.database`](https://github.com/pyannote/pyannote-database#speaker-diarization) format. +4. Follow [this recipe](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/adapting_pretrained_pipeline.ipynb). +5. Enjoy. From cab76ecf47debe7feeed985c9c998993c1fb5cf4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 2 Dec 2022 15:26:42 +0100 Subject: [PATCH 021/112] Update FAQ.md --- FAQ.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FAQ.md b/FAQ.md index 700b63746..3b50069a4 100644 --- a/FAQ.md +++ b/FAQ.md @@ -20,6 +20,6 @@ That being said, this whole authentication process does not prevent you from usi 1. Manually annotate dozens of conversations as precisely as possible. 2. Separate them into train (80%), development (10%) and test (10%) subsets. -3. Format the data in [`pyannote.database`](https://github.com/pyannote/pyannote-database#speaker-diarization) format. +3. Setup the data for use with [`pyannote.database`](https://github.com/pyannote/pyannote-database#speaker-diarization). 4. Follow [this recipe](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/adapting_pretrained_pipeline.ipynb). 5. Enjoy. From 09df8b9704019a97eee3270a22749c0e04f441c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 7 Dec 2022 12:57:02 +0100 Subject: [PATCH 022/112] fix: rewind IOBase after reading (#1180) Fixes #1179 --- pyannote/audio/core/io.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pyannote/audio/core/io.py b/pyannote/audio/core/io.py index 49175f531..34358c08f 100644 --- a/pyannote/audio/core/io.py +++ b/pyannote/audio/core/io.py @@ -277,6 +277,10 @@ def __call__(self, file: AudioFile) -> Tuple[Tensor, int]: elif "audio" in file: waveform, sample_rate = torchaudio.load(file["audio"]) + # rewind if needed + if isinstance(file["audio"], IOBase): + file["audio"].seek(0) + channel = file.get("channel", None) if channel is not None: @@ -384,6 +388,7 @@ def crop( data, _ = torchaudio.load( file["audio"], frame_offset=start_frame, num_frames=num_frames ) + # rewind if needed if isinstance(file["audio"], IOBase): file["audio"].seek(0) except RuntimeError: From 8217ae2442a64b49f37b7505e988be901ea1ccfd Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Thu, 8 Dec 2022 13:00:04 +0100 Subject: [PATCH 023/112] setup: switch to torchmetrics 0.11 --- pyannote/audio/tasks/embedding/mixins.py | 5 +++-- pyannote/audio/tasks/segmentation/mixins.py | 14 ++++++++++++-- requirements.txt | 2 +- 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index 0bff9d3d7..700008cb1 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -30,7 +30,8 @@ SpeakerDiarizationProtocol, SpeakerVerificationProtocol, ) -from torchmetrics import AUROC, Metric +from torchmetrics import Metric +from torchmetrics.classification import BinaryAUROC from tqdm import tqdm from pyannote.audio.core.task import Problem, Resolution, Specifications @@ -127,7 +128,7 @@ def setup(self, stage: Optional[str] = None): def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: - return AUROC(compute_on_step=False) + return BinaryAUROC(compute_on_cpu=True) def train__iter__(self): """Iterate over training samples diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index ea1960ca3..b45d85d1f 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -31,7 +31,8 @@ import torch from pyannote.core import Segment, SlidingWindowFeature from torch.utils.data._utils.collate import default_collate -from torchmetrics import AUROC, Metric +from torchmetrics import Metric +from torchmetrics.classification import BinaryAUROC, MultilabelAUROC, MulticlassAUROC from pyannote.audio.core.io import AudioFile from pyannote.audio.core.task import Problem @@ -129,7 +130,16 @@ def default_metric( """Returns macro-average of the area under the ROC curve""" num_classes = len(self.specifications.classes) - return AUROC(num_classes, pos_label=1, average="macro", compute_on_step=False) + if self.specifications.problem == Problem.BINARY_CLASSIFICATION: + return BinaryAUROC(compute_on_cpu=True) + elif self.specifications.problem == Problem.MULTI_LABEL_CLASSIFICATION: + return MultilabelAUROC(num_classes, average="macro", compute_on_cpu=True) + elif self.specifications.problem == Problem.MONO_LABEL_CLASSIFICATION: + return MulticlassAUROC(num_classes, average="macro", compute_on_cpu=True) + else: + raise RuntimeError( + f"The {self.specifications.problem} problem type hasn't been given a default segmentation metric yet." + ) def adapt_y(self, one_hot_y: np.ndarray) -> np.ndarray: raise NotImplementedError( diff --git a/requirements.txt b/requirements.txt index 48b585c20..dd7cc43e9 100644 --- a/requirements.txt +++ b/requirements.txt @@ -18,5 +18,5 @@ speechbrain >=0.5.12,<0.6 torch >=1.9 torch_audiomentations >= 0.11.0 torchaudio >=0.10,<1.0 -torchmetrics >=0.6,<1.0 +torchmetrics >=0.11,<1.0 typing_extensions From 9cc8b75777409b9b6f6f4b8d58555c86352b55bc Mon Sep 17 00:00:00 2001 From: pajowu Date: Wed, 14 Dec 2022 22:50:53 +0100 Subject: [PATCH 024/112] BREAKING: add progress hook to pipelines MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Hervé BREDIN --- notebook/inference.ipynb | 13 ---- pyannote/audio/cli/evaluate.py | 9 ++- pyannote/audio/core/inference.py | 69 +++++++++--------- pyannote/audio/core/pipeline.py | 14 +--- pyannote/audio/pipelines/multilabel.py | 19 +++-- .../pipelines/overlapped_speech_detection.py | 18 +++-- pyannote/audio/pipelines/resegmentation.py | 18 +++-- pyannote/audio/pipelines/segmentation.py | 29 +++++++- .../audio/pipelines/speaker_diarization.py | 35 ++++++--- pyannote/audio/pipelines/utils/hook.py | 71 ++++++++++++++++++- .../pipelines/voice_activity_detection.py | 19 +++-- .../audio/tasks/segmentation/segmentation.py | 6 +- pyannote/audio/utils/progress.py | 44 ------------ requirements.txt | 1 + setup.cfg | 1 - 15 files changed, 229 insertions(+), 137 deletions(-) delete mode 100644 pyannote/audio/utils/progress.py diff --git a/notebook/inference.ipynb b/notebook/inference.ipynb index 77e02a27c..b33e64282 100644 --- a/notebook/inference.ipynb +++ b/notebook/inference.ipynb @@ -104,19 +104,6 @@ "scores = inference.crop(dev_file, Segment(10, 15))" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# inference with progress bar\n", - "inference = Inference(model, step=0.1, batch_size=32, progress_hook='Processing...')\n", - "scores = inference(dev_file)\n", - "inference = Inference(model, step=0.1, batch_size=1, progress_hook=True)\n", - "scores = inference.crop(dev_file, Segment(10, 15))" - ] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/pyannote/audio/cli/evaluate.py b/pyannote/audio/cli/evaluate.py index 57f5c0149..a5ab682c5 100644 --- a/pyannote/audio/cli/evaluate.py +++ b/pyannote/audio/cli/evaluate.py @@ -53,14 +53,17 @@ def evaluate(cfg: DictConfig) -> Optional[float]: main_task = progress.add_task(protocol.name, total=len(files)) file_task = progress.add_task("Processing", total=1.0) - def progress_hook(completed: int, total: int): + def progress_hook(completed: int = None, total: int = None): progress.update(file_task, completed=completed / total) - inference = Inference(model, device=device, progress_hook=progress_hook) + inference = Inference(model, device=device) warm_up = cfg.warm_up / inference.duration def hypothesis(file: ProtocolFile): - return Inference.trim(binarize(inference(file)), warm_up=(warm_up, warm_up)) + return Inference.trim( + binarize(inference(file, hook=progress_hook)), + warm_up=(warm_up, warm_up), + ) metric = DiscreteDiarizationErrorRate() diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index b664174b5..a9d5f5f83 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -23,7 +23,7 @@ import math import warnings from pathlib import Path -from typing import Any, Callable, List, Optional, Text, Tuple, Union +from typing import Callable, List, Optional, Text, Tuple, Union import numpy as np import torch @@ -35,7 +35,6 @@ from pyannote.audio.core.model import Model from pyannote.audio.core.task import Resolution from pyannote.audio.utils.permutation import mae_cost_func, permutate -from pyannote.audio.utils.progress import InferenceProgressHook TaskName = Union[Text, None] @@ -67,12 +66,6 @@ class Inference: When a callable is provided, it is applied to the model output, just before aggregation. Takes a (num_chunks, num_frames, dimension) numpy array as input and returns a modified (num_chunks, num_frames, other_dimension) numpy array passed to overlap-add aggregation. - progress_hook : {callable, True, str}, optional - When a callable is provided, it is called everytime a batch is processed - with two integer arguments: - - the number of chunks that have been processed so far - - the total number of chunks - Set to True (or a descriptive string) to display a tqdm progress bar. use_auth_token : str, optional When loading a private huggingface.co model, set `use_auth_token` to True or to a string containing your hugginface.co authentication @@ -89,7 +82,6 @@ def __init__( step: float = None, batch_size: int = 32, pre_aggregation_hook: Callable[[np.ndarray], np.ndarray] = None, - progress_hook: Union[bool, Text, Callable[[int, int], Any]] = False, use_auth_token: Union[Text, None] = None, ): @@ -159,16 +151,6 @@ def __init__( self.batch_size = batch_size - if callable(progress_hook): - pass - elif isinstance(progress_hook, Text): - progress_hook = InferenceProgressHook(desc=progress_hook) - elif progress_hook: - progress_hook = InferenceProgressHook() - else: - progress_hook = None - self.progress_hook = progress_hook - def infer(self, chunks: torch.Tensor) -> np.ndarray: """Forward pass @@ -199,7 +181,12 @@ def infer(self, chunks: torch.Tensor) -> np.ndarray: return outputs.cpu().numpy() - def slide(self, waveform: torch.Tensor, sample_rate: int) -> SlidingWindowFeature: + def slide( + self, + waveform: torch.Tensor, + sample_rate: int, + hook: Optional[Callable], + ) -> SlidingWindowFeature: """Slide model on a waveform Parameters @@ -208,6 +195,11 @@ def slide(self, waveform: torch.Tensor, sample_rate: int) -> SlidingWindowFeatur Waveform. sample_rate : int Sample rate. + hook: Optional[Callable] + When a callable is provided, it is called everytime a batch is + processed with two keyword arguments: + - `completed`: the number of chunks that have been processed so far + - `total`: the total number of chunks Returns ------- @@ -218,7 +210,7 @@ def slide(self, waveform: torch.Tensor, sample_rate: int) -> SlidingWindowFeatur window_size: int = round(self.duration * sample_rate) step_size: int = round(self.step * sample_rate) - num_channels, num_samples = waveform.shape + _, num_samples = waveform.shape specifications = self.model.specifications resolution = specifications.resolution @@ -248,15 +240,15 @@ def slide(self, waveform: torch.Tensor, sample_rate: int) -> SlidingWindowFeatur outputs: Union[List[np.ndarray], np.ndarray] = list() - if self.progress_hook is not None: - self.progress_hook(0, num_chunks + has_last_chunk) + if hook is not None: + hook(completed=0, total=num_chunks + has_last_chunk) # slide over audio chunks in batch for c in np.arange(0, num_chunks, self.batch_size): batch: torch.Tensor = chunks[c : c + self.batch_size] outputs.append(self.infer(batch)) - if self.progress_hook is not None: - self.progress_hook(c + self.batch_size, num_chunks + has_last_chunk) + if hook is not None: + hook(completed=c + self.batch_size, total=num_chunks + has_last_chunk) # process orphan last chunk if has_last_chunk: @@ -268,9 +260,10 @@ def slide(self, waveform: torch.Tensor, sample_rate: int) -> SlidingWindowFeatur last_output = np.pad(last_output, ((0, 0), (0, pad), (0, 0))) outputs.append(last_output) - if self.progress_hook is not None: - self.progress_hook( - num_chunks + has_last_chunk, num_chunks + has_last_chunk + if hook is not None: + hook( + completed=num_chunks + has_last_chunk, + total=num_chunks + has_last_chunk, ) outputs = np.vstack(outputs) @@ -309,13 +302,20 @@ def slide(self, waveform: torch.Tensor, sample_rate: int) -> SlidingWindowFeatur return aggregated - def __call__(self, file: AudioFile) -> Union[SlidingWindowFeature, np.ndarray]: + def __call__( + self, file: AudioFile, hook: Optional[Callable] = None + ) -> Union[SlidingWindowFeature, np.ndarray]: """Run inference on a whole file Parameters ---------- file : AudioFile Audio file. + hook : callable, optional + When a callable is provided, it is called everytime a batch is processed + with two keyword arguments: + - `completed`: the number of chunks that have been processed so far + - `total`: the total number of chunks Returns ------- @@ -324,11 +324,10 @@ def __call__(self, file: AudioFile) -> Union[SlidingWindowFeature, np.ndarray]: and `np.ndarray` if is set to "whole". """ - waveform, sample_rate = self.model.audio(file) if self.window == "sliding": - return self.slide(waveform, sample_rate) + return self.slide(waveform, sample_rate, hook=hook) return self.infer(waveform[None])[0] @@ -337,6 +336,7 @@ def crop( file: AudioFile, chunk: Union[Segment, List[Segment]], duration: Optional[float] = None, + hook: Optional[Callable] = None, ) -> Union[SlidingWindowFeature, np.ndarray]: """Run inference on a chunk or a list of chunks @@ -354,6 +354,11 @@ def crop( Enforce chunk duration (in seconds). This is a hack to avoid rounding errors that may result in a different number of audio samples for two chunks of the same duration. + hook : callable, optional + When a callable is provided, it is called everytime a batch is processed + with two keyword arguments: + - `completed`: the number of chunks that have been processed so far + - `total`: the total number of chunks Returns ------- @@ -381,7 +386,7 @@ def crop( waveform, sample_rate = self.model.audio.crop( file, chunk, duration=duration ) - output = self.slide(waveform, sample_rate) + output = self.slide(waveform, sample_rate, hook=hook) frames = output.sliding_window shifted_frames = SlidingWindow( diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index 1c28e52f5..8d55b5762 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -171,18 +171,10 @@ def from_pretrained( @staticmethod def setup_hook(file: AudioFile, hook: Optional[Callable] = None) -> Callable: + def noop(*args, **kwargs): + return - if hook is None: - - def hook(*args, **kwargs): - return - - hook.missing = True - else: - hook = partial(hook, file=file) - hook.missing = False - - return hook + return partial(hook or noop, file=file) def default_parameters(self): raise NotImplementedError() diff --git a/pyannote/audio/pipelines/multilabel.py b/pyannote/audio/pipelines/multilabel.py index 0f6e3211d..4aef3e249 100644 --- a/pyannote/audio/pipelines/multilabel.py +++ b/pyannote/audio/pipelines/multilabel.py @@ -24,7 +24,7 @@ # Hadrien TITEUX - https://github.com/hadware # Hervé BREDIN - http://herve.niderb.fr - +from functools import partial from typing import Callable, Optional, Text, Union from pyannote.core import Annotation, SlidingWindowFeature @@ -163,8 +163,13 @@ def apply(self, file: AudioFile, hook: Optional[Callable] = None) -> Annotation: file : AudioFile Processed file. hook : callable, optional - Hook called after each major step of the pipeline with the following - signature: hook("step_name", step_artefact, file=file) + Callback called after each major steps of the pipeline as follows: + hook(step_name, # human-readable name of current step + step_artefact, # artifact generated by current step + file=file) # file being processed + Time-consuming steps call `hook` multiple times with the same `step_name` + and additional `completed` and `total` keyword arguments usable to track + progress of current step. Returns ------- @@ -181,10 +186,14 @@ def apply(self, file: AudioFile, hook: Optional[Callable] = None) -> Annotation: if self.CACHED_SEGMENTATION in file: segmentations = file[self.CACHED_SEGMENTATION] else: - segmentations = self._segmentation(file) + segmentations = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) file[self.CACHED_SEGMENTATION] = segmentations else: - segmentations: SlidingWindowFeature = self._segmentation(file) + segmentations: SlidingWindowFeature = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) hook("segmentation", segmentations) diff --git a/pyannote/audio/pipelines/overlapped_speech_detection.py b/pyannote/audio/pipelines/overlapped_speech_detection.py index 2d07a76c7..c3f4f8828 100644 --- a/pyannote/audio/pipelines/overlapped_speech_detection.py +++ b/pyannote/audio/pipelines/overlapped_speech_detection.py @@ -22,6 +22,7 @@ """Overlapped speech detection pipelines""" +from functools import partial from typing import Callable, Optional, Text, Union import numpy as np @@ -187,8 +188,13 @@ def apply(self, file: AudioFile, hook: Optional[Callable] = None) -> Annotation: file : AudioFile Processed file. hook : callable, optional - Hook called after each major step of the pipeline with the following - signature: hook("step_name", step_artefact, file=file) + Callback called after each major steps of the pipeline as follows: + hook(step_name, # human-readable name of current step + step_artefact, # artifact generated by current step + file=file) # file being processed + Time-consuming steps call `hook` multiple times with the same `step_name` + and additional `completed` and `total` keyword arguments usable to track + progress of current step. Returns ------- @@ -205,10 +211,14 @@ def apply(self, file: AudioFile, hook: Optional[Callable] = None) -> Annotation: if self.CACHED_SEGMENTATION in file: segmentations = file[self.CACHED_SEGMENTATION] else: - segmentations = self._segmentation(file) + segmentations = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) file[self.CACHED_SEGMENTATION] = segmentations else: - segmentations: SlidingWindowFeature = self._segmentation(file) + segmentations: SlidingWindowFeature = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) hook("segmentation", segmentations) diff --git a/pyannote/audio/pipelines/resegmentation.py b/pyannote/audio/pipelines/resegmentation.py index 7e3969a2a..4c786307f 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -22,6 +22,7 @@ """Resegmentation pipeline""" +from functools import partial from typing import Callable, Optional, Text, Union import numpy as np @@ -151,8 +152,13 @@ def apply( diarization : Annotation, optional Input diarization. Defaults to file[self.diarization]. hook : callable, optional - Hook called after each major step of the pipeline with the following - signature: hook("step_name", step_artefact, file=file) + Callback called after each major steps of the pipeline as follows: + hook(step_name, # human-readable name of current step + step_artefact, # artifact generated by current step + file=file) # file being processed + Time-consuming steps call `hook` multiple times with the same `step_name` + and additional `completed` and `total` keyword arguments usable to track + progress of current step. Returns ------- @@ -168,10 +174,14 @@ def apply( if self.CACHED_SEGMENTATION in file: segmentations = file[self.CACHED_SEGMENTATION] else: - segmentations = self._segmentation(file) + segmentations = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) file[self.CACHED_SEGMENTATION] = segmentations else: - segmentations: SlidingWindowFeature = self._segmentation(file) + segmentations: SlidingWindowFeature = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) hook("segmentation", segmentations) diff --git a/pyannote/audio/pipelines/segmentation.py b/pyannote/audio/pipelines/segmentation.py index 34eb207c9..8c28ebbe8 100644 --- a/pyannote/audio/pipelines/segmentation.py +++ b/pyannote/audio/pipelines/segmentation.py @@ -23,6 +23,7 @@ """Speaker segmentation pipeline""" import math +from functools import partial from typing import Callable, Optional, Text, Union import networkx as nx @@ -255,6 +256,26 @@ def stitchable_components( def apply( self, file: AudioFile, hook: Optional[Callable] = None ) -> SlidingWindowFeature: + """Apply speaker segmentation + + Parameters + ---------- + file : AudioFile + Processed file. + hook : callable, optional + Callback called after each major steps of the pipeline as follows: + hook(step_name, # human-readable name of current step + step_artefact, # artifact generated by current step + file=file) # file being processed + Time-consuming steps call `hook` multiple times with the same `step_name` + and additional `completed` and `total` keyword arguments usable to track + progress of current step. + + Returns + ------- + segmentation : Annotation + Speaker segmentation + """ hook = self.setup_hook(file, hook=hook) @@ -264,10 +285,14 @@ def apply( if self.CACHED_SEGMENTATION in file: segmentations = file[self.CACHED_SEGMENTATION] else: - segmentations = self._segmentation(file) + segmentations = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) file[self.CACHED_SEGMENTATION] = segmentations else: - segmentations: SlidingWindowFeature = self._segmentation(file) + segmentations: SlidingWindowFeature = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) hook("segmentation", segmentations) diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 348e1cf11..8245ae646 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -22,6 +22,7 @@ """Speaker diarization pipelines""" +import functools import itertools import math from typing import Callable, Optional, Text, Union @@ -212,25 +213,30 @@ def classes(self): def CACHED_SEGMENTATION(self): return "training_cache/segmentation" - def get_segmentations(self, file) -> SlidingWindowFeature: + def get_segmentations(self, file, hook=None) -> SlidingWindowFeature: """Apply segmentation model Parameter --------- file : AudioFile + hook : Optional[Callable] Returns ------- segmentations : (num_chunks, num_frames, num_speakers) SlidingWindowFeature """ + + if hook is not None: + hook = functools.partial(hook, "segmentation", None) + if self.training: if self.CACHED_SEGMENTATION in file: segmentations = file[self.CACHED_SEGMENTATION] else: - segmentations = self._segmentation(file) + segmentations = self._segmentation(file, hook=hook) file[self.CACHED_SEGMENTATION] = segmentations else: - segmentations: SlidingWindowFeature = self._segmentation(file) + segmentations: SlidingWindowFeature = self._segmentation(file, hook=hook) return segmentations @@ -239,6 +245,7 @@ def get_embeddings( file, binary_segmentations: SlidingWindowFeature, exclude_overlap: bool = False, + hook: Optional[Callable] = None, ): """Extract embeddings for each (chunk, speaker) pair @@ -250,6 +257,8 @@ def get_embeddings( exclude_overlap : bool, optional Exclude overlapping speech regions when extracting embeddings. In case non-overlapping speech is too short, use the whole speech. + hook: Optional[Callable] + Called during embeddings after every batch to report the progress Returns ------- @@ -272,7 +281,7 @@ def get_embeddings( return cache["embeddings"] duration = binary_segmentations.sliding_window.duration - num_chunks, num_frames, _ = binary_segmentations.data.shape + num_chunks, num_frames, num_speakers = binary_segmentations.data.shape if exclude_overlap: # minimum number of samples needed to extract an embedding @@ -335,9 +344,11 @@ def iter_waveform_and_mask(): fillvalue=(None, None), ) + batch_count = math.ceil(num_chunks * num_speakers / self.embedding_batch_size) + embedding_batches = [] - for batch in batches: + for i, batch in enumerate(batches, 1): waveforms, masks = zip(*filter(lambda b: b[0] is not None, batch)) waveform_batch = torch.vstack(waveforms) @@ -353,6 +364,9 @@ def iter_waveform_and_mask(): embedding_batches.append(embedding_batch) + if hook is not None: + hook("embeddings", embedding_batch, total=batch_count, completed=i) + embedding_batches = np.vstack(embedding_batches) embeddings = rearrange(embedding_batches, "(c s) d -> c s d", c=num_chunks) @@ -440,8 +454,12 @@ def apply( max_speakers : int, optional Maximum number of speakers. Has no effect when `num_speakers` is provided. hook : callable, optional - Hook called after each major step of the pipeline with the following - signature: hook("step_name", step_artefact, file=file) + Callback called after each major steps of the pipeline as follows: + hook(step_name, # human-readable name of current step + step_artefact, # artifact generated by current step + file=file) # file being processed + Additionnally, time-consuming steps may call `hook` multiple times with the + same `step_name`, and `completed` increasing progressively from 0 to `total`. Returns ------- @@ -458,7 +476,7 @@ def apply( max_speakers=max_speakers, ) - segmentations = self.get_segmentations(file) + segmentations = self.get_segmentations(file, hook=hook) hook("segmentation", segmentations) # shape: (num_chunks, num_frames, local_num_speakers) @@ -487,6 +505,7 @@ def apply( file, binarized_segmentations, exclude_overlap=self.embedding_exclude_overlap, + hook=hook, ) hook("embeddings", embeddings) # shape: (num_chunks, local_num_speakers, dimension) diff --git a/pyannote/audio/pipelines/utils/hook.py b/pyannote/audio/pipelines/utils/hook.py index 37891f5fe..443ef9ac4 100644 --- a/pyannote/audio/pipelines/utils/hook.py +++ b/pyannote/audio/pipelines/utils/hook.py @@ -23,6 +23,73 @@ from copy import deepcopy from typing import Any, Mapping, Optional, Text +from rich.progress import ( + BarColumn, + Progress, + TaskProgressColumn, + TextColumn, + TimeRemainingColumn, +) -def logging_hook(key: Text, value: Any, file: Optional[Mapping] = None): - file[key] = deepcopy(value) + +def logging_hook( + step_name: Text, + step_artifact: Any, + file: Optional[Mapping] = None, + completed: Optional[int] = None, + total: Optional[int] = None, +): + """Hook to save step_artifact as file[step_name] + + Useful for debugging purposes + """ + + if completed is None: + file[step_name] = deepcopy(step_artifact) + + +class ProgressHook: + """Hook to show progress of each internal step + + Example + ------- + pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization") + with ProgressHook() as hook: + output = pipeline(file, hook=hook) + """ + + def __enter__(self): + + self.progress = Progress( + TextColumn("[progress.description]{task.description}"), + BarColumn(), + TaskProgressColumn(), + TimeRemainingColumn(elapsed_when_finished=True), + ) + self.progress.start() + return self + + def __exit__(self, *args): + self.progress.stop() + + def __call__( + self, + step_name: Text, + step_artifact: Any, + file: Optional[Mapping] = None, + total: Optional[int] = None, + completed: Optional[int] = None, + ): + + if completed is None: + completed = total = 1 + + if not hasattr(self, "step_name") or step_name != self.step_name: + self.step_name = step_name + self.step = self.progress.add_task(self.step_name) + + self.progress.update(self.step, completed=completed, total=total) + + # force refresh when completed + if completed >= total: + self.progress.refresh() diff --git a/pyannote/audio/pipelines/voice_activity_detection.py b/pyannote/audio/pipelines/voice_activity_detection.py index b146758ae..aa3e15903 100644 --- a/pyannote/audio/pipelines/voice_activity_detection.py +++ b/pyannote/audio/pipelines/voice_activity_detection.py @@ -24,6 +24,7 @@ import tempfile from copy import deepcopy +from functools import partial from types import MethodType from typing import Callable, Optional, Text, Union @@ -173,8 +174,13 @@ def apply(self, file: AudioFile, hook: Optional[Callable] = None) -> Annotation: file : AudioFile Processed file. hook : callable, optional - Hook called after each major step of the pipeline with the following - signature: hook("step_name", step_artefact, file=file) + Callback called after each major steps of the pipeline as follows: + hook(step_name, # human-readable name of current step + step_artefact, # artifact generated by current step + file=file) # file being processed + Time-consuming steps call `hook` multiple times with the same `step_name` + and additional `completed` and `total` keyword arguments usable to track + progress of current step. Returns ------- @@ -191,10 +197,14 @@ def apply(self, file: AudioFile, hook: Optional[Callable] = None) -> Annotation: if self.CACHED_SEGMENTATION in file: segmentations = file[self.CACHED_SEGMENTATION] else: - segmentations = self._segmentation(file) + segmentations = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) file[self.CACHED_SEGMENTATION] = segmentations else: - segmentations: SlidingWindowFeature = self._segmentation(file) + segmentations: SlidingWindowFeature = self._segmentation( + file, hook=partial(hook, "segmentation", None) + ) hook("segmentation", segmentations) @@ -352,7 +362,6 @@ def configure_optimizers(model): vad_model, device=self.inference.device, batch_size=self.inference.batch_size, - progress_hook=self.inference.progress_hook, ) file["vad"] = inference(file) diff --git a/pyannote/audio/tasks/segmentation/segmentation.py b/pyannote/audio/tasks/segmentation/segmentation.py index c79c4a99e..def43eb31 100644 --- a/pyannote/audio/tasks/segmentation/segmentation.py +++ b/pyannote/audio/tasks/segmentation/segmentation.py @@ -429,15 +429,15 @@ def main(protocol: str, subset: str = "test", model: str = "pyannote/segmentatio main_task = progress.add_task(protocol.name, total=len(files)) file_task = progress.add_task("Processing", total=1.0) - def progress_hook(completed: int, total: int): + def progress_hook(completed: int = None, total: int = None): progress.update(file_task, completed=completed / total) - inference = Inference(model, device=device, progress_hook=progress_hook) + inference = Inference(model, device=device) for file in files: progress.update(file_task, description=file["uri"]) reference = file["annotation"] - hypothesis = binarize(inference(file)) + hypothesis = binarize(inference(file, hook=progress_hook)) uem = file["annotated"] _ = metric(reference, hypothesis, uem=uem) progress.advance(main_task) diff --git a/pyannote/audio/utils/progress.py b/pyannote/audio/utils/progress.py deleted file mode 100644 index eaf6b661f..000000000 --- a/pyannote/audio/utils/progress.py +++ /dev/null @@ -1,44 +0,0 @@ -# MIT License -# -# Copyright (c) 2021 CNRS -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - - -from typing import Text - -from tqdm import tqdm - - -class InferenceProgressHook: - """Default inference progress bar""" - - def __init__(self, desc: Text = None): - self.desc = desc - - def __call__(self, chunk_idx, num_chunks): - - if chunk_idx == 0: - self.pbar = tqdm(desc=self.desc, total=num_chunks, unit="chunks") - self.chunk_idx = chunk_idx - - self.pbar.update(chunk_idx - self.chunk_idx) - self.chunk_idx = chunk_idx - if self.chunk_idx == num_chunks: - self.pbar.close() diff --git a/requirements.txt b/requirements.txt index dd7cc43e9..df2e9c1d6 100644 --- a/requirements.txt +++ b/requirements.txt @@ -11,6 +11,7 @@ pyannote.metrics >=3.2,<4.0 pyannote.pipeline >=2.3,<3.0 pytorch_lightning >=1.5.4,<1.7 pytorch_metric_learning >=1.0.0,<2.0 +rich >= 12.0.0 semver >=2.10.2,<3.0 singledispatchmethod soundfile >=0.10.2,<0.12 diff --git a/setup.cfg b/setup.cfg index 4d80b3966..33e56556e 100644 --- a/setup.cfg +++ b/setup.cfg @@ -52,7 +52,6 @@ interactive = prodigy>=1.11.0 cli = hydra-core >=1.1,<1.2 - rich >= 11.1.0,<12.0.0 typer >= 0.4.0,<0.5.0 [options.entry_points] From b00b1f7faa3962d657127ea905c743a2d4388b41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 15 Dec 2022 12:34:16 +0100 Subject: [PATCH 025/112] fix(pipeline): fix #1166 --- pyannote/audio/pipelines/speaker_diarization.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 8245ae646..ac79cb16b 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -490,6 +490,10 @@ def apply( # shape: (num_frames, 1) # dtype: int + # exit early when no speaker is ever active + if np.nanmax(count.data) == 0.0: + return Annotation(uri=file["uri"]) + # binarize segmentation binarized_segmentations: SlidingWindowFeature = binarize( segmentations, From 01405fd87fd37ebd9a303004860bb68b051d4d3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 21 Dec 2022 18:47:07 +0100 Subject: [PATCH 026/112] Update changelog.rst --- doc/source/changelog.rst | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/doc/source/changelog.rst b/doc/source/changelog.rst index c6a3ff50e..549e40a0e 100644 --- a/doc/source/changelog.rst +++ b/doc/source/changelog.rst @@ -2,6 +2,15 @@ Changelog ######### +Version 2.2 (xxxx-xx-xx) +~~~~~~~~~~~~~~~~~~~~~~~~ + + - feat(pipeline): add progress hook to pipelines + - fix(pipeline): fix support for IOBase audio + - fix(pipeline): fix corner case with no speaker + - setup: add support for soundfile >= 0.11 + - setup: add support for torchmetrics >= 0.11 + Version 2.1 (2022-11-xx) ~~~~~~~~~~~~~~~~~~~~~~~~ From 7a60da9b8e28ad66b89e67e7ce5a9806fd9b781f Mon Sep 17 00:00:00 2001 From: Ewald Enzinger Date: Tue, 3 Jan 2023 13:24:30 +0100 Subject: [PATCH 027/112] fix: add support for MLflow in segmentation task --- pyannote/audio/tasks/segmentation/mixins.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index b45d85d1f..beaa2bc63 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -30,6 +30,7 @@ import numpy as np import torch from pyannote.core import Segment, SlidingWindowFeature +from pytorch_lightning.loggers import TensorBoardLogger, MLFlowLogger from torch.utils.data._utils.collate import default_collate from torchmetrics import Metric from torchmetrics.classification import BinaryAUROC, MultilabelAUROC, MulticlassAUROC @@ -429,7 +430,7 @@ def validation_step(self, batch, batch_idx: int): ): return - # visualize first 9 validation samples of first batch in Tensorboard + # visualize first 9 validation samples of first batch in Tensorboard/MLflow X = X.cpu().numpy() y = y.float().cpu().numpy() y_pred = y_pred.cpu().numpy() @@ -478,8 +479,15 @@ def validation_step(self, batch, batch_idx: int): plt.tight_layout() - self.model.logger.experiment.add_figure( - f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch - ) + if isinstance(self.model.logger, TensorBoardLogger): + self.model.logger.experiment.add_figure( + f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch + ) + elif isinstance(self.model.logger, MLFlowLogger): + self.model.logger.experiment.log_figure( + run_id=self.model.logger.run_id, + figure=fig, + artifact_file=f"{self.logging_prefix}ValSamples_epoch{self.model.current_epoch}.png", + ) plt.close(fig) From 40783ce0f81b8f7db2120546b6ce5c8e76b7753d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 3 Jan 2023 13:44:56 +0100 Subject: [PATCH 028/112] feat: send pipeline to device with Pipeline.to(device) (#1204) --- doc/source/changelog.rst | 9 +- pyannote/audio/core/inference.py | 13 ++- pyannote/audio/core/pipeline.py | 98 ++++++++++++++++++- pyannote/audio/pipelines/multilabel.py | 7 +- .../pipelines/overlapped_speech_detection.py | 7 +- pyannote/audio/pipelines/resegmentation.py | 3 - pyannote/audio/pipelines/segmentation.py | 3 - .../audio/pipelines/speaker_diarization.py | 18 ++-- .../audio/pipelines/speaker_verification.py | 61 +++++++----- .../pipelines/voice_activity_detection.py | 7 +- 10 files changed, 162 insertions(+), 64 deletions(-) diff --git a/doc/source/changelog.rst b/doc/source/changelog.rst index 549e40a0e..543449ff4 100644 --- a/doc/source/changelog.rst +++ b/doc/source/changelog.rst @@ -2,17 +2,18 @@ Changelog ######### -Version 2.2 (xxxx-xx-xx) -~~~~~~~~~~~~~~~~~~~~~~~~ +Version 2.2.x +~~~~~~~~~~~~~ + - feat(pipeline): (BREAKING) send pipeline to device with Pipeline.to(device) - feat(pipeline): add progress hook to pipelines - fix(pipeline): fix support for IOBase audio - fix(pipeline): fix corner case with no speaker - setup: add support for soundfile >= 0.11 - setup: add support for torchmetrics >= 0.11 -Version 2.1 (2022-11-xx) -~~~~~~~~~~~~~~~~~~~~~~~~ +Version 2.1.1 (2022-10-27) +~~~~~~~~~~~~~~~~~~~~~~~~~~ - BREAKING(pipeline): rewrite speaker diarization pipeline - feat(pipeline): add option to optimize for DER variant diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index a9d5f5f83..16cdea65c 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -39,7 +39,11 @@ TaskName = Union[Text, None] -class Inference: +class BaseInference: + pass + + +class Inference(BaseInference): """Inference Parameters @@ -151,6 +155,13 @@ def __init__( self.batch_size = batch_size + def to(self, device: torch.device): + """Send internal model to `device`""" + + self.model.to(device) + self.device = device + return self + def infer(self, chunks: torch.Tensor) -> np.ndarray: """Forward pass diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index 8d55b5762..f7c83a3e9 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -22,10 +22,11 @@ import os import warnings +from collections import OrderedDict from collections.abc import Iterator from functools import partial from pathlib import Path -from typing import Callable, List, Optional, Text, Union +from typing import Callable, Dict, List, Optional, Text, Union import yaml from huggingface_hub import hf_hub_download @@ -35,8 +36,9 @@ from pyannote.pipeline import Pipeline as _Pipeline from pyannote.audio import Audio, __version__ +from pyannote.audio.core.inference import BaseInference from pyannote.audio.core.io import AudioFile -from pyannote.audio.core.model import CACHE_DIR +from pyannote.audio.core.model import CACHE_DIR, Model PIPELINE_PARAMS_NAME = "config.yaml" @@ -169,6 +171,83 @@ def from_pretrained( return pipeline + def __init__(self): + super().__init__() + self._models: Dict[str, Model] = OrderedDict() + self._inferences: Dict[str, BaseInference] = OrderedDict() + + def __getattr__(self, name): + """(Advanced) attribute getter + + Adds support for Model and Inference attributes, + which are iterated over by Pipeline.to() method. + + See pyannote.pipeline.Pipeline.__getattr__. + """ + + if "_models" in self.__dict__: + _models = self.__dict__["_models"] + if name in _models: + return _models[name] + + if "_inferences" in self.__dict__: + _inferences = self.__dict__["_inferences"] + if name in _inferences: + return _inferences[name] + + return super().__getattr__(name) + + def __setattr__(self, name, value): + """(Advanced) attribute setter + + Adds support for Model and Inference attributes, + which are iterated over by Pipeline.to() method. + + See pyannote.pipeline.Pipeline.__setattr__. + """ + + def remove_from(*dicts): + for d in dicts: + if name in d: + del d[name] + + _parameters = self.__dict__.get("_parameters") + _instantiated = self.__dict__.get("_instantiated") + _pipelines = self.__dict__.get("_pipelines") + _models = self.__dict__.get("_models") + _inferences = self.__dict__.get("_inferences") + + if isinstance(value, Model): + if _models is None: + msg = "cannot assign models before Pipeline.__init__() call" + raise AttributeError(msg) + remove_from( + self.__dict__, _inferences, _parameters, _instantiated, _pipelines + ) + _models[name] = value + return + + if isinstance(value, BaseInference): + if _inferences is None: + msg = "cannot assign inferences before Pipeline.__init__() call" + raise AttributeError(msg) + remove_from(self.__dict__, _models, _parameters, _instantiated, _pipelines) + _inferences[name] = value + return + + super().__setattr__(name, value) + + def __delattr__(self, name): + + if name in self._models: + del self._models[name] + + elif name in self._inferences: + del self._inferences[name] + + else: + super().__delattr__(name) + @staticmethod def setup_hook(file: AudioFile, hook: Optional[Callable] = None) -> Callable: def noop(*args, **kwargs): @@ -228,3 +307,18 @@ def __call__(self, file: AudioFile, **kwargs): file = ProtocolFile(file, lazy=self.preprocessors) return self.apply(file, **kwargs) + + def to(self, device): + """Send pipeline to `device`""" + + for _, pipeline in self._pipelines.items(): + if hasattr(pipeline, "to"): + _ = pipeline.to(device) + + for _, model in self._models.items(): + _ = model.to(device) + + for _, inference in self._inferences.items(): + _ = inference.to(device) + + return self diff --git a/pyannote/audio/pipelines/multilabel.py b/pyannote/audio/pipelines/multilabel.py index 4aef3e249..18693f14c 100644 --- a/pyannote/audio/pipelines/multilabel.py +++ b/pyannote/audio/pipelines/multilabel.py @@ -37,7 +37,7 @@ from pyannote.audio.utils.metric import MacroAverageFMeasure from ..utils.signal import Binarize -from .utils import PipelineModel, get_devices, get_model +from .utils import PipelineModel, get_model class MultiLabelSegmentation(Pipeline): @@ -93,11 +93,8 @@ def __init__( self.fscore = fscore self.share_min_duration = share_min_duration - # load model and send it to GPU (when available and not already on GPU) + # load model 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) self._classes = model.specifications.classes self._segmentation = Inference(model, **inference_kwargs) diff --git a/pyannote/audio/pipelines/overlapped_speech_detection.py b/pyannote/audio/pipelines/overlapped_speech_detection.py index c3f4f8828..9b14ee10f 100644 --- a/pyannote/audio/pipelines/overlapped_speech_detection.py +++ b/pyannote/audio/pipelines/overlapped_speech_detection.py @@ -34,7 +34,7 @@ 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.pipelines.utils import PipelineModel, get_model from pyannote.audio.utils.signal import Binarize @@ -125,11 +125,8 @@ def __init__( self.segmentation = segmentation - # load model and send it to GPU (when available and not already on GPU) + # load model 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) if model.introspection.dimension > 1: inference_kwargs["pre_aggregation_hook"] = lambda scores: np.partition( diff --git a/pyannote/audio/pipelines/resegmentation.py b/pyannote/audio/pipelines/resegmentation.py index 4c786307f..57cf9004b 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -36,7 +36,6 @@ from pyannote.audio.pipelines.utils import ( PipelineModel, SpeakerDiarizationMixin, - get_devices, get_model, ) from pyannote.audio.utils.permutation import mae_cost_func, permutate @@ -96,8 +95,6 @@ def __init__( self.diarization = diarization model: Model = get_model(segmentation, use_auth_token=use_auth_token) - (device,) = get_devices(needs=1) - model.to(device) self._segmentation = Inference(model) self._frames = self._segmentation.model.introspection.frames diff --git a/pyannote/audio/pipelines/segmentation.py b/pyannote/audio/pipelines/segmentation.py index 8c28ebbe8..3eeb6070a 100644 --- a/pyannote/audio/pipelines/segmentation.py +++ b/pyannote/audio/pipelines/segmentation.py @@ -38,7 +38,6 @@ from pyannote.audio.pipelines.utils import ( PipelineModel, SpeakerDiarizationMixin, - get_devices, get_model, ) from pyannote.audio.utils.metric import ( @@ -95,8 +94,6 @@ def __init__( self.skip_conversion = skip_conversion model: Model = get_model(segmentation, use_auth_token=use_auth_token) - (device,) = get_devices(needs=1) - model.to(device) self._segmentation = Inference(model) self._frames = self._segmentation.model.introspection.frames diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index ac79cb16b..dbe2686c0 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -41,7 +41,6 @@ from pyannote.audio.pipelines.utils import ( PipelineModel, SpeakerDiarizationMixin, - get_devices, get_model, ) from pyannote.audio.utils.signal import binarize @@ -139,10 +138,6 @@ def __init__( self.der_variant = der_variant or {"collar": 0.0, "skip_overlap": False} - seg_device, emb_device = get_devices(needs=2) - - model.to(seg_device) - self._segmentation = Inference( model, duration=self.segmentation_duration, @@ -162,7 +157,7 @@ def __init__( else: self._embedding = PretrainedSpeakerEmbedding( - self.embedding, device=emb_device, use_auth_token=use_auth_token + self.embedding, use_auth_token=use_auth_token ) self._audio = Audio(sample_rate=self._embedding.sample_rate, mono=True) metric = self._embedding.metric @@ -455,11 +450,12 @@ def apply( Maximum number of speakers. Has no effect when `num_speakers` is provided. hook : callable, optional Callback called after each major steps of the pipeline as follows: - hook(step_name, # human-readable name of current step - step_artefact, # artifact generated by current step - file=file) # file being processed - Additionnally, time-consuming steps may call `hook` multiple times with the - same `step_name`, and `completed` increasing progressively from 0 to `total`. + hook(step_name, # human-readable name of current step + step_artefact, # artifact generated by current step + file=file) # file being processed + Time-consuming steps call `hook` multiple times with the same `step_name` + and additional `completed` and `total` keyword arguments usable to track + progress of current step. Returns ------- diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 1ebd40fdc..18f527c34 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -36,9 +36,10 @@ from torch.nn.utils.rnn import pad_sequence from pyannote.audio import Inference, Model, Pipeline +from pyannote.audio.core.inference import BaseInference from pyannote.audio.core.io import AudioFile from pyannote.audio.core.model import CACHE_DIR -from pyannote.audio.pipelines.utils import PipelineModel, get_devices, get_model +from pyannote.audio.pipelines.utils import PipelineModel, get_model backend = torchaudio.get_audio_backend() try: @@ -62,7 +63,7 @@ NEMO_IS_AVAILABLE = False -class NeMoPretrainedSpeakerEmbedding: +class NeMoPretrainedSpeakerEmbedding(BaseInference): def __init__( self, embedding: Text = "nvidia/speakerverification_en_titanet_large", @@ -77,12 +78,17 @@ def __init__( super().__init__() self.embedding = embedding - self.device = device + self.device = device or torch.device("cpu") self.model_ = NeMo_EncDecSpeakerLabelModel.from_pretrained(self.embedding) self.model_.freeze() self.model_.to(self.device) + def to(self, device: torch.device): + self.model_.to(device) + self.device = device + return self + @cached_property def sample_rate(self) -> int: return self.model_._cfg.train_ds.get("sample_rate", 16000) @@ -193,7 +199,7 @@ def __call__( return embeddings -class SpeechBrainPretrainedSpeakerEmbedding: +class SpeechBrainPretrainedSpeakerEmbedding(BaseInference): """Pretrained SpeechBrain speaker embedding Parameters @@ -237,15 +243,26 @@ def __init__( super().__init__() self.embedding = embedding - self.device = device + self.device = device or torch.device("cpu") + self.use_auth_token = use_auth_token self.classifier_ = SpeechBrain_EncoderClassifier.from_hparams( source=self.embedding, savedir=f"{CACHE_DIR}/speechbrain", run_opts={"device": self.device}, - use_auth_token=use_auth_token, + use_auth_token=self.use_auth_token, ) + def to(self, device: torch.device): + self.classifier_ = SpeechBrain_EncoderClassifier.from_hparams( + source=self.embedding, + savedir=f"{CACHE_DIR}/speechbrain", + run_opts={"device": self.device}, + use_auth_token=self.use_auth_token, + ) + self.device = device + return self + @cached_property def sample_rate(self) -> int: return self.classifier_.audio_normalizer.sample_rate @@ -321,7 +338,10 @@ def __call__( imasks = imasks > 0.5 signals = pad_sequence( - [waveform[imask] for waveform, imask in zip(waveforms, imasks)], + [ + waveform[imask].contiguous() + for waveform, imask in zip(waveforms, imasks) + ], batch_first=True, ) @@ -349,7 +369,7 @@ def __call__( return embeddings -class PyannoteAudioPretrainedSpeakerEmbedding: +class PyannoteAudioPretrainedSpeakerEmbedding(BaseInference): """Pretrained pyannote.audio speaker embedding Parameters @@ -386,12 +406,17 @@ def __init__( ): super().__init__() self.embedding = embedding - self.device = device + self.device = device or torch.device("cpu") self.model_: Model = get_model(self.embedding, use_auth_token=use_auth_token) self.model_.eval() self.model_.to(self.device) + def to(self, device: torch.device): + self.model_.to(device) + self.device = device + return self + @cached_property def sample_rate(self) -> int: return self.model_.audio.sample_rate @@ -518,23 +543,11 @@ def __init__( embedding, use_auth_token=use_auth_token ) - if self.segmentation is None: - models = [self.embedding_model_] - else: + if self.segmentation is not None: 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) - cpu_models = [model for model in models if model.device.type == "cpu"] - for cpu_model, gpu_device in zip( - cpu_models, get_devices(needs=len(cpu_models)) - ): - cpu_model.to(gpu_device) - - if self.segmentation is not None: - self.voice_activity_ = Inference( + self._segmentation = Inference( segmentation_model, pre_aggregation_hook=lambda scores: np.max( scores, axis=-1, keepdims=True @@ -552,7 +565,7 @@ def apply(self, file: AudioFile) -> np.ndarray: weights = None else: # obtain voice activity scores - weights = self.voice_activity_(file).data + weights = self._segmentation(file).data # HACK -- this should be fixed upstream weights[np.isnan(weights)] = 0.0 weights = torch.from_numpy(weights**3)[None, :, 0].to(device) diff --git a/pyannote/audio/pipelines/voice_activity_detection.py b/pyannote/audio/pipelines/voice_activity_detection.py index aa3e15903..4328e1cbf 100644 --- a/pyannote/audio/pipelines/voice_activity_detection.py +++ b/pyannote/audio/pipelines/voice_activity_detection.py @@ -1,6 +1,6 @@ # MIT License # -# Copyright (c) 2018-2021 CNRS +# Copyright (c) 2018- CNRS # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal @@ -49,7 +49,6 @@ PipelineInference, PipelineModel, get_augmentation, - get_devices, get_inference, get_model, ) @@ -122,10 +121,6 @@ def __init__( # load model and send it to GPU (when available and not already on GPU) 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) - inference_kwargs["pre_aggregation_hook"] = lambda scores: np.max( scores, axis=-1, keepdims=True ) From fbab49aa3d5692047d7c102df61f39d4e17aafdb Mon Sep 17 00:00:00 2001 From: Prashanth Ellina Date: Thu, 5 Jan 2023 06:57:42 -0500 Subject: [PATCH 029/112] fix: fix SpeechBrainPretrainedSpeakerEmbedding.to(device) --- pyannote/audio/pipelines/speaker_verification.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 18f527c34..af32582a3 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -257,7 +257,7 @@ def to(self, device: torch.device): self.classifier_ = SpeechBrain_EncoderClassifier.from_hparams( source=self.embedding, savedir=f"{CACHE_DIR}/speechbrain", - run_opts={"device": self.device}, + run_opts={"device": device}, use_auth_token=self.use_auth_token, ) self.device = device From 6927ced52de68b6be978d3417acadee4d4ca5bf2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 6 Jan 2023 08:38:20 +0100 Subject: [PATCH 030/112] doc: add usage section to HAC pipeline fixes #1219 --- pyannote/audio/pipelines/clustering.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index ffb51b483..6258bbd98 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -293,7 +293,6 @@ class FINCHClustering(BaseClustering): ---------- metric : {"cosine", "euclidean", ...}, optional Distance metric to use. Defaults to "cosine". - """ def __init__( @@ -400,6 +399,21 @@ class AgglomerativeClustering(BaseClustering): Linkage method. threshold : float in range [0.0, 2.0] Clustering threshold. + min_cluster_size : int in range [1, 20] + Minimum cluster size + + Usage + ----- + >>> clustering = AgglomerativeClustering(metric="cosine") + >>> clustering.instantiate({"method": "average", + ... "threshold": 1.0, + ... "min_cluster_size": 1}) + >>> clusters, _ = clustering(embeddings, # shape + ... num_clusters=None, + ... min_clusters=None, + ... max_clusters=None) + where `embeddings` is a np.ndarray with shape (num_embeddings, embedding_dimension) + and `clusters` is a np.ndarray with shape (num_embeddings, ) """ def __init__( From 0506ae38c3e03e7ce2cb0b869e986d259ffc75a4 Mon Sep 17 00:00:00 2001 From: "Balazs G. Horvath" Date: Mon, 16 Jan 2023 13:00:19 +0100 Subject: [PATCH 031/112] fix: fix pre-commit hook --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d1a6a64cd..549e46ad0 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -20,7 +20,7 @@ repos: args: ["--profile", "black"] # Formatting, Whitespace, etc - - repo: git://github.com/pre-commit/pre-commit-hooks + - repo: https://github.com/pre-commit/pre-commit-hooks rev: v2.2.3 hooks: - id: trailing-whitespace From 12dc20bde1d4bb5fb7c46d288bf722e58d373215 Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Fri, 20 Jan 2023 11:22:18 +0100 Subject: [PATCH 032/112] feat: add support for "powerset" speaker segmentation training MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Hervé BREDIN --- pyannote/audio/cli/pretrained.py | 4 +- pyannote/audio/core/inference.py | 39 +- pyannote/audio/core/task.py | 33 +- pyannote/audio/models/segmentation/PyanNet.py | 13 +- .../audio/pipelines/speaker_diarization.py | 63 +-- pyannote/audio/tasks/__init__.py | 3 +- pyannote/audio/tasks/segmentation/mixins.py | 20 +- .../audio/tasks/segmentation/multilabel.py | 28 +- .../audio/tasks/segmentation/segmentation.py | 379 ++++++++++++++++-- pyannote/audio/utils/permutation.py | 4 +- pyannote/audio/utils/powerset.py | 153 +++++++ tests/io_test.py | 1 - tests/utils/test_powerset.py | 53 +++ 13 files changed, 694 insertions(+), 99 deletions(-) create mode 100644 pyannote/audio/utils/powerset.py create mode 100644 tests/utils/test_powerset.py diff --git a/pyannote/audio/cli/pretrained.py b/pyannote/audio/cli/pretrained.py index 95a439b3f..8b8aae587 100644 --- a/pyannote/audio/cli/pretrained.py +++ b/pyannote/audio/cli/pretrained.py @@ -26,6 +26,4 @@ def pretrained(checkpoint: Text): - return Model.from_pretrained( - checkpoint, map_location=lambda storage, loc: storage - ) + return Model.from_pretrained(checkpoint, map_location=lambda storage, loc: storage) diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 16cdea65c..cf92e2ee5 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -35,6 +35,7 @@ from pyannote.audio.core.model import Model from pyannote.audio.core.task import Resolution from pyannote.audio.utils.permutation import mae_cost_func, permutate +from pyannote.audio.utils.powerset import Powerset TaskName = Union[Text, None] @@ -53,23 +54,26 @@ class Inference(BaseInference): window : {"sliding", "whole"}, optional Use a "sliding" window and aggregate the corresponding outputs (default) or just one (potentially long) window covering the "whole" file or chunk. - skip_aggregation : bool, optional - Do not aggregate outputs when using "sliding" window. Defaults to False. duration : float, optional Chunk duration, in seconds. Defaults to duration used for training the model. Has no effect when `window` is "whole". step : float, optional Step between consecutive chunks, in seconds. Defaults to warm-up duration when greater than 0s, otherwise 10% of duration. Has no effect when `window` is "whole". + pre_aggregation_hook : callable, optional + When a callable is provided, it is applied to the model output, just before aggregation. + Takes a (num_chunks, num_frames, dimension) numpy array as input and returns a modified + (num_chunks, num_frames, other_dimension) numpy array passed to overlap-add aggregation. + skip_aggregation : bool, optional + Do not aggregate outputs when using "sliding" window. Defaults to False. + skip_conversion: bool, optional + In case `model` has been trained with `powerset` mode, its output is automatically + converted to `multi-label`, unless `skip_conversion` is set to True. batch_size : int, optional Batch size. Larger values make inference faster. Defaults to 32. device : torch.device, optional Device used for inference. Defaults to `model.device`. In case `device` and `model.device` are different, model is sent to device. - pre_aggregation_hook : callable, optional - When a callable is provided, it is applied to the model output, just before aggregation. - Takes a (num_chunks, num_frames, dimension) numpy array as input and returns a modified - (num_chunks, num_frames, other_dimension) numpy array passed to overlap-add aggregation. use_auth_token : str, optional When loading a private huggingface.co model, set `use_auth_token` to True or to a string containing your hugginface.co authentication @@ -80,12 +84,13 @@ def __init__( self, model: Union[Model, Text, Path], window: Text = "sliding", - skip_aggregation: bool = False, - device: torch.device = None, duration: float = None, step: float = None, - batch_size: int = 32, pre_aggregation_hook: Callable[[np.ndarray], np.ndarray] = None, + skip_aggregation: bool = False, + skip_conversion: bool = False, + device: torch.device = None, + batch_size: int = 32, use_auth_token: Union[Text, None] = None, ): @@ -154,11 +159,19 @@ def __init__( self.step = step self.batch_size = batch_size + self.skip_conversion = skip_conversion + if specifications.powerset and not self.skip_conversion: + self._powerset = Powerset( + len(specifications.classes), specifications.powerset_max_classes + ) + self._powerset.to(self.device) def to(self, device: torch.device): """Send internal model to `device`""" self.model.to(device) + if self.model.specifications.powerset and not self.skip_conversion: + self._powerset.to(device) self.device = device return self @@ -190,6 +203,14 @@ def infer(self, chunks: torch.Tensor) -> np.ndarray: else: raise exception + # convert powerset to multi-label unless specifically requested not to + if self.model.specifications.powerset and not self.skip_conversion: + powerset = torch.nn.functional.one_hot( + torch.argmax(outputs, dim=-1), + self.model.specifications.num_powerset_classes, + ).float() + outputs = self._powerset.to_multilabel(powerset) + return outputs.cpu().numpy() def slide( diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index fb42fb7cc..5b523176b 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -25,6 +25,8 @@ from functools import partial +import scipy.special + try: from functools import cached_property except ImportError: @@ -89,9 +91,38 @@ class Specifications: # (for classification tasks only) list of classes classes: Optional[List[Text]] = None + # (for powerset only) max number of simultaneous classes + # (n choose k with k <= powerset_max_classes) + powerset_max_classes: Optional[int] = None + # whether classes are permutation-invariant (e.g. diarization) permutation_invariant: bool = False + @cached_property + def powerset(self): + + if self.powerset_max_classes is None: + return False + + if self.problem != Problem.MONO_LABEL_CLASSIFICATION: + raise ValueError( + "`powerset_max_classes` only makes sense with multi-class classification problems." + ) + + return True + + @cached_property + def num_powerset_classes(self) -> int: + # compute number of subsets of size at most "powerset_max_classes" + # e.g. with len(classes) = 3 and powerset_max_classes = 2: + # {}, {0}, {1}, {2}, {0, 1}, {0, 2}, {1, 2} + return int( + sum( + scipy.special.binom(len(self.classes), i) + for i in range(0, self.powerset_max_classes + 1) + ) + ) + class TrainDataset(IterableDataset): def __init__(self, task: Task): @@ -314,7 +345,7 @@ def default_loss( ]: return binary_cross_entropy(prediction, target, weight=weight) - elif specifications.problem == Problem.MONO_LABEL_CLASSIFICATION: + elif specifications.problem in [Problem.MONO_LABEL_CLASSIFICATION]: return nll_loss(prediction, target, weight=weight) else: diff --git a/pyannote/audio/models/segmentation/PyanNet.py b/pyannote/audio/models/segmentation/PyanNet.py index a39a8fa70..1b68a32a9 100644 --- a/pyannote/audio/models/segmentation/PyanNet.py +++ b/pyannote/audio/models/segmentation/PyanNet.py @@ -27,12 +27,12 @@ import torch.nn as nn import torch.nn.functional as F from einops import rearrange +from pyannote.core.utils.generators import pairwise from pyannote.audio.core.model import Model from pyannote.audio.core.task import Task from pyannote.audio.models.blocks.sincnet import SincNet from pyannote.audio.utils.params import merge_dict -from pyannote.core.utils.generators import pairwise class PyanNet(Model): @@ -130,7 +130,9 @@ def __init__( [ nn.Linear(in_features, out_features) for in_features, out_features in pairwise( - [lstm_out_features,] + [ + lstm_out_features, + ] + [self.hparams.linear["hidden_size"]] * self.hparams.linear["num_layers"] ) @@ -146,7 +148,12 @@ def build(self): 2 if self.hparams.lstm["bidirectional"] else 1 ) - self.classifier = nn.Linear(in_features, len(self.specifications.classes)) + if self.specifications.powerset: + out_features = self.specifications.num_powerset_classes + else: + out_features = len(self.specifications.classes) + + self.classifier = nn.Linear(in_features, out_features) self.activation = self.default_activation() def forward(self, waveforms: torch.Tensor) -> torch.Tensor: diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index dbe2686c0..1e279b82a 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -147,10 +147,16 @@ def __init__( ) self._frames: SlidingWindow = self._segmentation.model.introspection.frames - self.segmentation = ParamDict( - threshold=Uniform(0.1, 0.9), - min_duration_off=Uniform(0.0, 1.0), - ) + if self._segmentation.model.specifications.powerset: + self.segmentation = ParamDict( + min_duration_off=Uniform(0.0, 1.0), + ) + + else: + self.segmentation = ParamDict( + threshold=Uniform(0.1, 0.9), + min_duration_off=Uniform(0.0, 1.0), + ) if self.klustering == "OracleClustering": metric = "not_applicable" @@ -260,18 +266,19 @@ def get_embeddings( embeddings : (num_chunks, num_speakers, dimension) array """ - # when optimizing the hyper-parameters of this pipeline with frozen "segmentation_onset", - # one can reuse the embeddings from the first trial, bringing a massive speed up to - # the optimization process (and hence allowing to use a larger search space). + # when optimizing the hyper-parameters of this pipeline with frozen + # "segmentation.threshold", one can reuse the embeddings from the first trial, + # bringing a massive speed up to the optimization process (and hence allowing to use + # a larger search space). if self.training: # we only re-use embeddings if they were extracted based on the same value of the - # "segmentation_onset" hyperparameter and "embedding_exclude_overlap" parameter. + # "segmentation.threshold" hyperparameter or if the segmentation model relies on + # `powerset` mode cache = file.get("training_cache/embeddings", dict()) - if ( - cache.get("segmentation.threshold", None) == self.segmentation.threshold - and cache.get("embedding_exclude_overlap", None) - == self.embedding_exclude_overlap + if ("embeddings" in cache) and ( + self._segmentation.model.specifications.powerset + or (cache["segmentation.threshold"] == self.segmentation.threshold) ): return cache["embeddings"] @@ -369,11 +376,16 @@ def iter_waveform_and_mask(): # caching embeddings for subsequent trials # (see comments at the top of this method for more details) if self.training: - file["training_cache/embeddings"] = { - "segmentation.threshold": self.segmentation.threshold, - "embedding_exclude_overlap": self.embedding_exclude_overlap, - "embeddings": embeddings, - } + + if self._segmentation.model.specifications.powerset: + file["training_cache/embeddings"] = { + "embeddings": embeddings, + } + else: + file["training_cache/embeddings"] = { + "segmentation.threshold": self.segmentation.threshold, + "embeddings": embeddings, + } return embeddings @@ -479,7 +491,9 @@ def apply( # estimate frame-level number of instantaneous speakers count = self.speaker_count( segmentations, - onset=self.segmentation.threshold, + onset=0.5 + if self._segmentation.model.specifications.powerset + else self.segmentation.threshold, frames=self._frames, ) hook("speaker_counting", count) @@ -491,11 +505,14 @@ def apply( return Annotation(uri=file["uri"]) # binarize segmentation - binarized_segmentations: SlidingWindowFeature = binarize( - segmentations, - onset=self.segmentation.threshold, - initial_state=False, - ) + if self._segmentation.model.specifications.powerset: + binarized_segmentations = segmentations + else: + binarized_segmentations: SlidingWindowFeature = binarize( + segmentations, + onset=self.segmentation.threshold, + initial_state=False, + ) if self.klustering == "OracleClustering": embeddings = None diff --git a/pyannote/audio/tasks/__init__.py b/pyannote/audio/tasks/__init__.py index e53600bc1..eeaf19d10 100644 --- a/pyannote/audio/tasks/__init__.py +++ b/pyannote/audio/tasks/__init__.py @@ -25,9 +25,10 @@ OverlappedSpeechDetection, ) -from .segmentation.multilabel import MultiLabelSegmentation # isort:skip +from .segmentation.multilabel import MultiLabelSegmentation # isort:skip from .segmentation.segmentation import Segmentation # isort:skip from .embedding.arcface import SupervisedRepresentationLearningWithArcFace # isort:skip + SpeakerEmbedding = SupervisedRepresentationLearningWithArcFace __all__ = [ diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index beaa2bc63..d0f63d2c2 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -29,14 +29,16 @@ import matplotlib.pyplot as plt import numpy as np import torch +import torch.nn.functional from pyannote.core import Segment, SlidingWindowFeature -from pytorch_lightning.loggers import TensorBoardLogger, MLFlowLogger +from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger from torch.utils.data._utils.collate import default_collate from torchmetrics import Metric -from torchmetrics.classification import BinaryAUROC, MultilabelAUROC, MulticlassAUROC +from torchmetrics.classification import BinaryAUROC, MulticlassAUROC, MultilabelAUROC from pyannote.audio.core.io import AudioFile from pyannote.audio.core.task import Problem +from pyannote.audio.utils.powerset import Powerset from pyannote.audio.utils.random import create_rng_for_worker @@ -125,6 +127,13 @@ def setup(self, stage: Optional[str] = None): random.shuffle(self._validation) + def setup_loss_func(self): + if self.specifications.powerset: + self.model.powerset = Powerset( + len(self.specifications.classes), + self.specifications.powerset_max_classes, + ) + def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: @@ -372,10 +381,12 @@ def validation_step(self, batch, batch_idx: int): _, num_frames, _ = y_pred.shape # y_pred = (batch_size, num_frames, num_classes) - # - remove warm-up frames - # - downsample remaining frames + # compute warmup frames boundaries and weight warm_up_left = round(self.warm_up[0] / self.duration * num_frames) warm_up_right = round(self.warm_up[1] / self.duration * num_frames) + + # - remove warm-up frames + # - downsample remaining frames preds = y_pred[:, warm_up_left : num_frames - warm_up_right : 10] target = y[:, warm_up_left : num_frames - warm_up_right : 10] @@ -383,7 +394,6 @@ def validation_step(self, batch, batch_idx: int): # pyannote.audio is more explicit so we have to reshape target and preds for # torchmetrics to be happy... more details can be found here: # https://torchmetrics.readthedocs.io/en/latest/references/modules.html#input-types - if self.specifications.problem == Problem.BINARY_CLASSIFICATION: # target: shape (batch_size, num_frames), type binary # preds: shape (batch_size, num_frames, 1), type float diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index a501554b8..20632b619 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -36,7 +36,7 @@ class MultiLabelSegmentation(SegmentationTaskMixin, Task): """Generic multi-label segmentation - Multi-label segmentation is the process of detecting temporal intervals + Multi-label segmentation is the process of detecting temporal intervals when a specific audio class is active. Example use cases include speaker tracking, gender (male/female) @@ -80,18 +80,18 @@ class MultiLabelSegmentation(SegmentationTaskMixin, Task): """ def __init__( - self, - protocol: Protocol, - classes: Optional[List[str]] = None, - duration: float = 2.0, - warm_up: Union[float, Tuple[float, float]] = 0.0, - balance: Text = None, - weight: Text = None, - batch_size: int = 32, - num_workers: int = None, - pin_memory: bool = False, - augmentation: BaseWaveformTransform = None, - metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, + self, + protocol: Protocol, + classes: Optional[List[str]] = None, + duration: float = 2.0, + warm_up: Union[float, Tuple[float, float]] = 0.0, + balance: Text = None, + weight: Text = None, + batch_size: int = 32, + num_workers: int = None, + pin_memory: bool = False, + augmentation: BaseWaveformTransform = None, + metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): super().__init__( protocol, @@ -109,7 +109,7 @@ def __init__( self.classes = classes # task specification depends on the data: we do not know in advance which - # classes should be detected. therefore, we postpone the definition of + # classes should be detected. therefore, we postpone the definition of # specifications to setup() def setup(self, stage: Optional[str] = None): diff --git a/pyannote/audio/tasks/segmentation/segmentation.py b/pyannote/audio/tasks/segmentation/segmentation.py index def43eb31..6dc68a44a 100644 --- a/pyannote/audio/tasks/segmentation/segmentation.py +++ b/pyannote/audio/tasks/segmentation/segmentation.py @@ -20,13 +20,18 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +import math +import warnings from collections import Counter from typing import Dict, Optional, Sequence, Text, Tuple, Union import numpy as np import torch +import torch.nn.functional +from matplotlib import pyplot as plt from pyannote.core import SlidingWindow from pyannote.database import Protocol +from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric from typing_extensions import Literal @@ -34,13 +39,17 @@ from pyannote.audio.core.task import Problem, Resolution, Specifications, Task from pyannote.audio.tasks.segmentation.mixins import SegmentationTaskMixin from pyannote.audio.torchmetrics import ( + DiarizationErrorRate, + FalseAlarmRate, + MissedDetectionRate, OptimalDiarizationErrorRate, OptimalDiarizationErrorRateThreshold, OptimalFalseAlarmRate, OptimalMissedDetectionRate, OptimalSpeakerConfusionRate, + SpeakerConfusionRate, ) -from pyannote.audio.utils.loss import binary_cross_entropy, mse_loss +from pyannote.audio.utils.loss import binary_cross_entropy, mse_loss, nll_loss from pyannote.audio.utils.permutation import permutate @@ -53,9 +62,13 @@ class Segmentation(SegmentationTaskMixin, Task): pyannote.database protocol duration : float, optional Chunks duration. Defaults to 2s. - max_num_speakers : int, optional - Force maximum number of speakers per chunk (must be at least 2). + max_speakers_per_chunk : int, optional + Maximum number of speakers per chunk (must be at least 2). Defaults to estimating it from the training set. + max_speakers_per_frame : int, optional + Maximum number of (overlapping) speakers per frame. + Setting this value to 1 or more enables `powerset multi-class` training. + Default behavior is to use `multi-label` training. warm_up : float or (float, float), optional Use that many seconds on the left- and rightmost parts of each chunk to warm up the model. While the model does process those left- and right-most @@ -67,7 +80,7 @@ class Segmentation(SegmentationTaskMixin, Task): For instance, setting `balance` to "uri" will make sure that each file will be equally represented in the training samples. weight: str, optional - When provided, use this key to as frame-wise weight in loss function. + When provided, use this key as frame-wise weight in loss function. batch_size : int, optional Number of training samples per batch. Defaults to 32. num_workers : int, optional @@ -80,26 +93,32 @@ class Segmentation(SegmentationTaskMixin, Task): augmentation : BaseWaveformTransform, optional torch_audiomentations waveform transform, used by dataloader during training. - loss : {"bce", "mse"}, optional - Permutation-invariant segmentation loss. Defaults to "bce". vad_loss : {"bce", "mse"}, optional Add voice activity detection loss. + Cannot be used in conjunction with `max_speakers_per_frame`. metric : optional Validation metric(s). Can be anything supported by torchmetrics.MetricCollection. Defaults to AUROC (area under the ROC curve). - Reference + References ---------- Hervé Bredin and Antoine Laurent "End-To-End Speaker Segmentation for Overlap-Aware Resegmentation." Proc. Interspeech 2021 + + Zhihao Du, Shiliang Zhang, Siqi Zheng, and Zhijie Yan + "Speaker Embedding-aware Neural Diarization: an Efficient Framework for Overlapping + Speech Diarization in Meeting Scenarios" + https://arxiv.org/abs/2203.09767 + """ def __init__( self, protocol: Protocol, duration: float = 2.0, - max_num_speakers: int = None, + max_speakers_per_chunk: int = None, + max_speakers_per_frame: int = None, warm_up: Union[float, Tuple[float, float]] = 0.0, balance: Text = None, weight: Text = None, @@ -107,9 +126,10 @@ def __init__( num_workers: int = None, pin_memory: bool = False, augmentation: BaseWaveformTransform = None, - loss: Literal["bce", "mse"] = "bce", vad_loss: Literal["bce", "mse"] = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, + max_num_speakers: int = None, # deprecated in favor of `max_speakers_per_chunk`` + loss: Literal["bce", "mse"] = None, # deprecated ): super().__init__( @@ -123,20 +143,37 @@ def __init__( metric=metric, ) - self.max_num_speakers = max_num_speakers + # deprecation warnings + if max_speakers_per_chunk is None and max_num_speakers is not None: + max_speakers_per_chunk = max_num_speakers + warnings.warn( + "`max_num_speakers` has been deprecated in favor of `max_speakers_per_chunk`." + ) + if loss is not None: + warnings.warn("`loss` has been deprecated and has no effect.") + + # parameter validation + if max_speakers_per_frame is not None: + if max_speakers_per_frame < 1: + raise ValueError( + f"`max_speakers_per_frame` must be 1 or more (you used {max_speakers_per_frame})." + ) + if vad_loss is not None: + raise ValueError( + "`vad_loss` cannot be used jointly with `max_speakers_per_frame`" + ) + + self.max_speakers_per_chunk = max_speakers_per_chunk + self.max_speakers_per_frame = max_speakers_per_frame self.balance = balance self.weight = weight - - if loss not in ["bce", "mse"]: - raise ValueError("'loss' must be one of {'bce', 'mse'}.") - self.loss = loss self.vad_loss = vad_loss def setup(self, stage: Optional[str] = None): super().setup(stage=stage) - if self.max_num_speakers is None: + if self.max_speakers_per_chunk is None: # TODO: optimize this @@ -165,19 +202,31 @@ def setup(self, stage: Optional[str] = None): num_speakers = num_speakers[sorting_indices] counts = counts[sorting_indices] - self.max_num_speakers = max( + self.max_speakers_per_chunk = max( 2, num_speakers[np.where(np.cumsum(counts) / np.sum(counts) > 0.99)[0][0]], ) + if ( + self.max_speakers_per_frame is not None + and self.max_speakers_per_frame > self.max_speakers_per_chunk + ): + raise ValueError( + f"`max_speakers_per_frame` ({self.max_speakers_per_frame}) must be smaller " + f"than `max_speakers_per_chunk` ({self.max_speakers_per_chunk})" + ) + # now that we know about the number of speakers upper bound # we can set task specifications self.specifications = Specifications( - problem=Problem.MULTI_LABEL_CLASSIFICATION, + problem=Problem.MULTI_LABEL_CLASSIFICATION + if self.max_speakers_per_frame is None + else Problem.MONO_LABEL_CLASSIFICATION, resolution=Resolution.FRAME, duration=self.duration, warm_up=self.warm_up, - classes=[f"speaker#{i+1}" for i in range(self.max_num_speakers)], + classes=[f"speaker#{i+1}" for i in range(self.max_speakers_per_chunk)], + powerset_max_classes=self.max_speakers_per_frame, permutation_invariant=True, ) @@ -193,27 +242,27 @@ def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor: Returns ------- - y : (batch_size, num_frames, max_num_speakers) tensor - Same as collated_y, except we only keep ``max_num_speakers`` most + y : (batch_size, num_frames, max_speakers_per_chunk) tensor + Same as collated_y, except we only keep ``max_speakers_per_chunk`` most talkative speakers (per sample). """ batch_size, num_frames, num_speakers = collated_y.shape # maximum number of active speakers in a chunk - max_num_speakers = torch.max( + max_speakers_per_chunk = torch.max( torch.sum(torch.sum(collated_y, dim=1) > 0.0, dim=1) ) # sort speakers in descending talkativeness order indices = torch.argsort(torch.sum(collated_y, dim=1), dim=1, descending=True) - # keep max_num_speakers most talkative speakers, for each chunk + # keep max_speakers_per_chunk most talkative speakers, for each chunk y = torch.zeros( - (batch_size, num_frames, max_num_speakers), dtype=collated_y.dtype + (batch_size, num_frames, max_speakers_per_chunk), dtype=collated_y.dtype ) for b, index in enumerate(indices): - for k, i in zip(range(max_num_speakers), index): + for k, i in zip(range(max_speakers_per_chunk), index): y[b, :, k] = collated_y[b, :, i.item()] return y @@ -241,14 +290,15 @@ def segmentation_loss( Permutation-invariant segmentation loss """ - if self.loss == "bce": + if self.specifications.powerset: + seg_loss = nll_loss( + permutated_prediction, torch.argmax(target, dim=-1), weight=weight + ) + else: seg_loss = binary_cross_entropy( permutated_prediction, target.float(), weight=weight ) - elif self.loss == "mse": - seg_loss = mse_loss(permutated_prediction, target.float(), weight=weight) - return seg_loss def voice_activity_detection_loss( @@ -289,7 +339,7 @@ def voice_activity_detection_loss( return loss def training_step(self, batch, batch_idx: int): - """Compute permutation-invariant binary cross-entropy + """Compute permutation-invariant segmentation loss Parameters ---------- @@ -313,7 +363,7 @@ def training_step(self, batch, batch_idx: int): # drop samples that contain too many speakers num_speakers: torch.Tensor = torch.sum(torch.any(target, dim=1), dim=1) - keep: torch.Tensor = num_speakers <= self.max_num_speakers + keep: torch.Tensor = num_speakers <= self.max_speakers_per_chunk target = target[keep] waveform = waveform[keep] @@ -337,9 +387,6 @@ def training_step(self, batch, batch_idx: int): batch_size, num_frames, _ = prediction.shape # (batch_size, num_frames, num_classes) - # find optimal permutation - permutated_prediction, _ = permutate(target, prediction) - # frames weight weight_key = getattr(self, "weight", None) weight = batch.get( @@ -354,7 +401,26 @@ def training_step(self, batch, batch_idx: int): warm_up_right = round(self.warm_up[1] / self.duration * num_frames) weight[:, num_frames - warm_up_right :] = 0.0 - seg_loss = self.segmentation_loss(permutated_prediction, target, weight=weight) + if self.specifications.powerset: + + powerset = torch.nn.functional.one_hot( + torch.argmax(prediction, dim=-1), + self.model.powerset.num_powerset_classes, + ).float() + multilabel = self.model.powerset.to_multilabel(powerset) + permutated_target, _ = permutate(multilabel, target) + permutated_target_powerset = self.model.powerset.to_powerset( + permutated_target.float() + ) + seg_loss = self.segmentation_loss( + prediction, permutated_target_powerset, weight=weight + ) + + else: + permutated_prediction, _ = permutate(target, prediction) + seg_loss = self.segmentation_loss( + permutated_prediction, target, weight=weight + ) self.model.log( f"{self.logging_prefix}TrainSegLoss", @@ -369,9 +435,18 @@ def training_step(self, batch, batch_idx: int): vad_loss = 0.0 else: - vad_loss = self.voice_activity_detection_loss( - permutated_prediction, target, weight=weight - ) + + # TODO: vad_loss probably does not make sense in powerset mode + # because first class (empty set of labels) does exactly this... + if self.specifications.powerset: + vad_loss = self.voice_activity_detection_loss( + prediction, permutated_target_powerset, weight=weight + ) + + else: + vad_loss = self.voice_activity_detection_loss( + permutated_prediction, target, weight=weight + ) self.model.log( f"{self.logging_prefix}TrainVADLoss", @@ -399,6 +474,15 @@ def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: """Returns diarization error rate and its components""" + + if self.specifications.powerset: + return [ + DiarizationErrorRate(0.5), + SpeakerConfusionRate(0.5), + MissedDetectionRate(0.5), + FalseAlarmRate(0.5), + ] + return [ OptimalDiarizationErrorRate(), OptimalDiarizationErrorRateThreshold(), @@ -407,6 +491,227 @@ def default_metric( OptimalFalseAlarmRate(), ] + def train__iter__(self): + for chunk in super().train__iter__(): + # TODO: document why this filtering is needed + if self.specifications.powerset: + if len(chunk["y"].labels) <= self.max_speakers_per_chunk: + yield chunk + else: + yield chunk + + # TODO: no need to compute gradient in this method + def validation_step(self, batch, batch_idx: int): + """Compute validation loss and metric + + Parameters + ---------- + batch : dict of torch.Tensor + Current batch. + batch_idx: int + Batch index. + """ + + # target + target = batch["y"] + # (batch_size, num_frames, num_speakers) + + waveform = batch["X"] + # (batch_size, num_channels, num_samples) + + # TODO: should we handle validation samples with too many speakers + # waveform = waveform[keep] + # target = target[keep] + + # forward pass + prediction = self.model(waveform) + batch_size, num_frames, _ = prediction.shape + + # frames weight + weight_key = getattr(self, "weight", None) + weight = batch.get( + weight_key, + torch.ones(batch_size, num_frames, 1, device=self.model.device), + ) + # (batch_size, num_frames, 1) + + # warm-up + warm_up_left = round(self.warm_up[0] / self.duration * num_frames) + weight[:, :warm_up_left] = 0.0 + warm_up_right = round(self.warm_up[1] / self.duration * num_frames) + weight[:, num_frames - warm_up_right :] = 0.0 + + if self.specifications.powerset: + + powerset = torch.nn.functional.one_hot( + torch.argmax(prediction, dim=-1), + self.model.powerset.num_powerset_classes, + ).float() + multilabel = self.model.powerset.to_multilabel(powerset) + permutated_target, _ = permutate(multilabel, target) + + # FIXME: handle case where target have too many speakers? + # since we don't need + permutated_target_powerset = self.model.powerset.to_powerset( + permutated_target.float() + ) + seg_loss = self.segmentation_loss( + prediction, permutated_target_powerset, weight=weight + ) + + else: + permutated_prediction, _ = permutate(target, prediction) + seg_loss = self.segmentation_loss( + permutated_prediction, target, weight=weight + ) + + self.model.log( + f"{self.logging_prefix}ValSegLoss", + seg_loss, + on_step=False, + on_epoch=True, + prog_bar=False, + logger=True, + ) + + if self.vad_loss is None: + vad_loss = 0.0 + + else: + + # TODO: vad_loss probably does not make sense in powerset mode + # because first class (empty set of labels) does exactly this... + if self.specifications.powerset: + vad_loss = self.voice_activity_detection_loss( + prediction, permutated_target_powerset, weight=weight + ) + + else: + vad_loss = self.voice_activity_detection_loss( + permutated_prediction, target, weight=weight + ) + + self.model.log( + f"{self.logging_prefix}ValVADLoss", + vad_loss, + on_step=False, + on_epoch=True, + prog_bar=False, + logger=True, + ) + + loss = seg_loss + vad_loss + + self.model.log( + f"{self.logging_prefix}ValLoss", + loss, + on_step=False, + on_epoch=True, + prog_bar=False, + logger=True, + ) + + if self.specifications.powerset: + self.model.validation_metric( + torch.transpose( + multilabel[:, warm_up_left : num_frames - warm_up_right], 1, 2 + ), + torch.transpose( + target[:, warm_up_left : num_frames - warm_up_right], 1, 2 + ), + ) + else: + self.model.validation_metric( + torch.transpose( + prediction[:, warm_up_left : num_frames - warm_up_right], 1, 2 + ), + torch.transpose( + target[:, warm_up_left : num_frames - warm_up_right], 1, 2 + ), + ) + + self.model.log_dict( + self.model.validation_metric, + on_step=False, + on_epoch=True, + prog_bar=True, + logger=True, + ) + + # log first batch visualization every 2^n epochs. + if ( + self.model.current_epoch == 0 + or math.log2(self.model.current_epoch) % 1 > 0 + or batch_idx > 0 + ): + return + + # visualize first 9 validation samples of first batch in Tensorboard/MLflow + + if self.specifications.powerset: + y = permutated_target_powerset.float().cpu().numpy() + y_pred = multilabel.cpu().numpy() + else: + y = target.float().cpu().numpy() + y_pred = permutated_prediction.cpu().numpy() + + # prepare 3 x 3 grid (or smaller if batch size is smaller) + num_samples = min(self.batch_size, 9) + nrows = math.ceil(math.sqrt(num_samples)) + ncols = math.ceil(num_samples / nrows) + fig, axes = plt.subplots( + nrows=2 * nrows, ncols=ncols, figsize=(8, 5), squeeze=False + ) + + # reshape target so that there is one line per class when plotting it + y[y == 0] = np.NaN + if len(y.shape) == 2: + y = y[:, :, np.newaxis] + y *= np.arange(y.shape[2]) + + # plot each sample + for sample_idx in range(num_samples): + + # find where in the grid it should be plotted + row_idx = sample_idx // nrows + col_idx = sample_idx % ncols + + # plot target + ax_ref = axes[row_idx * 2 + 0, col_idx] + sample_y = y[sample_idx] + ax_ref.plot(sample_y) + ax_ref.set_xlim(0, len(sample_y)) + ax_ref.set_ylim(-1, sample_y.shape[1]) + ax_ref.get_xaxis().set_visible(False) + ax_ref.get_yaxis().set_visible(False) + + # plot predictions + ax_hyp = axes[row_idx * 2 + 1, col_idx] + sample_y_pred = y_pred[sample_idx] + ax_hyp.axvspan(0, warm_up_left, color="k", alpha=0.5, lw=0) + ax_hyp.axvspan( + num_frames - warm_up_right, num_frames, color="k", alpha=0.5, lw=0 + ) + ax_hyp.plot(sample_y_pred) + ax_hyp.set_ylim(-0.1, 1.1) + ax_hyp.set_xlim(0, len(sample_y)) + ax_hyp.get_xaxis().set_visible(False) + + plt.tight_layout() + + if isinstance(self.model.logger, TensorBoardLogger): + self.model.logger.experiment.add_figure( + f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch + ) + elif isinstance(self.model.logger, MLFlowLogger): + self.model.logger.experiment.log_figure( + run_id=self.model.logger.run_id, + figure=fig, + artifact_file=f"{self.logging_prefix}ValSamples_epoch{self.model.current_epoch}.png", + ) + + plt.close(fig) + def main(protocol: str, subset: str = "test", model: str = "pyannote/segmentation"): """Evaluate a segmentation model""" diff --git a/pyannote/audio/utils/permutation.py b/pyannote/audio/utils/permutation.py index 689f4759e..913379651 100644 --- a/pyannote/audio/utils/permutation.py +++ b/pyannote/audio/utils/permutation.py @@ -194,7 +194,7 @@ def build_permutation_graph( cost_func: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] = mae_cost_func, ) -> nx.Graph: """Build permutation graph - + Parameters ---------- segmentations : (num_chunks, num_frames, local_num_speakers)-shaped SlidingWindowFeature @@ -203,7 +203,7 @@ def build_permutation_graph( Threshold above which a speaker is considered active. Defaults to 0.5 cost_func : callable Cost function used to find the optimal bijective mapping between speaker activations - of two overlapping chunks. Expects two (num_frames, num_classes) torch.tensor as input + of two overlapping chunks. Expects two (num_frames, num_classes) torch.tensor as input and returns cost as a (num_classes, ) torch.tensor. Defaults to mae_cost_func. Returns diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py new file mode 100644 index 000000000..a41bf0570 --- /dev/null +++ b/pyannote/audio/utils/powerset.py @@ -0,0 +1,153 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - https://herve.niderb.fr +# Alexis PLAQUET + +try: + from functools import cached_property +except ImportError: + from backports.cached_property import cached_property + +from itertools import combinations + +import scipy.special +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class Powerset(nn.Module): + """Powerset to multilabel conversion, and back. + + Parameters + ---------- + num_classes : int + Number of regular classes. + max_set_size : int + Maximum number of classes in each set. + """ + + def __init__(self, num_classes: int, max_set_size: int): + super().__init__() + self.num_classes = num_classes + self.max_set_size = max_set_size + + mapping = self.build_mapping() + self.register_buffer("mapping", mapping, persistent=False) + + @cached_property + def num_powerset_classes(self) -> int: + # compute number of subsets of size at most "max_set_size" + # e.g. with num_classes = 3 and max_set_size = 2: + # {}, {0}, {1}, {2}, {0, 1}, {0, 2}, {1, 2} + return int( + sum( + scipy.special.binom(self.num_classes, i) + for i in range(0, self.max_set_size + 1) + ) + ) + + def build_mapping(self) -> torch.Tensor: + mapping = torch.zeros(self.num_powerset_classes, self.num_classes) + powerset_k = 0 + for set_size in range(0, self.max_set_size + 1): + for current_set in combinations(range(self.num_classes), set_size): + mapping[powerset_k, current_set] = 1 + powerset_k += 1 + + return mapping + + def to_multilabel(self, powerset: torch.Tensor) -> torch.Tensor: + """Convert (hard) predictions from powerset to multi-label + + Parameter + --------- + powerset : (batch_size, num_frames, num_powerset_classes) torch.Tensor + Hard predictions in "powerset" space. + + Returns + ------- + multi_label : (batch_size, num_frames, num_classes) torch.Tensor + Hard predictions in "multi-label" space. + + Note + ---- + This method will not complain if `powerset` is provided a soft predictions + (e.g. the output of a softmax-ed classifier). However, in that particular + case, the resulting soft multi-label output will not make much sense. + """ + return torch.matmul(powerset, self.mapping) + + def to_powerset(self, multilabel: torch.Tensor) -> torch.Tensor: + """Convert (hard) predictions from multi-label to powerset + + Parameter + --------- + multi_label : (batch_size, num_frames, num_classes) torch.Tensor + Prediction in "multi-label" space. + + Returns + ------- + powerset : (batch_size, num_frames, num_powerset_classes) torch.Tensor + Hard, one-hot prediction in "powerset" space. + + Note + ---- + This method will not complain if `multilabel` is provided a soft predictions + (e.g. the output of a sigmoid-ed classifier). However, in that particular + case, the resulting powerset output will most likely not make much sense. + """ + return F.one_hot( + torch.argmax(torch.matmul(multilabel, self.mapping.T), dim=-1), + num_classes=self.num_powerset_classes, + ) + + +if __name__ == "__main__": + + powerset = Powerset(3, 3) + print(powerset.mapping) + + # simulate a sequence where each frame is assigned to a different powerset class + one_sequence = [ + [0] * powerset.num_powerset_classes + for _ in range(powerset.num_powerset_classes) + ] + for i in range(powerset.num_powerset_classes): + one_sequence[i][i] = 1.0 + + # make a batch out of this sequence and the same sequence in reverse order + batch_powerset = torch.tensor([one_sequence, one_sequence[::-1]]) + print(batch_powerset) + print(batch_powerset.shape) + + # convert from powerset to multi-label + batch_multilabel = powerset.to_multilabel(batch_powerset) + print(batch_multilabel) + print(batch_multilabel.shape) + + # convert batch to powerset + reconstruction = powerset.to_powerset(batch_multilabel) + print(reconstruction) + print(reconstruction.shape) diff --git a/tests/io_test.py b/tests/io_test.py index 3729c37c4..a07ce7403 100644 --- a/tests/io_test.py +++ b/tests/io_test.py @@ -84,4 +84,3 @@ def test_can_crop_from_file_like(): assert isinstance(wav, Tensor) assert sr == 16000 assert wav.shape[1] == 0.5 * 16000 - diff --git a/tests/utils/test_powerset.py b/tests/utils/test_powerset.py new file mode 100644 index 000000000..dd12eed41 --- /dev/null +++ b/tests/utils/test_powerset.py @@ -0,0 +1,53 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +import torch + +from pyannote.audio.utils.powerset import Powerset + + +def test_roundtrip(): + + for num_classes in range(2, 5): + for max_set_size in range(1, num_classes + 1): + + powerset = Powerset(num_classes, max_set_size) + + # simulate a sequence where each frame is assigned to a different powerset class + one_sequence = [ + [0] * powerset.num_powerset_classes + for _ in range(powerset.num_powerset_classes) + ] + for i in range(powerset.num_powerset_classes): + one_sequence[i][i] = 1.0 + + # make a batch out of this sequence and the same sequence in reverse order + batch_powerset = torch.tensor([one_sequence, one_sequence[::-1]]) + + # convert from powerset to multi-label + batch_multilabel = powerset.to_multilabel(batch_powerset) + + # convert batch back to powerset + reconstruction = powerset.to_powerset(batch_multilabel) + + assert torch.equal(batch_powerset, reconstruction) From 2a4e3bf245260c4a7129064b4f2de26bf9d6e6de Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 20 Jan 2023 11:24:56 +0100 Subject: [PATCH 033/112] chore: remove main function that is already part of tests --- pyannote/audio/utils/powerset.py | 29 ----------------------------- 1 file changed, 29 deletions(-) diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index a41bf0570..e909ab4ee 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -122,32 +122,3 @@ def to_powerset(self, multilabel: torch.Tensor) -> torch.Tensor: torch.argmax(torch.matmul(multilabel, self.mapping.T), dim=-1), num_classes=self.num_powerset_classes, ) - - -if __name__ == "__main__": - - powerset = Powerset(3, 3) - print(powerset.mapping) - - # simulate a sequence where each frame is assigned to a different powerset class - one_sequence = [ - [0] * powerset.num_powerset_classes - for _ in range(powerset.num_powerset_classes) - ] - for i in range(powerset.num_powerset_classes): - one_sequence[i][i] = 1.0 - - # make a batch out of this sequence and the same sequence in reverse order - batch_powerset = torch.tensor([one_sequence, one_sequence[::-1]]) - print(batch_powerset) - print(batch_powerset.shape) - - # convert from powerset to multi-label - batch_multilabel = powerset.to_multilabel(batch_powerset) - print(batch_multilabel) - print(batch_multilabel.shape) - - # convert batch to powerset - reconstruction = powerset.to_powerset(batch_multilabel) - print(reconstruction) - print(reconstruction.shape) From cb7bfd5a4d7da6b2650537b8762a6fb18bf8e10c Mon Sep 17 00:00:00 2001 From: Ewald Enzinger Date: Fri, 20 Jan 2023 12:46:56 +0100 Subject: [PATCH 034/112] setup: switch to pytorch-lightning >= 1.8 (#1210) --- pyannote/audio/cli/train.py | 2 +- pyannote/audio/core/model.py | 2 +- pyannote/audio/pipelines/voice_activity_detection.py | 3 ++- requirements.txt | 2 +- tests/tasks/test_reproducibility.py | 8 ++++---- tutorials/training_a_model.ipynb | 8 ++++---- tutorials/voice_activity_detection.ipynb | 2 +- 7 files changed, 14 insertions(+), 13 deletions(-) diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index 6e04fcde5..825d7f8ae 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -37,7 +37,7 @@ RichProgressBar, ) from pytorch_lightning.loggers import TensorBoardLogger -from pytorch_lightning.utilities.seed import seed_everything +from lightning_lite.utilities.seed import seed_everything from torch_audiomentations.utils.config import from_dict as get_augmentation from pyannote.audio.core.io import get_torchaudio_info diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 2a49360b9..000b469b6 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -36,7 +36,7 @@ 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 lightning_lite.utilities.cloud_io import _load as pl_load from pytorch_lightning.utilities.model_summary import ModelSummary from semver import VersionInfo from torch.utils.data import DataLoader diff --git a/pyannote/audio/pipelines/voice_activity_detection.py b/pyannote/audio/pipelines/voice_activity_detection.py index 4328e1cbf..0edbea42f 100644 --- a/pyannote/audio/pipelines/voice_activity_detection.py +++ b/pyannote/audio/pipelines/voice_activity_detection.py @@ -346,7 +346,8 @@ def configure_optimizers(model): with tempfile.TemporaryDirectory() as default_root_dir: trainer = Trainer( max_epochs=self.num_epochs, - gpus=1, + accelerator="gpu", + devices=1, callbacks=[GraduallyUnfreeze(epochs_per_stage=self.num_epochs + 1)], enable_checkpointing=False, default_root_dir=default_root_dir, diff --git a/requirements.txt b/requirements.txt index df2e9c1d6..b2d000a27 100644 --- a/requirements.txt +++ b/requirements.txt @@ -9,7 +9,7 @@ pyannote.core >=4.4,<5.0 pyannote.database >=4.1.1,<5.0 pyannote.metrics >=3.2,<4.0 pyannote.pipeline >=2.3,<3.0 -pytorch_lightning >=1.5.4,<1.7 +pytorch_lightning >=1.8.0,<1.9 pytorch_metric_learning >=1.0.0,<2.0 rich >= 12.0.0 semver >=2.10.2,<3.0 diff --git a/tests/tasks/test_reproducibility.py b/tests/tasks/test_reproducibility.py index 39a950464..912548827 100644 --- a/tests/tasks/test_reproducibility.py +++ b/tests/tasks/test_reproducibility.py @@ -1,4 +1,4 @@ -import pytorch_lightning as pl +from lightning_lite.utilities.seed import seed_everything import torch from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel @@ -30,7 +30,7 @@ def get_next5(dl): def test_seeding_ensures_data_loaders(): "Setting a global seed for the dataloaders ensures that we get data back in the same order" - pl.seed_everything(1) + seed_everything(1) for task in [VoiceActivityDetection, MultiLabelSegmentation]: protocol, vad = setup_tasks(task) @@ -50,12 +50,12 @@ def test_different_seeds(): for task in [VoiceActivityDetection, MultiLabelSegmentation]: protocol, vad = setup_tasks(task) - pl.seed_everything(4) + seed_everything(4) dl = create_dl(SimpleSegmentationModel, vad) last5a = get_next5(dl) protocol, vad = setup_tasks(task) - pl.seed_everything(5) + seed_everything(5) dl = create_dl(SimpleSegmentationModel, vad) last5b = get_next5(dl) diff --git a/tutorials/training_a_model.ipynb b/tutorials/training_a_model.ipynb index 167a48c9a..f062bd95d 100644 --- a/tutorials/training_a_model.ipynb +++ b/tutorials/training_a_model.ipynb @@ -180,7 +180,7 @@ ], "source": [ "import pytorch_lightning as pl\n", - "trainer = pl.Trainer(gpus=1, max_epochs=1)\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\", max_epochs=1)\n", "trainer.fit(vad_model)" ] }, @@ -545,7 +545,7 @@ } ], "source": [ - "trainer = pl.Trainer(gpus=1, max_epochs=1)\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\", max_epochs=1)\n", "trainer.fit(finetuned)" ] }, @@ -781,7 +781,7 @@ } ], "source": [ - "trainer = pl.Trainer(gpus=1, max_epochs=1)\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\", max_epochs=1)\n", "trainer.fit(osd_model)" ] }, @@ -854,7 +854,7 @@ "We also benefit from all the nice things [`pytorch-lightning`](ttps://pytorch-lightning.readthedocs.io) has to offer (like multi-gpu training, for instance).\n", "\n", "```python\n", - "trainer = Trainer(gpus=4, strategy='ddp')\n", + "trainer = Trainer(devices=4, accelerator=\"gpu\", strategy='ddp')\n", "trainer.fit(model)\n", "```\n", "\n", diff --git a/tutorials/voice_activity_detection.ipynb b/tutorials/voice_activity_detection.ipynb index 1b80bd391..df2cadd15 100644 --- a/tutorials/voice_activity_detection.ipynb +++ b/tutorials/voice_activity_detection.ipynb @@ -273,7 +273,7 @@ ], "source": [ "import pytorch_lightning as pl\n", - "trainer = pl.Trainer(gpus=1, max_epochs=2)\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\", max_epochs=2)\n", "trainer.fit(model)" ] }, From 46563825f180678c180196649a828a01de505b4d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 20 Jan 2023 14:06:23 +0100 Subject: [PATCH 035/112] feat(cli): add "registry" option to training CLI --- pyannote/audio/cli/train.py | 8 ++++++-- pyannote/audio/cli/train_config/config.yaml | 1 + 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index 6e04fcde5..89aa9373f 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -29,7 +29,7 @@ from omegaconf import DictConfig, OmegaConf # from pyannote.audio.core.callback import GraduallyUnfreeze -from pyannote.database import FileFinder, get_protocol +from pyannote.database import FileFinder, registry from pytorch_lightning.callbacks import ( EarlyStopping, LearningRateMonitor, @@ -51,12 +51,16 @@ def train(cfg: DictConfig) -> Optional[float]: seed = int(os.environ.get("PL_GLOBAL_SEED", "0")) seed_everything(seed=seed) + # load databases into registry + for database_yml in cfg.registry.split(","): + registry.load_database(database_yml) + # instantiate training protocol with optional preprocessors preprocessors = {"audio": FileFinder(), "torchaudio.info": get_torchaudio_info} if "preprocessor" in cfg: preprocessor = instantiate(cfg.preprocessor) preprocessors[preprocessor.preprocessed_key] = preprocessor - protocol = get_protocol(cfg.protocol, preprocessors=preprocessors) + protocol = registry.get_protocol(cfg.protocol, preprocessors=preprocessors) # instantiate data augmentation augmentation = ( diff --git a/pyannote/audio/cli/train_config/config.yaml b/pyannote/audio/cli/train_config/config.yaml index f939f39e1..380ed9213 100644 --- a/pyannote/audio/cli/train_config/config.yaml +++ b/pyannote/audio/cli/train_config/config.yaml @@ -1,3 +1,4 @@ +registry: ??? protocol: ??? defaults: From 67aa7f02363481526c40fbe508ab7abc92a0ddf9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 20 Jan 2023 14:11:44 +0100 Subject: [PATCH 036/112] fix(cli): remove loss/vad_loss default options --- pyannote/audio/cli/train_config/task/SpeakerSegmentation.yaml | 2 -- 1 file changed, 2 deletions(-) diff --git a/pyannote/audio/cli/train_config/task/SpeakerSegmentation.yaml b/pyannote/audio/cli/train_config/task/SpeakerSegmentation.yaml index b7b6bdc02..fcfa06978 100644 --- a/pyannote/audio/cli/train_config/task/SpeakerSegmentation.yaml +++ b/pyannote/audio/cli/train_config/task/SpeakerSegmentation.yaml @@ -7,5 +7,3 @@ weight: null batch_size: 32 num_workers: null pin_memory: False -loss: "bce" -vad_loss: "bce" From 8f6af1b5de93833a65a80d3f2c02b0c66b0e43ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 20 Jan 2023 14:27:11 +0100 Subject: [PATCH 037/112] fix(cli): fix default trainer options --- .../audio/cli/train_config/trainer/default.yaml | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/pyannote/audio/cli/train_config/trainer/default.yaml b/pyannote/audio/cli/train_config/trainer/default.yaml index eeb5b85b9..7f289c865 100644 --- a/pyannote/audio/cli/train_config/trainer/default.yaml +++ b/pyannote/audio/cli/train_config/trainer/default.yaml @@ -2,23 +2,19 @@ _target_: pytorch_lightning.Trainer accelerator: auto accumulate_grad_batches: 1 -amp_backend: native -auto_lr_find: False auto_scale_batch_size: False -auto_select_gpus: True +auto_lr_find: False benchmark: False -check_val_every_n_epoch: 1 -detect_anomaly: False deterministic: False +check_val_every_n_epoch: 1 devices: auto +detect_anomaly: False enable_checkpointing: True enable_model_summary: True enable_progress_bar: True fast_dev_run: False -gpus: null gradient_clip_val: 0 gradient_clip_algorithm: norm -ipus: null limit_predict_batches: 1.0 limit_test_batches: 1.0 limit_train_batches: 1.0 @@ -32,7 +28,6 @@ min_steps: null move_metrics_to_cpu: False multiple_trainloader_mode: max_size_cycle num_nodes: 1 -num_processes: 1 num_sanity_val_steps: 2 overfit_batches: 0.0 precision: 32 @@ -41,7 +36,5 @@ reload_dataloaders_every_n_epochs: 0 replace_sampler_ddp: True strategy: null sync_batchnorm: False -tpu_cores: null track_grad_norm: -1 val_check_interval: 1.0 -weights_save_path: null From f93fe71a8800420158d79c0447c851c2196f8275 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 20 Jan 2023 14:50:52 +0100 Subject: [PATCH 038/112] fix(cli): fix default trainer config --- pyannote/audio/cli/train_config/trainer/default.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/cli/train_config/trainer/default.yaml b/pyannote/audio/cli/train_config/trainer/default.yaml index 7f289c865..fee078690 100644 --- a/pyannote/audio/cli/train_config/trainer/default.yaml +++ b/pyannote/audio/cli/train_config/trainer/default.yaml @@ -21,7 +21,7 @@ limit_train_batches: 1.0 limit_val_batches: 1.0 log_every_n_steps: 50 max_epochs: 1000 -max_steps: null +max_steps: -1 max_time: null min_epochs: 1 min_steps: null From 2dd9af0e6a83ce36a9118886d7a7674f9707db58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 24 Jan 2023 08:58:24 +0100 Subject: [PATCH 039/112] BREAKING: monitor validation loss instead of DER --- .../audio/tasks/segmentation/segmentation.py | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/pyannote/audio/tasks/segmentation/segmentation.py b/pyannote/audio/tasks/segmentation/segmentation.py index 6dc68a44a..b4deec3c4 100644 --- a/pyannote/audio/tasks/segmentation/segmentation.py +++ b/pyannote/audio/tasks/segmentation/segmentation.py @@ -712,6 +712,27 @@ def validation_step(self, batch, batch_idx: int): plt.close(fig) + @property + def val_monitor(self): + """Quantity (and direction) to monitor + + Useful for model checkpointing or early stopping. + + Returns + ------- + monitor : str + Name of quantity to monitor (validation loss) + mode : {'min', 'max} + Minimize + + See also + -------- + pytorch_lightning.callbacks.ModelCheckpoint + pytorch_lightning.callbacks.EarlyStopping + """ + + return f"{self.logging_prefix}ValLoss", "min" + def main(protocol: str, subset: str = "test", model: str = "pyannote/segmentation"): """Evaluate a segmentation model""" From 952e1507fa597c052bd6216ef5028ecee62893f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 24 Jan 2023 21:50:41 +0100 Subject: [PATCH 040/112] BREAKING: fix random seed generation Make sure that multiple nodes use different seeds. --- pyannote/audio/utils/random.py | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/pyannote/audio/utils/random.py b/pyannote/audio/utils/random.py index c3173dbd1..97d50c362 100644 --- a/pyannote/audio/utils/random.py +++ b/pyannote/audio/utils/random.py @@ -48,26 +48,14 @@ def create_rng_for_worker(epoch: int) -> Random: global_seed = int(os.environ.get("PL_GLOBAL_SEED", "0")) local_rank = int(os.environ.get("LOCAL_RANK", "0")) node_rank = int(os.environ.get("NODE_RANK", "0")) - num_gpus = len(os.environ.get("PL_TRAINER_GPUS", "0").split(",")) - world_size = int(os.environ.get("WORLD_SIZE", "1")) worker_info = torch.utils.data.get_worker_info() if worker_info is None: - num_workers = 1 worker_id = 0 else: - num_workers = worker_info.num_workers worker_id = worker_info.id - seed = ( - global_seed - + worker_id - + local_rank * num_workers - + node_rank * num_workers * num_gpus - + epoch * num_workers * world_size - ) - - rng.seed(seed) + rng.seed(hash((global_seed, worker_id, local_rank, node_rank, epoch))) return rng From 5db4783c751c6f0f0e1a4cebac9dd5901f61377a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 24 Jan 2023 21:59:45 +0100 Subject: [PATCH 041/112] fix: fix corner case with non-speech batch (#1239) --- pyannote/audio/tasks/segmentation/mixins.py | 15 +++++++++------ pyannote/audio/tasks/segmentation/segmentation.py | 4 ++-- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index d0f63d2c2..50f33a423 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -296,14 +296,17 @@ def collate_y(self, batch) -> torch.Tensor: # gather common set of labels # b["y"] is a SlidingWindowFeature instance labels = sorted(set(itertools.chain(*(b["y"].labels for b in batch)))) + num_labels = len(labels) - batch_size, num_frames, num_labels = ( - len(batch), - len(batch[0]["y"]), - len(labels), - ) - Y = np.zeros((batch_size, num_frames, num_labels), dtype=np.int64) + batch_size = len(batch) + num_frames = len(batch[0]["y"]) + if num_labels == 0: + return torch.from_numpy( + np.zeros((batch_size, num_frames, 1), dtype=np.int64) + ) + + Y = np.zeros((batch_size, num_frames, num_labels), dtype=np.int64) for i, b in enumerate(batch): for local_idx, label in enumerate(b["y"].labels): global_idx = labels.index(label) diff --git a/pyannote/audio/tasks/segmentation/segmentation.py b/pyannote/audio/tasks/segmentation/segmentation.py index b4deec3c4..5d791589b 100644 --- a/pyannote/audio/tasks/segmentation/segmentation.py +++ b/pyannote/audio/tasks/segmentation/segmentation.py @@ -250,8 +250,8 @@ def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor: batch_size, num_frames, num_speakers = collated_y.shape # maximum number of active speakers in a chunk - max_speakers_per_chunk = torch.max( - torch.sum(torch.sum(collated_y, dim=1) > 0.0, dim=1) + max_speakers_per_chunk = max( + 1, torch.max(torch.sum(torch.sum(collated_y, dim=1) > 0.0, dim=1)) ) # sort speakers in descending talkativeness order From c7325884d8d1ab5ea58a5fcebbfeabf20d909808 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 26 Jan 2023 09:54:35 +0100 Subject: [PATCH 042/112] fix: add missing collate function (#1241) --- pyannote/audio/tasks/embedding/mixins.py | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index 700008cb1..c7a88c7f7 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -30,6 +30,7 @@ SpeakerDiarizationProtocol, SpeakerVerificationProtocol, ) +from torch.utils.data._utils.collate import default_collate from torchmetrics import Metric from torchmetrics.classification import BinaryAUROC from tqdm import tqdm @@ -217,6 +218,29 @@ def train__len__(self): avg_chunk_duration = 0.5 * (self.min_duration + self.duration) return max(self.batch_size, math.ceil(duration / avg_chunk_duration)) + def collate_X(self, batch) -> torch.Tensor: + return default_collate([b["X"] for b in batch]) + + def collate_y(self, batch) -> torch.Tensor: + return default_collate([b["y"] for b in batch]) + + def collate_fn(self, batch, stage="train"): + + # collate X + collated_X = self.collate_X(batch) + + # collate y + collated_y = self.collate_y(batch) + + # apply augmentation (only in "train" stage) + self.augmentation.train(mode=(stage == "train")) + augmented = self.augmentation( + samples=collated_X, + sample_rate=self.model.hparams.sample_rate, + ) + + return {"X": augmented.samples, "y": collated_y} + def training_step(self, batch, batch_idx: int): X, y = batch["X"], batch["y"] From bce740f0b8b11579ebdf0a111544d09ea9df6879 Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Mon, 30 Jan 2023 10:45:56 +0100 Subject: [PATCH 043/112] fix: fix support for multiple loggers (#1244) --- pyannote/audio/tasks/segmentation/mixins.py | 21 ++++++++++--------- .../audio/tasks/segmentation/segmentation.py | 21 ++++++++++--------- 2 files changed, 22 insertions(+), 20 deletions(-) diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 50f33a423..b9056d052 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -492,15 +492,16 @@ def validation_step(self, batch, batch_idx: int): plt.tight_layout() - if isinstance(self.model.logger, TensorBoardLogger): - self.model.logger.experiment.add_figure( - f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch - ) - elif isinstance(self.model.logger, MLFlowLogger): - self.model.logger.experiment.log_figure( - run_id=self.model.logger.run_id, - figure=fig, - artifact_file=f"{self.logging_prefix}ValSamples_epoch{self.model.current_epoch}.png", - ) + for logger in self.model.loggers: + if isinstance(logger, TensorBoardLogger): + logger.experiment.add_figure( + f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch + ) + elif isinstance(logger, MLFlowLogger): + logger.experiment.log_figure( + run_id=logger.run_id, + figure=fig, + artifact_file=f"{self.logging_prefix}ValSamples_epoch{self.model.current_epoch}.png", + ) plt.close(fig) diff --git a/pyannote/audio/tasks/segmentation/segmentation.py b/pyannote/audio/tasks/segmentation/segmentation.py index 5d791589b..a7e6c4b3f 100644 --- a/pyannote/audio/tasks/segmentation/segmentation.py +++ b/pyannote/audio/tasks/segmentation/segmentation.py @@ -699,16 +699,17 @@ def validation_step(self, batch, batch_idx: int): plt.tight_layout() - if isinstance(self.model.logger, TensorBoardLogger): - self.model.logger.experiment.add_figure( - f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch - ) - elif isinstance(self.model.logger, MLFlowLogger): - self.model.logger.experiment.log_figure( - run_id=self.model.logger.run_id, - figure=fig, - artifact_file=f"{self.logging_prefix}ValSamples_epoch{self.model.current_epoch}.png", - ) + for logger in self.model.loggers: + if isinstance(logger, TensorBoardLogger): + logger.experiment.add_figure( + f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch + ) + elif isinstance(logger, MLFlowLogger): + logger.experiment.log_figure( + run_id=logger.run_id, + figure=fig, + artifact_file=f"{self.logging_prefix}ValSamples_epoch{self.model.current_epoch}.png", + ) plt.close(fig) From 559a34a6ad8e099ece78db077fb53a2ea408f8bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 30 Jan 2023 11:06:51 +0100 Subject: [PATCH 044/112] fix: fix embedding validation step (#1245) --- pyannote/audio/tasks/embedding/mixins.py | 34 +++++++++--------------- 1 file changed, 13 insertions(+), 21 deletions(-) diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index c7a88c7f7..08721eb24 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -79,6 +79,9 @@ def setup(self, stage: Optional[str] = None): # loop over the training set, remove annotated regions shorter than # chunk duration, and keep track of the reference annotations, per class. + # FIXME: it looks like this time consuming step is called multiple times. + # it should not be... + self._train = dict() desc = f"Loading {self.protocol.name} training labels" @@ -218,28 +221,19 @@ def train__len__(self): avg_chunk_duration = 0.5 * (self.min_duration + self.duration) return max(self.batch_size, math.ceil(duration / avg_chunk_duration)) - def collate_X(self, batch) -> torch.Tensor: - return default_collate([b["X"] for b in batch]) - - def collate_y(self, batch) -> torch.Tensor: - return default_collate([b["y"] for b in batch]) - def collate_fn(self, batch, stage="train"): - # collate X - collated_X = self.collate_X(batch) + collated = default_collate(batch) - # collate y - collated_y = self.collate_y(batch) - - # apply augmentation (only in "train" stage) - self.augmentation.train(mode=(stage == "train")) - augmented = self.augmentation( - samples=collated_X, - sample_rate=self.model.hparams.sample_rate, - ) + if stage == "train": + self.augmentation.train(mode=True) + augmented = self.augmentation( + samples=collated["X"], + sample_rate=self.model.hparams.sample_rate, + ) + collated["X"] = augmented.samples - return {"X": augmented.samples, "y": collated_y} + return collated def training_step(self, batch, batch_idx: int): @@ -257,6 +251,7 @@ def training_step(self, batch, batch_idx: int): return {"loss": loss} def val__getitem__(self, idx): + if isinstance(self.protocol, SpeakerVerificationProtocol): trial = self._validation[idx] @@ -312,6 +307,3 @@ def validation_step(self, batch, batch_idx: int): prog_bar=True, logger=True, ) - - elif isinstance(self.protocol, SpeakerDiarizationProtocol): - pass From 9f790f27f6398692c199747355007d47ce78841d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 30 Jan 2023 16:52:20 +0100 Subject: [PATCH 045/112] feat: validate speaker embedding with new EqualErrorRate metric --- pyannote/audio/tasks/embedding/mixins.py | 7 ++- .../torchmetrics/classification/__init__.py | 28 ++++++++++ .../classification/equal_error_rate.py | 52 +++++++++++++++++++ 3 files changed, 86 insertions(+), 1 deletion(-) create mode 100644 pyannote/audio/torchmetrics/classification/__init__.py create mode 100644 pyannote/audio/torchmetrics/classification/equal_error_rate.py diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index 08721eb24..2178bb2a7 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -36,6 +36,7 @@ from tqdm import tqdm from pyannote.audio.core.task import Problem, Resolution, Specifications +from pyannote.audio.torchmetrics.classification import EqualErrorRate from pyannote.audio.utils.random import create_rng_for_worker @@ -132,7 +133,11 @@ def setup(self, stage: Optional[str] = None): def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: - return BinaryAUROC(compute_on_cpu=True) + + return [ + EqualErrorRate(compute_on_cpu=True, distances=False), + BinaryAUROC(compute_on_cpu=True), + ] def train__iter__(self): """Iterate over training samples diff --git a/pyannote/audio/torchmetrics/classification/__init__.py b/pyannote/audio/torchmetrics/classification/__init__.py new file mode 100644 index 000000000..078522434 --- /dev/null +++ b/pyannote/audio/torchmetrics/classification/__init__.py @@ -0,0 +1,28 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +from .equal_error_rate import EqualErrorRate + +__all__ = [ + "EqualErrorRate", +] diff --git a/pyannote/audio/torchmetrics/classification/equal_error_rate.py b/pyannote/audio/torchmetrics/classification/equal_error_rate.py new file mode 100644 index 000000000..f1daf0c10 --- /dev/null +++ b/pyannote/audio/torchmetrics/classification/equal_error_rate.py @@ -0,0 +1,52 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +from typing import Optional + +import torch +from pyannote.metrics.binary_classification import det_curve +from torchmetrics import Metric +from torchmetrics.utilities.data import dim_zero_cat + + +class EqualErrorRate(Metric): + + is_differentiable: Optional[bool] = False + higher_is_better: Optional[bool] = False + full_state_update: bool = True + + def __init__(self, distances: bool = True, compute_on_cpu: bool = True, **kwargs): + super().__init__(compute_on_cpu=compute_on_cpu, **kwargs) + self.distances = distances + self.add_state("scores", default=[], dist_reduce_fx="cat") + self.add_state("y_true", default=[], dist_reduce_fx="cat") + + def update(self, scores: torch.Tensor, y_true: torch.Tensor) -> None: + self.scores.append(scores) + self.y_true.append(y_true) + + def compute(self) -> torch.Tensor: + scores = dim_zero_cat(self.scores) + y_true = dim_zero_cat(self.y_true) + _, _, _, eer = det_curve(y_true.cpu(), scores.cpu(), distances=self.distances) + return torch.tensor(eer) From 856178a508ba5ab9b5f778882ef6c0dfadb07539 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 1 Feb 2023 11:25:50 +0100 Subject: [PATCH 046/112] fix(pipeline): fix corner case where global number of speakers is smaller than frame-wise one --- pyannote/audio/pipelines/utils/diarization.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/pyannote/audio/pipelines/utils/diarization.py b/pyannote/audio/pipelines/utils/diarization.py index 2ac783439..de07524e6 100644 --- a/pyannote/audio/pipelines/utils/diarization.py +++ b/pyannote/audio/pipelines/utils/diarization.py @@ -211,9 +211,14 @@ def to_diarization( missing=0.0, skip_average=True, ) + # shape is (num_frames, num_speakers) _, num_speakers = activations.data.shape - count.data = np.minimum(count.data, num_speakers) + max_speakers_per_frame = np.max(count.data) + if num_speakers < max_speakers_per_frame: + activations.data = np.pad( + activations.data, ((0, 0), (0, max_speakers_per_frame - num_speakers)) + ) extent = activations.extent & count.extent activations = activations.crop(extent, return_data=False) From 38d58e8631b491e5afd93e3884f7933b9eba0bcd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 8 Feb 2023 09:29:44 +0100 Subject: [PATCH 047/112] github: add suggest-related-links bot --- .github/workflows/suggest-related-links.yml | 33 +++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 .github/workflows/suggest-related-links.yml diff --git a/.github/workflows/suggest-related-links.yml b/.github/workflows/suggest-related-links.yml new file mode 100644 index 000000000..5caf2aaf3 --- /dev/null +++ b/.github/workflows/suggest-related-links.yml @@ -0,0 +1,33 @@ +name: 'Suggest Related Links' + +on: + issues: + types: + - opened + - edited + workflow_dispatch: + schedule: + - cron: '13 13 * * */7' + +jobs: + action: + runs-on: ubuntu-18.04 + steps: + - name: Cache dependencies + uses: actions/cache@v2 + with: + path: ~/actions-suggest-related-links-tmp + key: ${{ runner.os }}-action-${{ hashFiles('~/actions-suggest-related-links-tmp/training-data.json') }} + restore-keys: | + ${{ runner.os }}-action- + + - uses: peaceiris/actions-suggest-related-links@v1.1.1 + - uses: peaceiris/actions-suggest-related-links/models/fasttext@v1.1.1 + if: github.event_name == 'issues' + with: + version: v1.1.1 + - uses: peaceiris/actions-suggest-related-links@v1.1.1 + with: + mode: 'suggest' + repository: 'peaceiris/actions-gh-pages' + unclickable: true From 6dab9043b64cd41635e9f5d65e9a882da77eba99 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 8 Feb 2023 09:34:43 +0100 Subject: [PATCH 048/112] Delete suggest-related-links.yml --- .github/workflows/suggest-related-links.yml | 33 --------------------- 1 file changed, 33 deletions(-) delete mode 100644 .github/workflows/suggest-related-links.yml diff --git a/.github/workflows/suggest-related-links.yml b/.github/workflows/suggest-related-links.yml deleted file mode 100644 index 5caf2aaf3..000000000 --- a/.github/workflows/suggest-related-links.yml +++ /dev/null @@ -1,33 +0,0 @@ -name: 'Suggest Related Links' - -on: - issues: - types: - - opened - - edited - workflow_dispatch: - schedule: - - cron: '13 13 * * */7' - -jobs: - action: - runs-on: ubuntu-18.04 - steps: - - name: Cache dependencies - uses: actions/cache@v2 - with: - path: ~/actions-suggest-related-links-tmp - key: ${{ runner.os }}-action-${{ hashFiles('~/actions-suggest-related-links-tmp/training-data.json') }} - restore-keys: | - ${{ runner.os }}-action- - - - uses: peaceiris/actions-suggest-related-links@v1.1.1 - - uses: peaceiris/actions-suggest-related-links/models/fasttext@v1.1.1 - if: github.event_name == 'issues' - with: - version: v1.1.1 - - uses: peaceiris/actions-suggest-related-links@v1.1.1 - with: - mode: 'suggest' - repository: 'peaceiris/actions-gh-pages' - unclickable: true From 1f83e0b867e5b9e0221e238e7955b7d6fc4ea967 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 13 Feb 2023 10:34:11 +0100 Subject: [PATCH 049/112] feat: add `weigh_by_cardinality` option (#1256) --- .../audio/tasks/segmentation/segmentation.py | 20 ++++++++++++++++++- pyannote/audio/utils/loss.py | 9 ++++++++- pyannote/audio/utils/powerset.py | 14 +++++++++++-- 3 files changed, 39 insertions(+), 4 deletions(-) diff --git a/pyannote/audio/tasks/segmentation/segmentation.py b/pyannote/audio/tasks/segmentation/segmentation.py index a7e6c4b3f..976b5d376 100644 --- a/pyannote/audio/tasks/segmentation/segmentation.py +++ b/pyannote/audio/tasks/segmentation/segmentation.py @@ -69,6 +69,12 @@ class Segmentation(SegmentationTaskMixin, Task): Maximum number of (overlapping) speakers per frame. Setting this value to 1 or more enables `powerset multi-class` training. Default behavior is to use `multi-label` training. + weigh_by_cardinality: bool, optional + Weigh each powerset classes by the size of the corresponding speaker set. + In other words, {0, 1} powerset class weight is 2x bigger than that of {0} + or {1} powerset classes. Note that empty (non-speech) powerset class is + assigned the same weight as mono-speaker classes. Defaults to False (i.e. use + same weight for every class). Has no effect with `multi-label` training. warm_up : float or (float, float), optional Use that many seconds on the left- and rightmost parts of each chunk to warm up the model. While the model does process those left- and right-most @@ -119,6 +125,7 @@ def __init__( duration: float = 2.0, max_speakers_per_chunk: int = None, max_speakers_per_frame: int = None, + weigh_by_cardinality: bool = False, warm_up: Union[float, Tuple[float, float]] = 0.0, balance: Text = None, weight: Text = None, @@ -165,6 +172,7 @@ def __init__( self.max_speakers_per_chunk = max_speakers_per_chunk self.max_speakers_per_frame = max_speakers_per_frame + self.weigh_by_cardinality = weigh_by_cardinality self.balance = balance self.weight = weight self.vad_loss = vad_loss @@ -291,8 +299,18 @@ def segmentation_loss( """ if self.specifications.powerset: + + # `clamp_min` is needed to set non-speech weight to 1. + class_weight = ( + torch.clamp_min(self.model.powerset.cardinality, 1.0) + if self.weigh_by_cardinality + else None + ) seg_loss = nll_loss( - permutated_prediction, torch.argmax(target, dim=-1), weight=weight + permutated_prediction, + torch.argmax(target, dim=-1), + class_weight=class_weight, + weight=weight, ) else: seg_loss = binary_cross_entropy( diff --git a/pyannote/audio/utils/loss.py b/pyannote/audio/utils/loss.py index c8f37f3f0..2c55b26f3 100644 --- a/pyannote/audio/utils/loss.py +++ b/pyannote/audio/utils/loss.py @@ -129,7 +129,10 @@ def mse_loss( def nll_loss( - prediction: torch.Tensor, target: torch.Tensor, weight: torch.Tensor = None + prediction: torch.Tensor, + target: torch.Tensor, + class_weight: torch.Tensor = None, + weight: torch.Tensor = None, ) -> torch.Tensor: """Frame-weighted negative log-likelihood loss @@ -139,6 +142,8 @@ def nll_loss( Prediction with shape (batch_size, num_frames, num_classes). target : torch.Tensor Target with shape (batch_size, num_frames) + class_weight : (num_classes, ) torch.Tensor, optional + Class weight with shape (num_classes, ) weight : (batch_size, num_frames, 1) torch.Tensor, optional Frame weight with shape (batch_size, num_frames, 1). @@ -154,6 +159,8 @@ def nll_loss( # (batch_size x num_frames, num_classes) target.view(-1), # (batch_size x num_frames, ) + weight=class_weight, + # (num_classes, ) reduction="none", ).view(target.shape) # (batch_size, num_frames) diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index e909ab4ee..f206b65bf 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -53,8 +53,8 @@ def __init__(self, num_classes: int, max_set_size: int): self.num_classes = num_classes self.max_set_size = max_set_size - mapping = self.build_mapping() - self.register_buffer("mapping", mapping, persistent=False) + self.register_buffer("mapping", self.build_mapping(), persistent=False) + self.register_buffer("cardinality", self.build_cardinality(), persistent=False) @cached_property def num_powerset_classes(self) -> int: @@ -78,6 +78,16 @@ def build_mapping(self) -> torch.Tensor: return mapping + def build_cardinality(self) -> torch.Tensor: + """Compute size of each powerset class""" + cardinality = torch.zeros(self.num_powerset_classes) + powerset_k = 0 + for set_size in range(0, self.max_set_size + 1): + for _ in combinations(range(self.num_classes), set_size): + cardinality[powerset_k] = set_size + powerset_k += 1 + return cardinality + def to_multilabel(self, powerset: torch.Tensor) -> torch.Tensor: """Convert (hard) predictions from powerset to multi-label From 733cb433ab6c945adc07372396da9a8528f887b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Feb 2023 13:49:41 +0100 Subject: [PATCH 050/112] =?UTF-8?q?Cr=C3=A9=C3=A9=20avec=20Colaboratory?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tutorials/intro.ipynb | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index 3f9489aae..d5579541e 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "id": "ai082p4HYnp7", "outputId": "bb673846-8b58-4743-cea2-6c6270632d7f", @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "id": "uJWoQiJgYnp8" }, @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "id": "Mmm0Q22JYnp8" }, @@ -160,7 +160,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "id": "ToqCwl_FYnp9", "outputId": "a1d9631f-b198-44d1-ff6d-ec304125a9f4", @@ -202,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "id": "bAHza4Y1Ynp-", "outputId": "c4cc2369-bfe4-4ac2-bb71-37602e7c7a8a", @@ -245,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "id": "rDhZ3bXEYnp-", "outputId": "a82efe4e-2f9c-48bd-94fb-c62af3a3cb43", @@ -461,13 +461,14 @@ "\n", "To load the speaker diarization pipeline, \n", "\n", - "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization).\n", + "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization)\n", + "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/segmentation)\n", "* login using `notebook_login` below" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "id": "r5u7VMb-YnqB", "outputId": "c714a997-d4f8-417a-e5ad-0a4924333859", @@ -509,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { "id": "lUq1UvoJYnqB", "outputId": "8c052808-d0b2-4f2e-8771-f86114ae3fe3", @@ -739,7 +740,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "id": "DPosdyGrYnqB", "outputId": "45a2315e-6841-4de4-e54e-1f3da7cf2d46", @@ -778,7 +779,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "id": "vNHQRTUIYnqB" }, @@ -791,7 +792,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "id": "9d0vKQ0fYnqB", "outputId": "9a664753-cd84-4211-9153-d33e929bb252", @@ -825,7 +826,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "id": "xMLf4mrYYnqB", "outputId": "ed08bcc8-24c6-439c-a244-3a673ff480b0", @@ -854,7 +855,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "id": "Z0ewsLlQYnqB", "outputId": "8a8cd040-ee1d-48f7-d4be-eef9e08e9e55", From b3385ff709ffb0e337b65205de1bd9eed0c0227f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Feb 2023 13:54:52 +0100 Subject: [PATCH 051/112] doc: remove duplicate Colab badge --- tutorials/intro.ipynb | 2371 ++++++++++++++++++++--------------------- 1 file changed, 1180 insertions(+), 1191 deletions(-) diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index d5579541e..f5decb153 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -1,15 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, { "cell_type": "markdown", "metadata": { @@ -49,59 +39,16 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "ai082p4HYnp7", - "outputId": "bb673846-8b58-4743-cea2-6c6270632d7f", "colab": { "base_uri": "https://localhost:8080/" + }, + "id": "ai082p4HYnp7", + "outputId": "bb673846-8b58-4743-cea2-6c6270632d7f", + "vscode": { + "languageId": "python" } }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[K |████████████████████████████████| 750.6 MB 10 kB/s \n", - "\u001b[K |████████████████████████████████| 21.0 MB 1.3 MB/s \n", - "\u001b[K |████████████████████████████████| 2.9 MB 55.5 MB/s \n", - "\u001b[K |████████████████████████████████| 10.4 MB 46.0 MB/s \n", - "\u001b[K |████████████████████████████████| 496 kB 25.8 MB/s \n", - "\u001b[K |████████████████████████████████| 1.3 MB 60.6 MB/s \n", - "\u001b[K |████████████████████████████████| 163 kB 70.7 MB/s \n", - "\u001b[K |████████████████████████████████| 109 kB 74.9 MB/s \n", - "\u001b[K |████████████████████████████████| 500 kB 62.8 MB/s \n", - "\u001b[?25h Building wheel for hyperpyyaml (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "\u001b[K |████████████████████████████████| 390 kB 37.8 MB/s \n", - "\u001b[K |████████████████████████████████| 217 kB 67.2 MB/s \n", - "\u001b[K |████████████████████████████████| 111 kB 75.6 MB/s \n", - "\u001b[K |████████████████████████████████| 529 kB 61.5 MB/s \n", - "\u001b[K |████████████████████████████████| 41 kB 494 kB/s \n", - "\u001b[K |████████████████████████████████| 47 kB 5.5 MB/s \n", - "\u001b[K |████████████████████████████████| 585 kB 62.0 MB/s \n", - "\u001b[K |████████████████████████████████| 60 kB 8.4 MB/s \n", - "\u001b[K |████████████████████████████████| 51 kB 186 kB/s \n", - "\u001b[K |████████████████████████████████| 79 kB 9.3 MB/s \n", - "\u001b[K |████████████████████████████████| 117 kB 78.4 MB/s \n", - "\u001b[K |████████████████████████████████| 130 kB 73.0 MB/s \n", - "\u001b[K |████████████████████████████████| 348 kB 67.7 MB/s \n", - "\u001b[K |████████████████████████████████| 81 kB 10.6 MB/s \n", - "\u001b[K |████████████████████████████████| 209 kB 76.6 MB/s \n", - "\u001b[K |████████████████████████████████| 78 kB 8.1 MB/s \n", - "\u001b[K |████████████████████████████████| 59 kB 6.9 MB/s \n", - "\u001b[K |████████████████████████████████| 112 kB 71.5 MB/s \n", - "\u001b[K |████████████████████████████████| 50 kB 7.0 MB/s \n", - "\u001b[K |████████████████████████████████| 147 kB 60.0 MB/s \n", - "\u001b[?25h 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", - "\u001b[K |████████████████████████████████| 793 kB 34.5 MB/s \n", - "\u001b[K |████████████████████████████████| 1.6 MB 56.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", - "google-colab 1.0.0 requires ipython~=7.9.0, but you have ipython 7.34.0 which is incompatible.\u001b[0m\n", - "\u001b[?25h" - ] - } - ], + "outputs": [], "source": [ "# for speechbrain\n", "!pip install -qq torch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 torchtext==0.12.0\n", @@ -129,7 +76,10 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "uJWoQiJgYnp8" + "id": "uJWoQiJgYnp8", + "vscode": { + "languageId": "python" + } }, "outputs": [], "source": [ @@ -151,7 +101,10 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "Mmm0Q22JYnp8" + "id": "Mmm0Q22JYnp8", + "vscode": { + "languageId": "python" + } }, "outputs": [], "source": [ @@ -162,24 +115,27 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "ToqCwl_FYnp9", - "outputId": "a1d9631f-b198-44d1-ff6d-ec304125a9f4", "colab": { "base_uri": "https://localhost:8080/", "height": 233 + }, + "id": "ToqCwl_FYnp9", + "outputId": "a1d9631f-b198-44d1-ff6d-ec304125a9f4", + "vscode": { + "languageId": "python" } }, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, + "execution_count": 3, "metadata": {}, - "execution_count": 3 + "output_type": "execute_result" } ], "source": [ @@ -204,24 +160,27 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "bAHza4Y1Ynp-", - "outputId": "c4cc2369-bfe4-4ac2-bb71-37602e7c7a8a", "colab": { "base_uri": "https://localhost:8080/", "height": 230 + }, + "id": "bAHza4Y1Ynp-", + "outputId": "c4cc2369-bfe4-4ac2-bb71-37602e7c7a8a", + "vscode": { + "languageId": "python" } }, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, + "execution_count": 4, "metadata": {}, - "execution_count": 4 + "output_type": "execute_result" } ], "source": [ @@ -247,20 +206,19 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "rDhZ3bXEYnp-", - "outputId": "a82efe4e-2f9c-48bd-94fb-c62af3a3cb43", "colab": { "base_uri": "https://localhost:8080/", "height": 62 + }, + "id": "rDhZ3bXEYnp-", + "outputId": "a82efe4e-2f9c-48bd-94fb-c62af3a3cb43", + "vscode": { + "languageId": "python" } }, "outputs": [ { - "output_type": "execute_result", "data": { - "text/plain": [ - "" - ], "text/html": [ "\n", " \n", " " + ], + "text/plain": [ + "" ] }, + "execution_count": 5, "metadata": {}, - "execution_count": 5 + "output_type": "execute_result" } ], "source": [ @@ -308,7 +270,10 @@ "execution_count": null, "metadata": { "id": "xC05jFO_Ynp_", - "outputId": "c5502632-56ae-4adb-8bdc-112deedc8893" + "outputId": "c5502632-56ae-4adb-8bdc-112deedc8893", + "vscode": { + "languageId": "python" + } }, "outputs": [ { @@ -398,7 +363,10 @@ "execution_count": null, "metadata": { "id": "iZaFudpDYnp_", - "outputId": "981274fa-e654-4091-c838-91c81f921e5d" + "outputId": "981274fa-e654-4091-c838-91c81f921e5d", + "vscode": { + "languageId": "python" + } }, "outputs": [ { @@ -429,7 +397,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAACsCAYAAAAaLvvnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAOHUlEQVR4nO3de6ykZ10H8O+v3YIGCghbG1yqC+WiBWwpa9OKJk2DbQUVURRISCDyhxowXNQEFOzWqEnBtl4AjQVCDYSLgFpBqA1ZBJWCp1As5aJtbFPWUkStbVHLpT//mJdwaLuX2Z1zZp6zn08yOe95b/ObeeeZ951vnmemujsAAAAAjOOoZRcAAAAAwHwEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoTKrqeVX1msPY/uSq+khVXVNVf1VVD1i37OVVdV1Vfa6qzllMxVvbRh2PqnpIVe2pqjsOZ/8AAACwTAKdBaiqo5O8PsnLuvvxSf48ya9Oy05K8qwkj01ybpLXTeuzQfZ3PJL8X5JXJvmVJZUHAAAAh22oQKeq7ldV762qT1bVp6rqmVV1Q1W9auqJ8bGqeuS07nFV9a6q+sfp9qRp/mlTz41PVNU/VNVj7uV+njqts72qzp6mP15Vf1ZV95/WuaGqLqiqjyf5mSSPTvKhaRdXJPnpafppSd7W3Xd2978muS7JaRv6RG2SEY9Hd3+5u/8us2AHAAAAhjRUoJNZD5d/6+6Tu/txSd4/zf/vqSfGa5L83jTv95Nc3N0/kNmH+ddP8z+b5Ie7+wlJfiPJ76y/g6p6epKXJXnKNOsVSZ7c3acmWUvy0nWr/0d3n9rdb0tybWbhTTILFE6YpnckuWndNp+f5m0FIx4PAAAAGN62w9l4744Tdic5bzGlJEnO37H3pt37WX5Nkgur6oIk7+nuD1dVkrx1Wv7WJBdP009OctK0PEkeMPXmeGCSS6vqUUk6yTHr9n9Wkl1Jzu7u26rqx5KclOTvp/3cJ8lH1q3/9nXTP5fkD6rqlUkuS/KVg37UC3L6eZfvzoKPx5Xnn7N7P8sdDwAAAFiCwwp0Nlt3/3NVnZpZb43fqqoPfGPR+tWmv0clOb27v2VozfRFuHu6++lVtTPJB9ctvj7JIzIbrrOWpJJc0d3P3kdJX15X22eTnD3dx6OTPHVatDff2jvkYdO84Q16PAAAAGB4Qw25qqrvSvI/3f3mJK9Ocuq06Jnr/n6jx8bfJPmlddueMk0+MN8MVJ53t7u4MbPhQH9aVY9NcmWSJ637Hpj7TeHAvdX2ndPfozIbFvTH06LLkjyrqu5bVQ9P8qgkH5vjYa+sQY8HAAAADK+6+8BrrYjpJ79fneSuJF9N8otJ3pnZUJsfTXJnkmd393VVtT3Ja5N8X2Y9kT7U3b9QVWckuTSz3hzvTfKc7t5ZVc9Lsqu7X1hVT0jyliQ/nuR7klyQ5L5TGa/o7suq6oZp/S9Ntb0oyQumdd6d5OU9PblV9euZDQH6WpIXd/f7NuQJ2mQDH48bkjwgsyFbt2Y2pOvTG/AUAQAAwIYYKtC5N3f/IM9yOR4AAACw8YYacgUAAADAFuihAwAAAHCk0UMHAAAAYDACHQAAAIDBCHQAAAAABrNtnpW3b9/eO3fu3KBSAAAAAI48V1111Ze6+7h5tpkr0Nm5c2fW1tbmqwoAAACAfaqqG+fdxpArAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwcwV6Hz9llsWeue3XXjRQveXJJfsuW7h+1yEVa1rFW3F52orPibG53XJKtnf63EjrhfgUB3q69F7LnCk8z64eHMFOnctONC5/aKLF7q/JHnDB69f+D4XYVXrWkVb8bnaio+J8Xldskr293rciOsFOFSH+nr0ngsc6bwPLp4hVwAAAACDEegAAAAADGbbvBvs3XHCRtSxUKefd/myS+AwOYawObQ1RjHC9QcciPdcABZJDx0AAACAwQh0AAAAAAYz95CrHXtvWtidb1T36SvPP2dD9ns4dLGdzyoew8Ph+LOqtlpbY1wHep9c5PUHHI7DuX71ngscyXwmWjw9dAAAAAAGI9ABAAAAGIxABwAAAGAwcwU6Rx1//ELv/NiXvmSh+0uS55954sL3uQirWtcq2orP1VZ8TIzP65JVsr/X40ZcL8ChOtTXo/dc4EjnfXDxqrsPeuVdu3b12traBpYDAAAAcGSpqqu6e9c82xhyBQAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEehsgtsuvGjZJQxvs55DxwruSbtg1Vyy57oh9gkAq8Z13dYi0NkEt1908bJLGN5mPYeOFdyTdsGqecMHrx9inwCwalzXbS0CHQAAAIDBCHQAAAAABiPQAQAAABjMtmUXcKTYu+OEZZfAQXKsAFbf6eddvuwSAGBIPu9sHXroAAAAAAxGoAMAAAAwGEOuNsmOvTctu4ShbWa3QMcKvpVuuayiK88/Z6H7M4QLgCOFzzsrqmruTfTQAQAAABiMQAcAAABgMAKdTXDsS1+y7BKGt1nPoWMF96RdsGqef+aJQ+wTAFaN67qtpbr7oFfetWtXr62tbWA5AAAAAEeWqrqqu3fNs40eOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIOp7j74lav+PcmNG1cO3KvtSb607CKAQ6L9wpi0XRiTtgvjekx3HzvPBtvmWbm7j5uvHjh8VbXW3buWXQcwP+0XxqTtwpi0XRhXVa3Nu40hVwAAAACDEegAAAAADEagwwj+ZNkFAIdM+4UxabswJm0XxjV3+53rS5EBAAAAWD49dAAAAAAGI9BhpVTVG6vqi1X1qXXzHlxVV1TVv0x/v2OZNQL3tI+2u7uq9lbV1dPtKcusEbinqjqhqvZU1aer6tqqetE037kXVtx+2q/zL6ywqvq2qvpYVX1yarvnT/MfXlUfrarrqurtVXWfA+1LoMOqeVOSc+8272VJPtDdj0rygel/YLW8Kfdsu0lycXefMt3+epNrAg7sa0l+ubtPSnJ6khdU1Ulx7oUR7Kv9Js6/sMruTHJWd5+c5JQk51bV6UkuyKztPjLJfyV5/oF2JNBhpXT3h5L8591mPy3JpdP0pUl+clOLAg5oH20XWHHdfXN3f3yavj3JZ5LsiHMvrLz9tF9ghfXMHdO/x0y3TnJWkndO8w/q3CvQYQTHd/fN0/QXkhy/zGKAubywqv5pGpJlyAassKrameQJST4a514Yyt3ab+L8Cyutqo6uqquTfDHJFUmuT3Jrd39tWuXzOYiAVqDDUHr2s2x+mg3G8EdJTsysK+nNSS5cbjnAvlTV/ZO8K8mLu/u29cuce2G13Uv7df6FFdfdX+/uU5I8LMlpSb73UPYj0GEEt1TVQ5Nk+vvFJdcDHITuvmU6Wd2V5JLMTlbAiqmqYzL7MPiW7n73NNu5FwZwb+3X+RfG0d23JtmT5IwkD6qqbdOihyXZe6DtBTqM4LIkz52mn5vkL5dYC3CQvvFhcPL0JJ/a17rAclRVJXlDks9090XrFjn3worbV/t1/oXVVlXHVdWDpulvT/IjmX0H1p4kz5hWO6hzb8160cJqqKq3JjkzyfYktyQ5L8lfJHlHku9OcmOSn+1uX74KK2QfbffMzLp7d5Ibkvz8uu/kAFZAVf1Qkg8nuSbJXdPsX8vsezice2GF7af9PjvOv7Cyqur7M/vS46Mz62Tzju7+zap6RJK3JXlwkk8keU5337nffQl0AAAAAMZiyBUAAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAwMqrqodU1dXT7QtVtXeavqOqXrfs+gAANpufLQcAhlJVu5Pc0d2/u+xaAACWRQ8dAGBYVXVmVb1nmt5dVZdW1Yer6saq+qmqelVVXVNV76+qY6b1nlhVf1tVV1XV5VX10OU+CgCA+Ql0AICt5MQkZyX5iSRvTrKnux+f5H+TPHUKdf4wyTO6+4lJ3pjkt5dVLADAodq27AIAABbofd391aq6JsnRSd4/zb8myc4kj0nyuCRXVFWmdW5eQp0AAIdFoAMAbCV3Jkl331VVX+1vflngXZld91SSa7v7jGUVCACwCIZcAQBHks8lOa6qzkiSqjqmqh675JoAAOYm0AEAjhjd/ZUkz0hyQVV9MsnVSX5wuVUBAMzPz5YDAAAADEYPHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAw/w9yi/xWuRzNKQAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "" ] @@ -470,8 +438,6 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "r5u7VMb-YnqB", - "outputId": "c714a997-d4f8-417a-e5ad-0a4924333859", "colab": { "base_uri": "https://localhost:8080/", "height": 301, @@ -491,12 +457,17 @@ "765485a1d3f941d28b79782dcffbf401", "3499ef4dd9f243d9bef00b396e78ed69" ] + }, + "id": "r5u7VMb-YnqB", + "outputId": "c714a997-d4f8-417a-e5ad-0a4924333859", + "vscode": { + "languageId": "python" } }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Login successful\n", "Your token has been saved to /root/.huggingface/token\n" @@ -512,8 +483,6 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "lUq1UvoJYnqB", - "outputId": "8c052808-d0b2-4f2e-8771-f86114ae3fe3", "colab": { "base_uri": "https://localhost:8080/", "height": 273, @@ -607,120 +576,125 @@ "bacfb50c001047c4824a05c9f2ee2e40", "c53a1cf68fcd4388abf1f0379891089a" ] + }, + "id": "lUq1UvoJYnqB", + "outputId": "8c052808-d0b2-4f2e-8771-f86114ae3fe3", + "vscode": { + "languageId": "python" } }, "outputs": [ { - "output_type": "display_data", "data": { - "text/plain": [ - "Downloading: 0%| | 0.00/500 [00:00" - ], - "image/png": "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\n" + ] }, + "execution_count": 8, "metadata": {}, - "execution_count": 8 + "output_type": "execute_result" } ], "source": [ @@ -781,7 +758,10 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "vNHQRTUIYnqB" + "id": "vNHQRTUIYnqB", + "vscode": { + "languageId": "python" + } }, "outputs": [], "source": [ @@ -794,16 +774,19 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "9d0vKQ0fYnqB", - "outputId": "9a664753-cd84-4211-9153-d33e929bb252", "colab": { "base_uri": "https://localhost:8080/" + }, + "id": "9d0vKQ0fYnqB", + "outputId": "9a664753-cd84-4211-9153-d33e929bb252", + "vscode": { + "languageId": "python" } }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "diarization error rate = 19.2%\n" ] @@ -828,24 +811,27 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "xMLf4mrYYnqB", - "outputId": "ed08bcc8-24c6-439c-a244-3a673ff480b0", "colab": { "base_uri": "https://localhost:8080/", "height": 230 + }, + "id": "xMLf4mrYYnqB", + "outputId": "ed08bcc8-24c6-439c-a244-3a673ff480b0", + "vscode": { + "languageId": "python" } }, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, + "execution_count": 11, "metadata": {}, - "execution_count": 11 + "output_type": "execute_result" } ], "source": [ @@ -857,24 +843,27 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "Z0ewsLlQYnqB", - "outputId": "8a8cd040-ee1d-48f7-d4be-eef9e08e9e55", "colab": { "base_uri": "https://localhost:8080/", "height": 230 + }, + "id": "Z0ewsLlQYnqB", + "outputId": "8a8cd040-ee1d-48f7-d4be-eef9e08e9e55", + "vscode": { + "languageId": "python" } }, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, + "execution_count": 12, "metadata": {}, - "execution_count": 12 + "output_type": "execute_result" } ], "source": [ @@ -896,6 +885,11 @@ } ], "metadata": { + "accelerator": "GPU", + "colab": { + "include_colab_link": true, + "provenance": [] + }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", @@ -903,99 +897,116 @@ }, "widgets": { "application/vnd.jupyter.widget-state+json": { - "c8731777ce834e58a76a295076200cfc": { - "model_module": "@jupyter-widgets/controls", - "model_name": "VBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "VBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "VBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_859b12a6d95b4c6f987791ca848122b9", - "IPY_MODEL_94756148d2e94a93ae233baba20af683", - "IPY_MODEL_ba18cded436e486da34882d821d8f1eb", - "IPY_MODEL_99898e6ee64a46bd832af112e79b58b7" - ], - "layout": "IPY_MODEL_79184c8c2a6f4b7493bb7f6983f18a09" - } - }, - "859b12a6d95b4c6f987791ca848122b9": { + "0125df9fa8e14b3db0e2bce299529812": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_ea95ffd922c0455d957120f034e541f8", - "placeholder": "​", - "style": "IPY_MODEL_13525aa369a9410a83343952ab511f3c", - "value": "


Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + "layout": "IPY_MODEL_407e250e244b4985b1ce8c9d32a8af7d", + "max": 318, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8127c4258e374ad986ce1f8b4c70f704", + "value": 318 } }, - "94756148d2e94a93ae233baba20af683": { + "0821b47ae70444dfa38b84719c4836a6": { "model_module": "@jupyter-widgets/controls", - "model_name": "PasswordModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "PasswordModel", + "_model_name": "DescriptionStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "PasswordView", - "continuous_update": true, - "description": "Token:", - "description_tooltip": null, - "disabled": false, - "layout": "IPY_MODEL_b2be65e192384c948fb8987d4cfca505", - "placeholder": "​", - "style": "IPY_MODEL_333b42ca7aa44788b1c22724eb11bcc3", - "value": "" + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" } }, - "ba18cded436e486da34882d821d8f1eb": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ButtonModel", - "model_module_version": "1.5.0", + "0adb304bf90f4079a4031caea1cfb924": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ButtonModel", + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ButtonView", - "button_style": "", - "description": "Login", - "disabled": false, - "icon": "", - "layout": "IPY_MODEL_0e382d66f09f4958a40baa7ab83c4ccb", - "style": "IPY_MODEL_6a45ce374e2e47ba9457d02e02522748", - "tooltip": "" - } - }, - "99898e6ee64a46bd832af112e79b58b7": { + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b4bf8076fdf4d19843a3246c8bd61ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0d10fb0edc9144b1a1fc1f2c9e322410": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -1007,16 +1018,32 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_765485a1d3f941d28b79782dcffbf401", + "layout": "IPY_MODEL_d33fba0d78fb41f983c55f5cd2a0a740", "placeholder": "​", - "style": "IPY_MODEL_3499ef4dd9f243d9bef00b396e78ed69", - "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks.

l^$^8-i5Ka}`4J{G(6re$}vtM!f@kgfCA> zjnPEI*7dXnO7nq74KaQVZf~DBfrqAkLIP3)YV0G!*wHC@@ z_92+AyDJv53Y9RIfto?v^H?WnP8o;=So%eh7toTCm?qe1H;pxWTIHt4M0}xRpM>3Q z+CZr%oisUe#~0KoC5wqa$q1Ti!9HN}c-=+8I@tERksVWQfKDpTaM%oa7h6OQ6p4H|^++#V{5^{Y@cDm$Hi&!J5(x=mzKHSn)e~hFP zG?CbZt5e6cW7K*x1niLa|a=;gpAZ+VwYmZVnzu; z+s2rE>v=YyLaN%#X#6c_-rGD~D5w@>n#dk)MPrv|-pTW7*0i7dbSze*+Eb@sS1heP zGMK)mk`c1pRH0+DQ$?u{)wZf?W3WnbyYKlp>Nc)t4V%G8&)5QGLRQB!p7LDhgAu7@N&Io1VFCqEjq zpW7$EGtS`Ex3cUY0xlPuKs=@Po%;~w@GriUK&U;u-)Ld*1SmceMS|PYH8{Um#g?!dy7$BGVbVKD)NTs3PY+TyDuvY@%w^ z3IZbYYSt%yh|oy|DJL!!=BGv;M?>_#>*R9=Vt&<5dNk?lbev*rhE@;#tx}wq14S8gq z=3)g+s@I#v0x~vAN7^IiR z!;zOG`J4qj=V}+f?@BK;dVa~f^ihx*CQrx|sl{eQz*vUK7zz34(HmoBY80B3I#UKE zCCY}-c)@KTzCip>EFiEzzDs>0OFwe{b|G}KSOW5GBu>dih39?Hy|*c#%gBfreODt< zlb!y3HO9_Y9$aJ3Btak3-t&~T!t}|!yq!M-Vc=ldL5Jw`ig&&qdpl-JY9Xt8**}1N z-Fb*^AN~P?ZmRf;_hWnT$2~mjNn;pB8;OtptkPHn;CK5HSd{M1>w(|=^fpkPl+#&d zHYBW0b&t0G6P*l+!=foZ8acL88qDc*q9cV)V5}8fcNwm;IaXA*ZV$CQHDY2ZTsnm@%lZH z;4MAW#RZmAQ*v{zz-BoIPOB6dN~WgQ(B=@F(+k<6N$tg2Lpdf_!fkHa_F_OC`GW(% z`?tltrV8&U?zAK5>RakB@&U<6WDtN80y%OMjDnB->2mPlu$KDO zJdes&iip@h$i)mBs$68vFH&YUq?Bc6Ec#R^LS~WUX3@f7ZjsM zd8oBi0ic`(=ww$vyd>oqP+}c+=nZ8;`bM^lM~QTa;s8S4X&gxBja?UpXiMBmPx{IM&Ah2 z%o$ZGkq7%Y@a;Mld(TY7QSD7`yum#GRAMCOB0mwoz~e$WKRUZWH;4YCqP#r*_&yr* z8vtt4bpx+!sq1fjfR{KE`KL16pX6hh&#FjVPw)SUsK7HX~h#1|{eV|@&k z?})dfJIgJrf?CjpbL?U?4Lx)gd7S|I!cNw>c2ghr6{4C%T9V`i%=3W|wG0lb2|R+F zHFvTSqsA78;RaA(q8(6wT|RagD;ZX*At@irF7N(zAl&+?u-i7ia1=Lp@%k1BhKZ8z z;}MATl&(_Hg!ZQQEt_qteph!p#C6*&0M?uIA%)Viq`WY{tIZb~U@9f183+kYYy%Op z-##ymvc~229Vs@mN=~GCL8vI{#n!34CrbXzE1vY_Z^PxEa_pa9x$$jw%#i9rJ@z<9BqrEI^w*AGhV7+OtcZB38&H?V9S-x5NU{F;(Idw=R>v4dSH zD<&36c?G+MA*N4s%j(040!p|%&PSE%c;j?2AuUVj^q9r+hpNaSpo>u=V-W!MJ8VvHiPy_EM^@f?*X5Q^& z&+Mu&UEhI{ifTHi~Ce)zu3 z|6sbgFqH?sumt8J=`i}u(B-RfeAWZ_m>FA`4&l@KY*xe5H_{xgZiE<6dE(^iWUu6q zAh<@Zq>B98;b$c&b{aRCYujI$X8?RF5X<;PzDGU!YyMis@M5~AZ27sB3fq&pKWv4JaJ`5QUrT& zrCoK(i;amg4igl|lFl|DWR}<^#O|V5I3g&nh3eqJx&n*i%f46QC&@fe>g&y^qdpM;I1;cCkb%&jh=)vU4DWSk3yJ9sNx{obf1# z$;(KLqCWL+SoI86q7=92x6-;2oDRe86n4)3)sM&uRDl}i_a%F+-tcU^-Tc^~hILVy zJ~kvs?OF%JGM`xE_d0|RNB^&Dg$qxBF1a5b3$VkO9>o@Pz9I>BmQPU*1M5b$U%91gEMKiyFQ@Y2*a3AKL!%&(bS3^SbM++{;Vrrn zNvvSo!PwOjOi7&&d^kcR{_q?V;Zv-F1GPyrOF*xjR(C#BcT2n2oz%uAzk~?RX+GP$ zsUK7Z@4GEq2NtdOG!YUpETz<7{Fdhd`8&~ z72Nm*+)J`l>rf*TQiImh$++}ODs7@Mde1#>pBT;aEC9WzDWUTp#|^A8!UEKQRlqzo zz110q1?U{_?hQU172$L?$zcm?r21&dYhAOl);88^2%mHK=`)tDd`1Ts9(ZV2P8MrC z+X{=L3Xq@hB^UgCNr)4}cK!!h`&%cnMZS&Cgx2M#Q=vWEDRza4^d!f&%MG8NyTofzVP z?eIn-oP$sft7r2G8|`X!FXkD#r=?|6s-cV*?LMLbZ=X0*h=4ixg6Tn~b3$ zvW)@aK%bfxojG1S?t8G~>)Bj00R&lEnFvd8M@jB7PhMj(NZ?@ zR*^`!h}xT$kc9x;Yj$qS%MKUAXg;m&i2=wf^ZEw_#k%K&s zI+!Qnf$W!JxUcdkXLL&xMtA-`!%+KtPB9%qztp;eK&$r-qZI0h#M^?A3_3VfNEw={ z)$$W-@cZxJ5Kh&eZHn}GQR=~U%8(^cU7uC%R#fJj*6TCuWzz8%16(Wf*qmW<5J6gn zkH|jzrtIGogY>}&PB9?9#KZTzuITf`1~`(lDqTO57!3q4wQHZpH0Y)ZEBOw24{VEXfD@%r*!`)aiV|OteAX>1!3h_-U7q6 zwNWxihEVR3O@)nU8{fyGE3DI{D{Lt~HeV-3)Rxkw_=5#B+f)Zd&-i&4maUoW7W(M2xC;Vd1R0QKiLiT>S)dre?0qjtHrU?#f zGA3gk2C}7OmxgbOAzs_$mNjXU9r5X};M+pwigYsWOuKMFt(B~|vzrJRy|^+p+4wr7 z;Y^6aWwP84yH7mnQlTKFc4)c3-<~d7^A)X%YG^FzF|7ZC;nVoqp^UZFJRffSg%R{ni3Dhv z5}kapUD3wlb{-QX?g|)ra*ph^WpoG4$g~DIJE+8g)J&U$yUV}9o+-Vrh}ENMIZ589 zQXbV-a{^Ep)A588%8#AyhS?TZZpXP4(LX``Z#?9Gu!V#K9%oU%ebmi?zlTc< zaBau=y*`1~e26;Ttt_LWR%KhF$-CdAci`aeY(Y@i&hs066Pd|hqUT{7<-WRE9XBTo5pP*61p;f-Qv z(?gp54@~*qfV1JqP5#2tF6=&pM`BF3qD5sV?vu2UQP$?Jq<1Sz1hKJYnQ?2vcN$yTDWo6O@~bdYL5fm3 zC@|Sv|30t?%V?Dc>TUx4+|wA%S>D3u@;nm2{$lDR<|w?M zd9zEnNRr}Is*FT(?L#EIaRNUix*e8_J_wJot~4>_|-#U z<;BWS&@o$oVJUb9_Bf`?Xo@Fv zPRAyGeuR^DUc&&jNn_nbR(`{>+Hjx&1SK}>5?Omz|2o?GV}|An!xD4|1X#UVI;QkS zIk^v#6RZ9Ulz^VpkwJ#%y$5e$gm>r9RG!%e`D|L4@LPg$6z|A5@E4VDFz|_3k{FX; zuX_9u9WYd=KiBCW=mxfb~u=f@~up z{Kfy8{!#%-EqV(P?n4iT7L~gNAD}`QXx;xB*yVzqL#p<@$`I*9l^{pfqAQUKHPClc zEnlUEd`fLp&;YnmpN+%~k9(ok7bIeg84_a|vH2`}?Y2NeD_J#a9&yGTIVyE9C?wb~ z7u%AqJk)1}U&5=dGqr`pQ_X68M&P0F8bW0_IgxF4Yz1n)dhFd)*LfNLN*a|lz=ej1 z@cl8X^z0fRwdte;$pXJ$m=&Yy*$P3C`%N-l-AV=*>LrdZhAcsWboyeNP{~xqtM9{Y z*wvNw3s#Zy3MSqc)T@iW%1xFT3mhY%uI%Aee3{}~xj!Q6twlI6A%wXnm)$C-^Tz(9 zw@rzey$P|`TNTtU`|;s(>luHK-f%mLLx$6<-A=E2y+98aP+NiE>Jz2@mGj1bZ}!ZH zk42FYoAnKPG7=Z=p*R}}aO&hziG7I2jFUSVBNc|RkuCNL!IA-|?DJKgXL(A^gwhf| zD_`WLW~ZnZV7)PE6!J!A#El(x^2!3vrg&V+O?b5js}LFQp%10OpKjwYwai-e?u2c5 zuBKYvAjLt3Hpm<@k$v{GBIj&xYB@ugbViMi-zOmbN7F^4)m&}xT5j+qGw`eQ$MK!8 zSG5@0etEWYL#|DSWpR}m{8^!!l3glbfj)!lYJw_QT5BS%YYK~|NWwRojYU86o+_ze z&Hn;kVpGU@sPumX6TKq9{;x4Zg$(-qGFqgm?}txD@{i)q8*uzx9%0qgjdtWBh6~JRn?IScPj4Xjad7# zTzLGI1a}lWMiW!`5I8=zBh%qRUr6;%`X2=058|wezPDJQ;7v&v5eI+~2^{!dHms1hh>c8VdBTM@S$inlV@Nb2u zwwmqOA$bey?~riz0$4j_2sOrNcTx0_S>Ok-MyoiNQ@u#_@JnHwEm?{3hPdE~VZ<*jT8RCP-apLO3Xne1fhXxfBan7Y?hcInYr39XYEu+_#DzzN&-GvXDtuEpm zrYw8{PxCQr$U0;@2ui_?itI_9-5{bi!-?@NHg1Hq0YOLNnFN_;`)m!+)zY--rb1sW zdI{YFdkWMk*i1G#M1j`hL{>0EQmY`J+_HRJMT`R^hN}v1wWzc-f{!#aB?focYQ21R zPwm2N##_#bKCHUbF9n1x%MEXzG8(@_4*IH6BU0hML6|6V#x;G~Q8b-Aad z7q(ZTOOy#$dYj5#+COC6?MuWYm>aXvlyoR8LZi#v_umjCLse-{1{l6&D-~&?)nfRK z2^ao02Y|)?w1mhstIQdaZagR~dq+B2*LC9kPf=t>)IxreRFS_@jwa!MJQZwNXICJ z22cWfvi1=1%TIdE6}HWpLm6o(l4q6G(IZoiE+yDUE*gT+gWYLuJ}#Z|zcl7_AuU{t zqeNVkexS}lx>R<j?WHHuhI8x&<%*G*{W7B1 zZ9Hskr>jtSj`^s-lN|2fme^sE;-Cs2vi!DdoRql5ZXOZCDC+(SYM<}mpbhHPxW8CV zTmnFV815;SXklRfEVUxzD^C%8wUc_LM1Ej|gD7`)8Mz#$&}m4aZ>ihgBA$PBlE<{`YX8v=g0m+xU?!)J4TUuk}THL%#- za?u8njD;GjsTxluh9sE?O8Hm#J;o&aFjH56&1Dx^iMFee$B;z8KDtG3G5)?{9C<}R zdvTZA*DCDURqgiPu2G_zap2vPh>AEy$dPocsb7+c*^Wl>SzHU+-V7ku(8P^z@bW=t zhlwriT8@|dp_-|BjNfusjm7$Q7sfhux8PSQ*zshU$zbH|3g;PkW5t^@i+!DA`?OMQ zAd}zUa{vT{;biMT(F+x_Fa`;Q{6KatDhtgVFECjMCdf2Ct=7E^*4D!Vw{yK=)Lx`d zVkWJMwE6=4i=ggoAcjnDwX?l^EL+G;8tN=5D<>!RHjtRLP*Uf7N?=63=&*2B)8&^O zGMuui?dEiBNc;F0yTcf@B7%`{)Z+7BeDT1Hz(zR;@bzvGc>omt-+*7v<$Ldmf*>NQ zKRF+kRaQ(i5r;4{QALLZcEVhYJl(63#471q|J(rSAgN9w!JZO&n3fqo*&CRy5U_|Q zV;%jTD}!))6dycH`V1kvdZb$^M4K&1Q@$^+#+_ofnx0H|rthhUPAIGguCiT0L7kYk zdem;#Bjqg^ucJX<9-0){(U6`*?@BJr)_tOUpBWc?GIt=p7dVj7)7HZKN1G`MFNu!K$`_htQn`3tT1gL$7mNO=$`V=sH!GT|O zgFZ^k7WJPTe;*ww|H@cjA2Bc|mOxZNRwTLYny|ar29JAp@Y|LgtE6=T!*Xqgd-{Qxs^gd-DCYRi7 zcb(23wG)_)t$Z@?sN+yPo~oC3l>~mn%p#X>%P$G}KJM=4hbGgHeM%04Ur|M|h~;xa zyUDfDGbP8OwWHY{Z}p~@tu!@X*uDlhW;oC!;dA;pXN`@j-rUJ=mvrjBgUzrVInY$9 zXztGU1U=NTPpNqm-{gm@av^m;BqO=6qqmxf`t)0q?!J|mRLFvl^m$#25UYK6TMkU* zM=QeDwrjjVY2{Zwn8H6(B_PBG6fTrXf2maAmcFBY zSii$FF|CN#b z@$w|epWvzl5^aeup`f53=4mDO6WVq6>WAjshosZ`d|X)#vnNnmlbMkv=^AoB9i0!s zYzw!o5yYR|+HxHcA3hM*39xajH>ZnbJlW!&SMRU-1$f=EpWS_ohWfi7c^3hn6Xf?=mG~ z{G6sHY_CNGUqLyg;gQS1D+_tbDm+FOiOMR4*~pDo3%+F*U?KgyE;w6WQ@GR=R)0Y3=W*g zoq-?E%*lRXEC{h?(f+F-znRo7mSyc#Q>}=>WidniLGPZ;2aphs;M2Vjc*nb&_jnqA zw6Y&McT1+l6pIeQx2eX!Fq*m!_=##*Xx8pCqv$ZK^+<$6;B`!N6VE0xCZbs!$OsF? zP;N($@J>n*c|<%7d#=`qFe||CGNKaE*S(?@aX;>72GR4N#RyaxIIk5%=>OrL-HfdR z#=?tHR92Q)iM%|-CMA96Y3}wsI@3Sy$DP5_T*e@2+t|;U%H#G5T*i|I=0ZNw!? zK6HUBHR^ur+@Y?&f_jzgCcw7+o{I~X%1ba^|F>9Ew<-MJ$0a{CP_VE>yJEOT!uK{du<3Cjz*C0^7rhf=Ricvf1L^XcO>J-x z8McffxyoURsUA9<`!nFPfJ(m5= z&?&hp^2)@B+X~h8WJ}Q1xyEY|-g7t~Tf8PTVgAonK@%|B=!qmrZJE3m=ekVnDvs@P zW7ZRBAnK&TTFl^cAbvn8qS$~7-*Wgq;0FZoPn{7G{;&T{9k3MF!mj)@Or8Mod@<=E-fd|(%T5#~pHXyQiw6UQ;u;za+?`@$P6mQU?a^VOIhY>xkNCHxWz=!>Yvjnv>_ zeYKEOnnp3jza5l4HJIHN-V)4+ysfq{>h!C|Au0niqa%vw`5S@X z08ce^svM(~0;F(yxsX2Q3j<$(YlE;G*|t$uB6_lsr2Gk>>vadu>9bACQZv%mT_td_ zj~qDN@yG_K`(qiA91(8`_uL9Bn-Wmo1CwQx|roe!VrFMOySslvvQ1a7o-b5?ayxJ4=lf%qbpm{arp`W-z;_w5 zZ{nd{SDUq@@y?nK(5lGqB;+$DeL593=J4LQ-DFY=rZP(%5Yfyvb91VB1d^wZi+7%H`~n(qsO=?0Y4R3H~s1pl&%H!;5bD3^+P(bK)e~_WP5)8=_egL zp_mR+e}MgDf0!z-GG(aGI;{GKYZ*+TTm*%MMZD9@&a#QzN|>?^n?-g%0X;xRqueRW zdX(9{U@&BTyU7*xS4ekDlnX*(9~1-w1uTyg=T=7VTYH!D)nVbhe3S)jx_B(njV%Vg zRa-XF2c(Yf(0a4JDZIC+F+kJ=$xiNm?mi6LT&llFjMIpn?CN|^@@qs4jnRcgy%W0N z+ogx3@!!MW2pvM!V-6J>)yCJBH(s7hTx&UcRy$9!)32Uc$R22XY5qgzBd!;+m%!|OosI39}}*u;nrSlU%7^|KZzz6Q3I1Q7s>37qB2bSg! zxMiaP-@zLbkC9oG~|D#dl$c_543wJK#RqaX(9DW9X z7Dr(^inBq|WEzqb5^8Hx3H`O-zelbtjPwlpTlb(L#Zbh57{bEC;c{+7o3IxS`tqG1 zj@v`yi-$Y?!!G^X7H=w0kzfi`y9-C+I-BHsgQVowCYrM8T7(?e|FH6U2jr`5y}74> z-pS)np?dcp5`aK7;*6-H21V+nRUpc#GC1D1V0g2MQ4whVYeLDPD>gg-xwyR0<3}bG zaV+jK2Q}{91j`GrUqF!Xsh{ePjZ4=9u^Eh* zj^h!xCAs0q?T){s7F4NX?BgUiPW?Z|1wLVLUvqm&WmW%V80_b(sQB3+kn{(gby!B@ z<@2PWtS;>Ye;pJ_hCdp`#oJ*#?+l`3BC{^7*YtMhWP&v*o=G8#SKxSpR(9A#&ho zQA|3r_I4H9a{iP0U{x5|#@omIH~>$%)Zkz`{`B2X3Q_Q2g z40Mr=H(!uwH*6SHG|1kY&uBeEPyMAa8u?TD)IWt<3(A8Xn2mo$D9u+(mv}8<{+fbKtpO9rU85l*`4J z{-NJ$v5R7Hmex*-z&&bb-J;E?9eX>m4ucf_1zphc;JAdB{$72Gs@Vrf-2We8Zxt2? zw=Ih%5FijFSb$)`f=h63T!Xs@2=1=kxVyW%ySux)yG!FPx7XTxf9KqF{&VkJ_ftRg zoMTqis8J&U?&4<`3-F`42Xv`V%O656sxHaL`LY-MK^$EU{eyb4nOVPoJ1rpT^3#l4 z_^j&VM_1W~^+0}T0Y4*I`h(k0$%+#>?CPzA$()x|Il0Y=E7Fa;nEZq(s4I+@LU3k&HfVw; zsPki2Hfq3pBR|n{$F6-Z_0=t}B_=-op21KlT3%$ny0(oAX$Nam}$s5H;om%!X#XGP;7iWm(F%! zS&7+Fsc8G?)}?b~e7tw+>1h1(zeY^3bD^4%RSfAgT{zH+X-u3V9Xq|Pz=pHt8UeK~ z3H2%KOZZ;h=ojGi?>4N0>k2O9#zKc_ewLGXlM4SqarBn!kK9NS8 zthB@DO}u{;BzS?HW&Ho|M7Lr6nXC@*r&?8_{V3T1z_vj;enayhlaEG^icS2W#k;u^ zh~!1@{-{xzBC%1zt%MD(X-Y*GxwJ<&QWJwDaPS-g{RrR0JfUTWS+z~(T&e|Tp+ZL zmodVN{*8p5Jx1&6u!U{Aj3yMpfZB?0Pivx}V59dt+Y+RWN3WENS1XUQIbiD)ixzN6#9iN%Hc?<~SiN zI5!EcR+GTS$ww49$8n4?SE8;*8S^X2IPhG0j@n18ANd1T`N$KQlkPLRY6Ht_K=) zQ&B@v4d;OK-P_BhlA!gMxv>RBdm<ECDI>!t8P|wD{ z9N175H{aq|_0rBfJ7CTt>G04+$4$P>8`0dw`lBYD+X2?kC`49X{U<$3vx0^5;v^Ba zd?eeC6~G4W& zm#db_ljYQdWCGlpQW1iUgS}s=fwg`ry-OthYmg4pe?D=WF9@~oxU-LI8C~rTt|)h+ zi39)Ls1Sv?cr3Z&ss5-bXlxXJ*HihX($#*P%=zH{v4}VBbH%_~T;G#>dO^C&N2`~e zH06`mQ6QmRF-=`_O$_ev)?2_^Tb!Vw2rTG!;|y9jtu#1>lFv&Uq0loa_b&BrXj+E- zX?d0NMpr*m@>vXXxE8lxz|M)mrM7-A1VR#%km%ip!P;7vS>-YI0L)fdtvA0^?=mb57xg2DzRL3+Hp+;kpAhQ*g2x#etdj2Ow9D?CCqVfx_256B8H~eV zzE}W@y@A~L4D?6W`ww9u|AMKID!bxz-jzS5k(M(uGSWvoEgnNs53$~ycJDwQnLMD8 z&rEU6mm1NuK9hSj9Q$SW;`r@XOyb~r=(#zT>El+1z8Dp4kCGLBNlbZD-1NfY;_!O4 zbr}fIN$^x$L^9VQ&l+m(KaPbDifSMwl9bZ6D-~?{T1w$X7Z*meL34Pd7IgsLZX1cO z5RnsyY}8=0Y~Q+4)*b0VdoX_Hoa&q7tZ7=K`;A8*$M#HQ{`mG3CR^6-#uOYZq5kb& z2!7&zpuNF7Rz>~O&90(qT;8O;OM1k2WJRUU^2iN%mRwhZ+^n$V4-13vQ9qFmfyY2E z6ZNxY4=1v}MUJ&y1#Sq8_){0z~khjts{qxRvgE-%CLr zByX>hD0<_iCitUk_c7}(PGPOEskX}89_KWpiL6aCVW%q|pUud)i~9q&1g*!E5*!*s zi#^xty&Wsj6OdH~gRolpwiCt0)NG+&TAaF-`L90r&`^mkfjyu$rhtQO&rD%m%@>)u z7F`~97{l7mcysgsq?L{4X4?@eBqVrw7%qz`C0Zwk0|~Kuxy${U!nN9Bu8_JE6+dW& zyyyagvsbAWGR}6AbVM%R=>DSfQ}AC5 z5x!ra0BTEr%1>V1B-K2OfzvzNp#!WB;4FIscn8B>Y5zc5`#}cEB9(+$=bl>Fl$MCg zw96*Qy#{u3KNX}k(rravvxG}57S`97Ymm=*w7#A{E^ApPKw*4Ful#O`x?G34UthqpOfoK0Fe_>%e(KiPgnv_Z!NXY%+g5W>Nqws7m#>$REKmja@B}GG@FE>r84; zzKjXNxGLHx4~S^;>o?M(qEkc7D%zn&*0q;Rt5z(VK$FTRW)7KE);-l(c}Cq1M^cr= zBf4eoNRCR-KZx{=d;_9eVQX7;D~pFWHSUo$0 zzTo8+ z0PhwJ%6aWCmp<<=9Pygmgck!hPfImP_^M9WNDx_RSmMa_s8$~{u-y+KpD?OkUj>W1S&4ER^jF5%?9f_sl z4N1iCduxnQR~#Eg*7nS2yk#F*6XDsfuGbRi`BI|uaNqzgu8PNU%U49q`0OXY4tujC zF(z^?N3!Vrv9p>?18y9Vt3Z35tKOr}>y9W;5H+U`A%gkT|EsA=o7Yv;PL$or0P$G& z^FI`uOg=NOK^8>y38oJXcc)x|0UeLfr)wTxO^PU;AE3QdrqOs*)!63`&=*#QhqANU}MO9lYb9`!m1C}lpxB*Qz z51g145$B!m+4upR#mn+xzBDV!B*!I!awiS~sYsyQyu8!~$L(Y1x3_tTRR_0)_1NMM zqFYP-)&e?e);th(VB*thv-%>7QY8vuNHY{I4-O>8;zHXoNAZ=~PF=FuKioGx8Py>v z{kLq_;6+q?a_Dh#ezEr!db2YRzk0xc;9&Kmb^Gfry?*P<&Z%F5c0y&MSIc=L4B&(*I4a{s_sim>)k5v;Eq2267>5}Ph|=9A8i}z zn-t#FgAViq*2TBvVm*jN^Y6<*U9wUzS?6i+@O=W~8^6|axZWc)U-k<@-iTZ18$ogP ze#HB;$BM;IHga6aibm|703?1TC8WDS!XD(I6D2ttlM)w|inT!8@+Pzx@-Qn050AA% ztH`gGY@%_BFyQltH@1$@`}xuVR?5qcznAWB&;>1?sU2yaDgs+a3&5|SB3XQP=iId$ zWhXH*!J5+Vw`S{R4o*gFnj{F3pp$_pZUy*Pj6hjepdq^R2HF< z;xy&=R}Rw9^uXApFWXmDJJSF5l>EQ(i1ijc_f1}ffYOd@7CbG(u&E&u+y1J>OQ+&ZwB5WHI2YiNIui9Z9p>`gdv7(dqNybvPenbYK2 zpGYl0Jj}LZ%~G@j<>jT(-e`#G^~76Y+MiR|U7E=xSxk2ypLxK2M7_7!DGioZb?@LZ zwSfsDji4Ja5-csrgR;^BXIvI+_F2i(Pd@~~+=2p*jozS2u2;~)3bpdTeyks`esur3 z1q;!3#$iUI1rqnJq^K|{X8yi?-uNqPHYF13XV$7%d-IcB=>=i~H#SWI5#;3g*|o*y zs+`%ia4E)ZTsY(|Opi z11{)|kNzcj*uBm1XB*CI)A1**0uaAJVYaQx#!Xke65b-w8XE_!;^uOm%H|x~IFP`4 zjYS3N@Q(f_3_{hma5AC3euUS`l^9XC^7f5kj?+7S)|H^x-7TtNcRwY~|BV+CVkmR= z9A>W@MwVwl5&JD!@QTX{&hvP%yqPz zYq!vg)^1Qbx6)4H8CrPGb?>GAPh|CET7rxN-pj=9jc&{Pb_!yT*0L#|E{@MY0nUChww&<9_bS#dQU{^*%3?A}4pTj~`91hc zZR4@hsc~0m4KkWDDi%IAykG0TYz1`;Hbk0Pg9pIK8LQw0!K=5DmYjMx{*iM_pKFCo zYN+Hbfv0S0T`}s*?G0Y2cgv#P6*xf|DZXUI`?01IUcUNYi35L_e@EJ>^&=5ROBA$x z<+k~G)kChs0BKJm2K+?cbK7`9pi5@z zDQa~aky_9n{@{QV8srn~Vk$wA>y>K~Hy?*9yo=hoXT3#X7SaUGA=1-t0&+G2W63qZG=ZLf@^Wx;}MhJ;OJmyV^vOW%xRNn62kahKAF1~kS81; z;Md&DsdkV3*XY*b%RT|2^Ne?0oddf=^Vc{fC2TH3<||t=&DpUm#1P40S*nj|$;qY# zi0^@0)5#4H0t3Y`CtD-~TaGOZHr=YuJoo{r$zvydplx59X@vV#T)PBC#FnoCQCzbe zr+*CTAg-{*_RkeW{y%5rzpgeYdH>aRKF}IQnS&dO+1tz_nf8992v1{&zvW`kdtiXC z2=#j!N!&=v~(+v9W_HN`Ym7c$Bxkvp}_($-e zz+?+VjYeM}Ex|u3;wi=ztAg?3GICBUI)ov_xTie9w4Dd9991y#^^%_WtzdmNO%Hhg>zjYaS zX{xERxo)C=D#$0@Nsm~=FB@9%JlD~&q>-3uZeJCun6Go%;D6M-r?70lT$Wy_(VbB? zN*|$9TRpdtU&|+OyMkC(-`v!JjvGf3ZtQ{@Dh@4YKrJ-~nS_(!=4U&CxCm9(IfL;$ z7cL%-w|#@h7^pEQ3jo&cH6-cD10-@K6`k!x*z`Oek0g>@U_e}P)ARuVbLPv8!6>IJ z7xbyfJc(Flz8n-uXi-O%+5qm9ia|3n}I4VeTvvu`6mh6^(hs01U=`lLUS)vp-*D>w`lOw-0#yTs&$4uFBaZHrtki{2ix%}ZH)>nWaj{`py$Pzv5>8W2wvhW3AS)N9xn);dv=^inE>t+Xu2$s(O#EOn?767 zxxsn3T{_H)IWxOEw-JQmG9hGmTqvx8(tRt)(<{ub8r6&SbS`lo8QOrjnzST1VlmM# zRHWtkk`Bd_M?2Hn93K{B;V1KMteQZWhNi{{(f7R^zq(dV7FN>D8wy6;U%3Fi8@WK+ zhsGUfwk^?(XV(X=J zPfK)^ep=ehe?I=bZB|xV0|B05q?GCuS4M|pm5*PUm(%GL56c1lRXgODy&3QR_$|vS z7YZJKQhosuc;A!Uwk~VmY)6A)3NBj)GDO;Z$;?bOo=bpj;2IsvhL#P`gU-c+!bDbi zz4rLC!&SRfx~MM6G^5kHBZ+0}xu(e*VED>xePgzIwt)9iMzz&id*p1N+F~N9;{{B} zuESTD0N~_#D=vP`ER0Wr5a@{-(6Y=E4*vT_=k52FaYLR!Ly5B&ztXCT3Rix_j>0ock>4tko!Skou z!M7+?YpF7rt}Tj@RaITJZJ}0C6dtv5zaKdBhAfk14ZQq9-w^~+alULk9Ah!)FYjIq z$yIb*T;V=k*U$^6l?!~3;eF*^*RE<_QDTQMimffHSBhg$$%PLB&Fdz>!z;x~m2;C; zRtLC4OaABk+2-6^S}a?A$J<%V_@&3$27##(syuDM`s~|Vghvo|{AZntVxdPs$0Ld3 z`FcPA=_sZ)C9^y4Ev^5BtVGi)ve<_kvyCU+5{crmkx)F|*2m&&1={zx3c$1}{uWaq z!x6#b-K6!EN~FbjPGh;x@yiCT{C} zR1R_~%zWtK8SHD8l2qo)DuOU=1kQ&ei>(H30VUiTilJ6O@PM<7z(T~^?z8mXme>~> zol64V=e`P&bN4gL#%a{gJfD3 z96&`)7Q13tXf=PnxWqfT#I2EQAR#f5OwI+EOOR7f`?BIbl<%@%e=w?7q+O&9Xun*` z5c|^xjMSzr8232_POQHMT-;W;XSpcJdC=)JExQnYwSc`9PP_mjWmH(Om>Jxaf!~>n zi`12Q2#!POQGiD$jr+xtY4;))(3M*&o44s-3RxG26bwloH9ABJo1q+98Zs?ss2(7* z3Y&7onqOy3pqn$Kxmc#U$MUK(zU2OMt};b~$9lrg8|GTdZR z80A0!!#}pZ% zLsw3bu!*8Y|Ow#>=k2kYZ1Phk#c$Z8tK|YYRX)m2EmrqXFDc z0(cW1sV5#o2W23@fexbHyL~d=u*>74=kbx0q)d|BV~VH+({fvwW^FtUqB81I3%N9u z{rJWu__lT7nUH%QA~IejB=()~S`juPpy49ey@oxWyP;{F-VX~pdh=0Bb~t@nOc2d*m_#WCTcI?Y-x(hek{;IHmX zk&#>$5n%7>1&ht#Vpp77FH%kBP&J4Tu8c>adpPoj66ItTznM(CvM#gJD2d(^7`x{@ zK5eLMNBi0BUgDry+yz2B&CTn+G;gzNPeLH1);O!9< z57F*;fHB)MgvVSwdc1m^or4dNF)v;^HUM7l4_$0r$!9OpF$>T&xnCg>IJozMRO-tH zX|4MQC=T6;%7SU=)2Co)Sq~vu%<4HTwq`~V@x3GagO#Q*yAsoBDu$wSg^m&}wFrdX z1F@5fH#~hZ&lZD~@^~q{1cd105jYf&$1GlW$&!2MV?sPFoVly#D|($*I?!7Tco=|y z&|EDxI(D6^H~{o`-KT3al0QG$i@^VKpo4MCp8mK({a}_7++u2Y>yG#d8g*h!PUR>1 z>~pzs*IfNb(RHnB1gqWCZr~jE%J{@e8@hF#0Wt7W{$RR=MXOPA=As*T>azPEyy3q! zje}3i{xt6oD;bgx7X3{)#F`3eSaYfj9?~tDkuw}e2k#ke*B>IXkGn6H))WQAJtrYK z&EjCKPACbmd~T7ayyB-=VkudESraJ04~pqexfFpn>qIxw2)@zHE$3qjXuS;$s({3}d_RQ!01J;786}Y~W()5hXAD7RF=L8~r#H%65ALU;j$yt+Z4ddRi)l}{ zn&J#*6_!4(b(h-Pq!;x$kKdWinNzue(x%$TQit*v1vE@!#p3 zaK$PmpA^W$ohT^k7T!x##|1`&T8~LTWEUW$2l!>#@}LKQzWD{&{CooAe*A-*h8R^t z{Ou>iktx?2xcgUJgUj`WIXH!;na(feeU%a=FkQLG|J+b6>JH_ntwAbL)MTyN#>!{d z;BS?b@G*~%L@1jRVL0g^^Sd+&yVX{=Xr z2Z^HYxE0J-r6NUSb!LkXOVx&bD$SeUGnYg<+Z~&=}<+(Gtn!)07Im zC#8-q!y}nhus)hZJcaV-^Gp(ZS=mtq**m`Im^}HvMWv#z7*vT1`|!UE@RP~qjNaUv zZ1`Gsh25HT(z1fe#iyb zwOar@>w$it-3oc=CFNsYz$>YI;;;+Oye842pX;S(Pft&;bb2Q`3R130&)+pSkuerG z8LA^5sWy=4JVbrykv1>3Ml&6MyCdf&6dhVqE>TAv-oX+Lc6YfR-0O84C~v!B9GhfW zcn06bmWK?cT_f@yHR;YEH~PzL$tiZmp1V@ciqWcNldft zSIOWij^B0I9d57~uw<@zSUm>{HFvPvj$#=jY=3c>oTaAx<=i_U@6Rg=e0f^=DIQVf z+=aJP7tM?`Ode(uuEoRB66e`QLA$_xj~F(c;>B*Q&7@= z6@&k1V8eI;O*)kmj%lAp7IIcOU1yGJ=E#*?!#a{Lsw8g2y@j5h?Vc@FeTy1|-5aba zf2S}j(=@wF%uiDM>0WKEB(g(ojCOhGNS`-AD3 zH~o6QW92;+M*AlpFahZHm!(LMOi&*k5pisBewi_(&VrFznU2XB&W)7X4xH-s{F;cz6`I ztngo1=z1C*$I5kU_+dIBQppYfk^V`Ov}RKNVmO5>AQs_e9rzrca+&v(KOw&V8z&DA zAk;BT8AKD3t-%n)7{ev@c`;{1qtbkjb1wf7t`ZDVMF>f#@LJGd@pH6DUP;waL}LD8 zUp^E3Nu$9W5!l>8;-UMq>PK3DsbWc}3=fE?pd-J4p(6W)oa5(=4{8tGeVl6n9CQBY zgY-JuEB251A-^i79@yKckXivrH;Y|Zy2POflh5tR?64Gl-hr&NDPjk_w(;NiDTl>> z(E7$?r{;^Ut%{hfi_bLCmKK)PS>NJ5mVKeuqbk6WWjHEbR-&~Xxo;hi)v!&wsyJODu_IbBq7rCGj_j+)4V-pDrL)I5ZUTkRZ+4HP`;cV)CdQ zHUB}X{D%)IT37I(h(E^PTrU_1!+~NfLc1Ju3W=tvUBx}|lmJGD=)E@Ak9O;4s@T3iJ+r$Nz= zVNz1mPJv}1nZ1<4XgH>oiKd1Y!^^`ddDK0WXn39BAbT9nQ8ZB2L-#T4NyWQ{B^;wo@IMsHwpQ5ijrQHQ47oh*i|tc7gsSuM z-&pmI&B`XPzVZ_B6aPj%lcV6*tvck&4svA%dLkTomQZ>qY$?K3+E6x`%Z;@_l z*0M|2K45EIijk@n3E&tgE#BVq&ILs%M^nc^@Pj$unTIw5I_JHuIlh#|V3hbt=Is)B zj}oz@!A9+vl(Toc6JY;`5MA<(FO-%isc5NYOIN-IS|XKj{4fG(cIAPi@NN6kw!XVw z_u5v>NBiuxn*+Mm%@!&r;Q0$#fp7e*=Tip99@7tUMz_m>_zuOA!|U6`8l=Xv&qW`19Y#mdX zRte*SuIo0*zz&|F)p~nGcAf^j1c|iXP%Uv{Zb(Wrrs)b1n#v0&!Mow_q^~NGqjuL= zv{g$`T3_FS?{r)ji#NWX&Fh1#GyO?hNvCqH;z#8HGIF7LFWo;l317Fq z&Lwac1Kwg#GDR1pAIQ$zcP*)p^Y@E}0BqPb4_+LMcP|+DFv?7vEz9s`#_ZUZS}=lj z{(pWGMde`!dpH8PjTW)gqazvHFRt$5JsKzH$HH~6N!^%$yEQt@(gDdJQJoT)Y#3-MW~_>Yhe-gV9Kys*u50%q z{I0t^8tCcMOHQ6ImV@E_ewY68HNy4+=-M7qJ`QKlAf+y<^AOUuBLzBXuaNbH7V^sD&JXNCA$QgZsvdt0{fW2t zOFxQfXXP2}F)b+oiyAvODThn4UX#jU;jO4cS)cm0SJ2!MB#DWBDPx7`YA|kJW^vDk zkS#R%8WcAIiqyIs#LhOlchW@(J|2v^ETQjTx_Hh{i#SlS*fW^NVm$yoW1V)ixgZJ>qJxd`H^*w6%gGTLQbT6CQ>lyDN6oEZl5@ zR>Omc2>X7jCLAXuWumd6FX1vxMB&qGMF?c%r>gF~z>orl*X-#cU7nZiLqvj}R4(o8`UM{)V1u4o%l=j>vCpF7E6jW_7^fZu6;${lO~zWW^0`1 zIa55xb=cJL0Ptq~`KJ5cyRqPTs8Dy(<09ay4I8cgZ1J|C7U0MwS1M-i@i+8x7Ywwv6Hm=)=cJ#!aCnEksc`Tvopa8BQx!04$OmlfI9Oq^nf)nbe83)IKE$7vF5^iy(<& zP0El7a+?Z*hu(a6y)9CdXNUvvp+va$D(rt1U7_PWj3WV`h~esGZn;~hTJ~jL%b#eUJ5$6aHP{{d9W;}k^y%5m?P;2?D z^G;DB_HB+-!Wv^dxSiE}Ise#S-uK%8#zA=Y2^YR%NrhHNk-Fm?6#k!x9e8mZ2kjC| zl|RL$Mpo+pH&(Skg9_xhg+g`lx+ekzuGBC~aQl|*UzbaH&tq}yW2eQ;^@m&`>420A zd3GR2Y2vtYvLGY~Y9EvPf_r|0iRAlp)FEtN@qFdMpV8ef`Q3S)v1`9%jzd@VtTvjg zW~^XeK?v?Bq zk%pK$*wQEBf9BJwvS|J)ee~nw-T)!8JkUfg+^d{RY>;iY=kkJu^LNa}g7zdN_79}_ zsqJ7O{5#b*hk_eE;ri0{tLB!&o5XKE%8*!>4vQt1TFBzVu0opCzxH ze3cERp~lAmeCu3wo)G(%xbZOoHHOLkVF2w zkCSa-nn>mFVN7o2kHDB8>-TJmtCb}M^WP?iZ(-BMeu&CHLkS@~T^R6}li6UJy^3Ou zi92*WYzXJg__W$)jh^)$Rvd$^&_iY}-)gNrM_u|*UQ?QhhCkGZoh^h2@{0L0furKigB7gvqKgsKqfj zv0=)H58Ijrh$b=i;FCZNn?_BXYXwg>UFLCv@}+p5-4c0pq*W{UUfxq}Tx=5E2AuIG zIi`CE6y_FmSTk)8yX^(8A192A#kLr)z8Fa9>;B%B?m*OPNrLe z_#9o;mv?;bV$F29XpAG~FEL@TxsMKdue|U+Y|8RK)`iyaH^W6nwh|&_h{L zJd0dO7@VIyi}-$7(<{J)^8On44=yfNLsPTdxTRn9z|N(rP^e+t9oF3lQ&hsiI`k%G zCsjNSc#;?-tjn=!J+9JUAi(|fw@teK_Ac8tkA17PFy|#(Q1ALT4pXqw)y)ijepe() zf2NytYDiHlBhnc51>T>Fn{I%UXK0f3@yE@bkN!|Dosmjy8?YEQEe&VL+W4+sZdquQ z?FqzdK5a+=SyCSE{4zJoA#f`zQRW89ie{)~OXZ0HE&Am2T!!A_TO>$>W?q7!1ih z7!%mSix^p2#8RngD&3que!*tA(Z{{FRU*^=M``4LsD~#!Y2=3{;F0kD@A__>HdoDf z2B?nLDq-8|TxFIL6~F02i6isK&a=O#uX(NxrkpFk(K4el#Xe8n{b3#9aK5N6>0HvP#;(KUq(05I z4f#xc=vvSJoI2<}lR`my=%HIhSC4elpOm8 z^^2uJzDA+&59kMKW!qsud4$ARnEa+`MOd4yE#K>Xhv3!m6k)5?Jxjqtrp&~+?b?V6 z+PyY8s-?ShiF!;H*O2+DzVrG!mZeXn+De6M;6m}rLxsRsN#tHY$KG8r>oQ<+jm=DGDnIS zB=I$D(koY!1*Q$f5_^)8E3vG*n}kjBv>Hv)<@^Ew2_?GKG;hHh%eNVrj5F+A>C^GW zdKa|s39bprJT6zCAZNz30Zu(@S7@Xm54yVAYL9y^bCNnlO&{DLCPO!`FuX~VB+eIm z(Jn-|OqurkZQbp|c;?_;|JVvET|qWTRW(szh0KYLn~k$n(qumlRUam85h!8Kwf9*b z+`4D-Stz5wwyHsoZZ~v~O4rg6r4o zX^Jt(n_5~v2GLv}j9|)W9J7^!B|ozL7#@!i9FNSKa6O6^R>ZO$ua!*Vw0Xv9;Avx2 zFHtF1G1RyZ4^P>Hw|_W!U9W5$Gu`(VH1C`E1$ESD;dpZOZB(aGaV9$a)kD$)=F6_n z{RQQ(r)na3j73H1JedB`_CK9BTZQMag6-XZfOnq|DMp>F770c_8g_@}w%rVun9?_t1wA#idJ2)5KhDKzwT&+XxGHH1H>K6?o_rsJvod=~yzeZiGpj7f; z)U$*wx1gi?iQ}6p^-7aodicGC220c%#9#nlGH+h#!tPx!h=N3;-ipxI!TZpw=P;Ll z+dkXtM39dhD?>BgLp+tp%lme3qo@7cTW?dJw&U8aHd{e?R&wW@V}DP|YM*9Qr+)hO z$9gCK>0>-zB9-8ZQIdRL?tQF01)eX8Rw%)HUaa9uTEnu$(UyrD-akm3|LY#-%0WG} zJdK36HreUM_l84eUDRDD$RsiR*tA8n6sfQ?xGC12`E1P6k|klD1)&Nd0=eq_^S4%& zTDX3h2ZZ)ihWVl`!fv-id$3P7MDv#J;Qg2=TyE5nHO=GLEK~V+N^>v+3mnoI98gc_ zs$n*gD|hm$;0|lQ9A&t@O*YCMi0YdUbDLc6b4eJ%m(ZuoS8gA!w*hL+z{Mrqqz>(7 z6WyVbZ~U;{ut8rJnaZ5D4p$YoSTqhYHtl7%TRsACHS<&LpsuYnD5$7Sym2EB@;|R~ zypsJ&9(;33`4k@fL>7YOMeO%wxF|}cTpQ&~olV6eoY8dpgk*c{&O#9wXnUrJhNAC! z!<6XwLS^_1_{1#DMGQ}ixieXxXE3xi%a1?I>j+@AJ0xM8ww7fpdQDUO8=-7}?fhB@(I#cWHdyU*fVo=gAg7+ItBDu}=^bx*NUgoXA(s@h5NDO-hZlRpR#>h% z9~;-G-SIm?99?>Bnn-E9*So{;PGCT!1ZjevsJ#rIMgPGpBgDZZ8i z+OJ>3xD2O=Va}9*dn09}e|jeph;qnPbL2cVE7`HX#Q7StIaRK=c^ySt<#-Pf+b|l8 z1T}S%bbdz-cOdEdkSM*%Pcbtb-J;g>#PXx0LVa>4v#FJel34QCS038ePc-}Us>V4} zlMzJ0{to_mDCsWIm*!S)5^)qnBhi)`>3k)0=KApFx&E+6|H1Jrh^w9YnZ)L{5nf?y zW7L={PyDd6ZBW1kb&X2m_HxMs4w5lX%Dzfi*rFFz(xQ zjChDRjNb4g@{ET8{*nn5Tyam^@Xbo=P4}O#_U{^Sh&hzBJG?TkoxOQQZ(w5UQ@)BW zJ2y*B9v>@FL%mL6P51#SeC@F4R%$a|&t#lI6UcobeLNqFc_wD+h8FBVl_t14{9l73 z?DRH{Xt%K8oJ z^wE?`j#%131jf7mubqtl;@*f}HaP);Qlr^ICcR8KN29nE4gHi{ z>OcJr+${#BEUymqb4^L>a{(y7wO$_=qb^zeAepeJ$k7S}1_ic1549EVdBOUQtpm|N zy@cWoBoplOO|nmnrDD+5P+3X42;iT4fo`^iFZSE^iQE>*_UDTqT^+!oILGE-@FZ*8 z{kvH2e3h9;fFOs{R&;B6V_WGY=&rQx;PMc&!Aw!l3 zC?6%)_%Mz7p*e9OLvTBsQuY~*R@L{nrRR)tm%u}@5)V`e)J2oLT({|ao|f~t*YmT} zb6=(@%hu#jTCd2tfS$o;#ora;$?4G_NTbq@iOKoiv)kbq>#T-0>Fv z`sC6@tN3+3fxo?7V(aPK48&vcTD+$h%oO}j>cmZxrWyR6re}0a8ssp>W_k}!FJo$x zSY%sdhU!k^HSr<%B7|>6S;`=bEXLy zM_!a#;jaRMq^(u%=c&f}C}26c_GuIGO@CS&K4O6)&E-mh|qkq))byyEwHKG z!Xbpe92OzX14VtsO!$n|O#tWhOO)WEP*qZbsC+|TlafP)wNyjPmX}(c9RLcleVJ9# zl)S}*XBE5{;n(XK7$6rGj*s=$o4=t)<68Y|azIs8Um-#vIj{ikNJ3CB8ucL?QCY!% z4#Co8uzH)Qw7ch3Z9T-Dh74sP#PzUW<-rSQ&=8+-@XY z()FvSGPZ1LYBVa2`1$BBVq>FvTwljG`bob@6nskY)^A}t2m(_!99bD<7Yxti3FDzX zm=1^hA>tWfz9|jooklT+5-9e8pd-oMW+aWRmTo>OM~FjG=TP13DHVn!(_^00B|9Ut{1Nmn9Z@u2wqcc2}&6`Zez|mYgi*h~q zmM@c0*iMZQ*vnB$t}L%SSl$Ll-ZD6?Wrq?Nnx7hG6kM9N&gl=eRAb;r+fn9=!uy7} z_VYcag{*5YT4!F&1LaR*8MKpyH zQr0d!(9NR|6Hak|QW7}rOwr#u9v2EMz*tTuwRIj!7d(JoZ zyVv)p#;6*p%5&@Dob#S)z3;N|2Yz=So@cXKCz|YfH_>#{;dHotz{7fcM&t0j3#?Vk zEMi?DU6Cxy`JH?c$)xeo?xx)K3bf7+P~Rz_b};$Yb{^Qim^W=nT~p(_Oq~kIBj>#s zjCHBre^STr8jq1yWow-k%}j}$i%^>{$=n`Bc&s1u%09xgWHVug&;es;tT4NgNs4ug z$ts7UzE<+S5J z%HT6;Ku9^gV{H-;Cm!nxW6K&sVX>G3$0#Hbjs}LMYHk;U0G zW77hgcE5m~4_dGavX4<#2X_I17GlLP7|a9?sg7N{pY)->b8JYw=#-(0kvrSGJFUGP zrSh4~F&+Vs9cYRlfZox0?J6%X)ncm`=F;6NL+t$IqIHK-UGEPN&<}CsSF)9xH>#urxvE{rRgsylwRbKNA_lSBdNrF6d@{zXszLBI1`qMLKgau@#Kkjw_`iwg$nsH zes6B_N3ZCfcOycsPf#(kHFlg^KLJ>i6$iYq*SG7Ch(M7ArTR-~yf&JXChKXe4{lc} zXOx1|0z1HMWjjL>a>W9CXdfE-Ll+&Tw+wg$!Ei_Dmj`W5-l$v#rB_kuF4-gx2VNbOR3B!&mm<&D-!^9GZ9mp! zD+JZva8Xs%w}Zt`#~Dm-TgLSUIS%bq%b!WCKz6*#H99GYR#oVv)$)tpMmLhJ@Opnq zsfo~$Jb&Ps&d+~8rMvEE1zf)RvIu{rQ$7{1APajATXE(a-MsRUDDiV&Et|KCe-1Gn;XSMS8zmqmXRR3rjB+&ONRo zESQRKHJp?=8U7Jh(haslVtdhR%wd1WF~yre4$TT4US*?GB`a`jN!6c>&4ju>)$?wN z^M%7zjXsa{GTQ&*J$^X;*FxYhbIWXy=|mzlzHt8$g7s$S;SblF*5P4FWtGaa<+nX2 zcNX-~q~K?VBEywk!uH9BvP9|VUvyN%BbB(VE*I<1A!n9ppqF70j$1~74IZmD?(6p0 zD1=sFP!%l2l$Xo*cu>3(PFV8tlTlBFd38C)p z`6s)FMD7{~DmO%j^T%@CXzpfyq0r)~ZWS$s2@b{(cI%`pu@YA!cQ}AlJ60ynQgC=c zqv|?f8eb_P83Ke#O__+y;jKG5e`oT>TB3b_Lh7Op@VrU{m6|R)^lU4Q=JCb96<>6X zwOZV@TYk8Fj3!x>Iyvs@ruC-EWg)y8Q=~U}910@?m5&}r`p&z@L zp*o)|YBG3&HO8z5LW6~r8va8)0D!#mPj(aMH(>!6L#?M7s2}{Otg*L8^x{Ro8yPBs;rR&?7QPLhjS1>5Do99UC92?Xxqx`KqYGe zBefXf@#uB{^``uWxJ}mW@w}i^%iJ;r3mT?E|9A>oLq`PX;MRHR&BV#mP}a07Q?Se; z5oMdN2CZC|qr3IL1zRxGa5kL@n?lrN>BPCLA6DS@2ed`H?*QpU=;JGpwk)OLxs7IG z1kdC@XAq$&-81NA+Z8SzeTh|v68^>bM?6Du%wT~_H*}s;nLDpRl6w0mPHedRu6xZ& zDgZ#i@LqR)sKS)<=~ponb(4uidHY%^>o_uaDYuxtZlZRIz(MKj0Ra9%N%>|^0au_z zg&ISwoy}kvXzBjYy;!FqzCHM2_wz$^&1P?}lES~gs6V(b8OTn)Ftd^3fd&9rB+W(D30nq8=5BEa!_z`J9AqXcal|sq&4jO(`>lV=r6PaDbrMc)* zr7B!%!wH)2%badEkpU~>y28l(JSCdwz8Eg`GLC_71}n8G?4jjq2RO4c_N zJqzI%S&D8q2X?aZz`*&vA_kzmiJl*s)u{5~%#~RM_;xA*;5rM1Ys%n`?F3AByZ{(Q zm2}D-sg4Geg%YU{#IKOyfVOUXZXjA08{cOP9jx5ln)@B9P@Og`;n62>A{c%G!<5uE+lW7F9&xsS!U0UHLq7q9q*MCj-8NgwLAS+#QyFv5m1-uYScTN~ z+iR?dBP+}-D)QZ)ssWK$mq4nkJEncy59!#s0N+zaJT_ zDR6jP_x+s{4}cvVPNuv)vffciy}M_^%;=-tzc&K= zTzZZeI#5HFneScG<_Et|V+R0hYmUJj8@OrjmETe5&Nyt<;$+&Ex7?0dSr3%Le*Z8%( zvy;*0K($6QDou>IXz85IT28g$VrYN{WvUHdkfFSqox-4QD!)cDZ;F9kr!mqdP{sYfPUpHV`PW92Jzzz$DF!Vb`JEgKS#5OX5<#i`c2r zn72seEn}#+)?w%|Yq@{17hXQ)nn)t;oP|OCwZ4#E)ug0Mrau56ov9?5VGe`noXRXW zI-y#9rBoB3gIM}ifaLdYEdZY_06=rP5E$bNpSwcUQenAQ`avnPM8NZ7CunJHN`t_O zT`i}|U@N>2xkPGV{c7O{45lOPQ-}9%vV9$WMp1q4C?WFLiSDNy#`1Uq7C^`emTmvI zQ-EuESA852Z}Ui&;fOQ^I4G5j##eJ5LcltC;R@6JYeK=9LbvoW6^TULuPJ_auH%`c z)6$4TBWxq;lf<**2Kfei@ZscnSxvZvqKR*&V`FUlqy8Z=Am@C*qPoPVU(F!7omcoV z4yTcuXkKN1-^!~p2=t3Mx~>Q51`@1+pLV3{@p(a&`yIJ|!S?eZ<%nJfm9-i9J@c}o z9)1xIK$#p5ft~-s?v-?+;_&fdTWT?nd}Z1?R>&Hpi_g%lKBP9;J7j7 z{`wtJhcW=HI8i|hj8heJF7%`D_s`3@*}`1J4l}m)3x&Zt(+NDx285^{B5@CQY0lui zUz<6$xdmRXhZT!{ziI%mb+|kcIA6q&hYzEd-oW0?-ixa-R?AH=AX|n&aTz z6L76I1Y$*Hr;&Op>x_-l>FeLlSBnQ<7qF&!7KyA-o;M47yE@;)6#g~u!2MuR*hR#^-#jy*8#&zq#DmMw6 zI8|AYHIWoMJ_fj$=F9SEQSbYeS|-xmrV*|>0v^xL&K%@yt4X0E%iyOPm08;ER~yY? z5>HZht`jI2A76uJc-~2x=2JbspIlR|)AI82bgySHJC&SH-K04jZqKDT*!#FU8H}PS zJHE&_DJ~Sat)7=!995_$msrre-i~a+OXDu4(8T_*y{|ewx15EkJEV&}osl|}p%j>p zlr2-{blgjo#xqYK3czGFQ;KPg+qql5t@Z}RuA~~eczc7Fvf{N`-~mvq@lO1Qq1h^} zNY_DCgfK?**{wT@aii1`eAEj}&GReE90MamBO|>Ki%;dU5{iC`O7*%R@6t?{qTkEPa^(i`o z+c;nP)>OHXn$RTmwOpwV;6u3?gbO3Fvz4v|V^P7aM&fo@9LNcNtYwqe3&xS*ttm*( zmFp~%uji>arpDGJ)5@cHel?r+(P_kq&f+Os{ry|hWozvCR_SzDzvA1vMk%w#(c-PP zGBzi7v}g?^-qD@GeQOk>)4`*AndRu+;QM>;zH4lx$4yTmG6s(~in+^X{e8s@u)OBU zn*Aw8loI+#+-aXI`OYl1qy7(EQn6p0E<};|j|Jw&7h2{$2gh}oN~Z%LVfa2;wJ?Y; z#g4Lt!&wZ7NG`^2ExR^Pms|42aXhj+nSOnPOQH7rFvqTgu|yO4X|+D<&MXN^ z8gw2k8&y_6@i@w9BG2+TC&Ii=rb;l!f3^YDgZ%a_Th#9_mX#M<#%DM)i8#4Q1WP4| z{D8yfgXv|(HO!H$>X`}3QIDhEUcNnK^w~yfiAoK7-l0iWxSaC@-8?*u@guU3@#O*U ze%azv6Z_%zOshs?%Q!>lDDcOyH5s`LBv?fzg0ZF{~2+>5_Y2T9I4G|&dEn2vE_SXBa?`+|kiMg9-4U~r<8NUfmoX3(nzhbwj#{6F zw+PBL%u&H=*CO1Wy>iI1S6|qT2VHI+(8`qRL}RiVJ^1Dd#j?Go_||exXq~@#R5aRr z5_OoDRGua7gh{okRJ&wsoprl>))BNm;vv)>(A9c$2z%iz=KBoCV^6C8|Mb0}LCjl3 zZX_trtjZimc4Fm;L{PVG^i23XtQ2asB8Sjt6Ti3^GzLXW#X@ILHdsBL^HZMlwJ52S z%T1VcH1g4zjwg8 zdw8|2Mn1k3(6}-fk=A?X(TsmM6A6h3ug*Oi-m;0a6LMJu9)KBW_B-r_eltj71rSzz za^%B{^L|~d)gf-2GXY&>Gs>%9jJMm9Je+VViq=buX-|uADmUu3dFR#Zvda2LuLNia>fzOj6dNuZ*q4kX0T^;{>NJ$^mIt-f~bqQu@B}o z)=b`~+&ok0$%TOG2>Zry1(&njVlKhCQj2=Jlk2Z%+a&>G^z7a7Z9@v>cW{1h5F4js zni}LJaX6h?Atq&Bt52#1+QGz?LejB=>hHc_aGdXTf^1T4&p@-A5D@&y^^(q|+{$Oi z+X#S^J20MdN2**hUlCWrh-}5wzIx4vP-HC`J845W0!_-uhUxcU^cP}iCLs#a&|f@O z^ed4~fg<-7-!s=ZnFeebzwmg%C0A%s6!c;^nZ5MHcHW>ujot_zb*ceM4utw4p%zEY z9D4!RQ)QZ>$H!ox7l`+5UWYo(p8G$G59S=#igOqxh@?pUdIK3uzxBB{Y@M^O3SOwG zilYR^v5*!V@Yo(TC*pYZtWiBF#b`(+A>$1tBID!xJ+#FbW@XD&hWT_#kC7jVG+|n= zw@|1S!gl-h4M`je&}h+pJqlvXg3$jHzTuv(eB9{;7%6dMIt{0H(;Q7Og-z6G@2~I;7>at0Gt&d z3Heus))auY9WF}xjq-*7P6pHSbAU%cBhvMjvlNWcZ*MGnW5}z)M@=!pRM`v2?`&@~ z*g?4i@#tiaeA4$q3@Ws$ATpUPq<9p!`@-_+#I?q^0ojE0(=tY}Q;};yvxa-~b`kju z&Pf(ugK`31x?{iDVYYd>I|o&)I&aS^G!kDDcxxft9n#c{5^{zrtbih)UZt{D>&kMX zSA$oKL2hIAhlX+h)8G+sIRpBX1+Y9Q3Db><@1Y+*znT%6D4x&ZJb=)~Ts1$@qGjs= z2AG%63&Su6>a+$a-TZK&UA@+V0O1mYwn<@cOR8U>vp13fDtOh));Sz~h)qCH<3%lY!k#O_WR4^t&AsFSaY7bidU6%rM^~S%13mEX_nC zO9g%(z5dGB0ibA{Erqd6nNCq+u@$o`QR?CxQGE|LeZuAnJuE~2e8m%sRj+d=!+Q67 z34tjUz31iSRmuW&?>2-foG2_>J!-e#TcV=WEX+TFRo8jDj($O}F+UesYeK0-B@L52 zhW$mOU=v~0Y#_l;tli}%dSTw1Qs)P@7Bq#fbtx**k~;yXt?2pK$87ey>k}`I!wFDW zI}+dj_2Ie^76nknUFAuYuP_&``C0Ujzyn45Br}^YRX+xVO>@R8_B@qPoStO~iWjw^(K`}Lyh znOxO=VL5Eej_FgubdBa&7&K6$=UbWpU}O*;pS* z4@@-Cu3>Pz+@ED4pq98Z^>91}JN*j6Rk~a%jJgh?OjCBL>B(lt<@woXP#p3z@U^&& zBM=AG146eIuW+XqWgw!Pf+Pf_BSc6l>mH9*=YgNqk&6CU6Cl52>@a!x+A@3X-LYaB zwleFHxUnecb94BxUQC7^$yGdKi_S8z(e?@S@$~h;8^u@&m))J?XN4CD8(jgC?)xc3 zu~rGs2|r9PX#1xlzIG&ob|>{bXV|5OeJ>h)fzlHVjDC{c&73+E91KK3k9^dLvM)2Y z!rBm@#exmE(VYU&Wf)$shbr{Q#!9KMVk)Cs@Ebm%ozZ*YIawYbvmi>AS>bk%YLQ6;XK6>nHCELY$)jz!Jtk zWqc!HE1>t)SyZ3hz2h=y=TS!0%PII7a)DByF`iCA5o>#Nu^u8|tqTp0!kA1ik7cul zDLIdcQ?Kjg-VS;%za|jJBDxmkP(q0ODOS9UKC4iv_TE-{?=Iyc4M=myzGdjJnqT3B zlTn{m#E(McGTJ;9Lzh1E5XnxN9gDVE{nGxH%ZK7ktBd~F58AL^_vm{ky8Cc*C$!jM zn@)eopn;GTgAda!+vjh7SfhZjCcL;(j&kE?&DsA85F-n1O z6(4W7fiZEJ%{YO3?|q<3#lFN8P7ON$c9t&^|XJ%z982y+~}SCArv525edvku#pe#Ra#ZQe0&5D#ZyaY zQEv@JI%D`h<@@Nz|{SnoRXKDyOl6mC~@fY0wTD`v@iGTdEn`( z>uf9|zgud3u@p3nSa@pIJxex|3d5@KZsT^a=;H`72f(8n6;vpFdL{5Ft!z5_X?T6p zFhiid`IHmDiB}|MSqA4GweijSpTj{$zd$5HdE+Q^0u~hJ3bmVEEmxZ>QMShwYZ|GjMCo*Ps~@UskMsR@lt7upVI#%xVR-=6 zDWZ3(*K9Wwy^7xYQ^zh@+*=bba6`UyTI|YDCsO7)82AA$l;ncN>ZZv~b>_a&0@x`^ z@{dj;ymts*iS<$W`& z901!yKwXZ?Fc%61mKr=D_m?Bx-A8$NmQ6>thv2)r(*WAJ-OpdU6f&UiVT3j2l}jFu z+T2}qoNClTnWU~Cuy|kY{V%?*H@j(~=!f6C8(6cmC#ca$^Am8RJiL3zVbIRJw}FO4 zOZbe2zrQ;6dFW_5J!;S03V?R>fO_RwhlH-P0<)XlcAP#7+(ic>F;a?GP{PGiSbe9_ zoNVEKuA;@ikM`J(+93|Q-TubT@0#5`u}m4ufLU)d3k7autk5wW{}A?TuQcx#>Aht% zEiBM0VDq%{bjM8AX!-g#8>5i`LrCg~zWK{uO+00{{=iZa0Iv@LAk6GYDVNBEENXTG z3gAn4O_{^-IPpsY45KLx=mlhRW{P)`(Mg*VKNAT>r4+JbzJfQ5lUPa2*znbufqX(p?GCc;_Zq5esSbE>%n`>Z* z?-=uNJ5S)u+Uk?*k@NM8Q>|}T$nzyhu`_Wdd( zbd^kg)3;MQ$1Z@&xoq0aoUc^~b0CD^&cEMVBaUpI1k=ntSBilv=P0HV%sik!ffxag zlggyPEXck{A1ue8f10D*bJ;h=;t=F~tQQLAt0fl^nm228RwV#2>kqCfWG1v0#yfD-UAy3H4 zC;if*-S3a!e#-|YujCm#*H(MY;!wfYX6i{sX7#(wlE;K_>dMxZof7uUMgO)SOX*x| znZy1R;&=Qkq{hLq{IDvJpe0|JO}uFPE!6ZITalu828QNz%9DP)meY7g?HE7HIU~<_ z)Sw9NoVj8)*(@dLykS{G+$A>g=_!wh(Qx#z^vq!NgG-P4O1i5ecI`27Kl*^%58_dglOmjJx%MTevjEd_y;=fABi!CYai6#CY01@NsHRSJasGX} zS-kskZ0EAzv9RMk8!klCTNfCfiKQYBYpIK(eX*%+om#a@TeX5D=kOF$y<_v5GTMz=bmf&N(fzjC#02f3T62=xWMpZ)b zZ%RF(iMqY%8KVj_IJH{Nb1hYywebXV&hkOpBS~30o-m2Y+)A_0_`J{$e*G=)lW5>^ z&0rBX>!zNXU7=h4gXj-Qn=;+ED1JEEb>^<6Hlw;x7R4OUFoQptD@E8l5;N-*F4sgZ z62vrKp(+^DihhgM`>BmWbOf%g6^m=wm6<^l()D2>Bl|7#3-|IM_-q=}kyXN|*m0-( zyU0j}jnJvbRIY?d#m$se^46Wg=t5B`C10WbHy6PN8~kCIz<^;%h64w;Ge z-8%e^a3Re*%Ma~!P#s`j5V1SNbIsSt>6F6WYN! zSiVuQU{`t;p9lWMMjPVf6lYBG$PWM$lQ_)&kTgX=!h==|n)7V4?uWrCFE%T z9g+o5EAcq;@7@|qy|v`)EP=J-Kg5X0}XOA7Pzt;m`bxAACDio z9q4gAr*{3XURbQ!-NJ+~oC8TDgapPJTZ2p%-wIC1bkuht-^+;KL<4r zdkcW-B=G*kVK9nR1 z&Q!9ouvkvGD+eF(x9=;-1PlsLf85Gq#^WEcO32t2$X}`FY3#eQJ04!}T4Dk<+2Qz| zGw-BC0}{z?UF0^5C-;n*pzR!zp)CxZVfP$GmI6Wst!5;-(kuVxTe4#ic^i)rZ4p7q zu{t@%O}Or3R7PDc@PqTysqL@5&aIR5(sQP2o$Hh+>ho{0q3KBE*B-Uv*wQi&26a~uJrUq`HI!&?EU}wH`dT70+!9yGQfUB# z=)&&uMjVgbq%G#2%az0bYwCkkb?PHBixsp>3}QIl6#x!>e}5<9;82r5CQ?bQq4z4u zv!FyVHYcD~Z+OyN-|ca0x6WoL^ZV8lKTC!;cBG&1bG~ee2b!jFK=B_5g$fkF7$2OU zt<8dOJ?$BXzrW5x0vAlhkLv&wPmXKx^2Rmq(;GykzePf|8sCaATAT=_+)v^$0h7nx zfN9xPN=M7rP0a`^iQ7IuT`Qu&iHOPaU`3TzJ0fdb1OuWPZm{wrHSA6cP@&3SkP9Au ztqoGYSA9Jy$dR1(Y#7mLfj8*5#r-AMN418*X1IXSCWJR(e1{VtyFK5D)nq;(7c^ZA zX^ZY3;0d&t7fN9_)`J5)re~hIg?2KHW=?;OrFM^zXFH9O#u>v(0crrT5sz2$Stb3+ zsDs{6`(w$GRa8}`{{&(sghxf{<>z;Rk27t*5k<9T;S zSMQ;nz(@gif!-lCUb}Lb1yIz<*8utJz)lp%d`|8y%^F=K+-#W2`hRt0MvQ3#{7XVS zlxmT{0L{1=B<)JBR!wX0sS$GINTIEE z(7BTYkhej*dL6DX<$khX;+fEf5ews!fTog=-p|NP%|qZ_$xy|_u`}_TXKi`c^~{78 zej^KKo+fX&7Ky&C(5J;PQ~%HG5dxsCH>-ci1jUL#W65nLZVBQ@V0iHukuC7y3FuZz ztJQjbH92M;>wD2V5^&2j{p$}a$pP&(Rn+~Dzur*^`6`5nYV$=<#WMhBA1Sa))s)1N zjO%&f!z@5)G8I~L(;I=9h53SSZjx4#J}zXx0?8xm*}6blxUQv8r?1bvMll z3{RJI{pO;E+PKE$`Sk(q%juSd@j$7K^Y-ckl1ANO!i`V{?*I9Qj_=L8;jAqvF$}S` z4mBu+-IGX0(@Z2<#jH%EIN!RZoR5aZ%ad_Ir)+EIUauAR&q+rt7qnLU7a&-l7hxA$ zmLeHnn0<-U%3Z-f*2I?vs(NY$9jyiN&%16(LOr(^FycpR;IWT$O4NyL7Ck4YD#{6{qrP(X{y%EaNP-D=~4w& zNMq+5tnAMkSX=_*4cpcz{?@r64FmF?E?{Uo+JYo?y}Ir(D<&-rgySnN@kHL$5jT+J z*R{2n!-rFUBPA-_e^z9CHW{d(IEU4X51x!l^M!>L+H8ZChjj5{a``rV(>p*5 zz#dDHa6!X?gbWeTlYDuJ8}2U zxWFPeTa-IyOYWm2}69GDHWOt>n&zcYK;dxw!_X?>`1m%05*yg6IeCF zBEitp+VhtzD_eLj=d`o&Y`eXA+xq(4b zr*dYLs5-hATS^chjFPgo{&6L z^2naJjq>H&>i_$k0DLqZ$c42v!2ZHdPn+2GxdAvs{UQFYWMru>3P*ODe}7GE5=_gf zQW`--oconxD70Dj?~iSxeW$?&wZMVw_kf`~jaGx#=&H1Vzqd$jsdUkCX(R&$j2LOg zNTv#CkoyW61{7gpg{MG%AEeb=?!tpxcF0+^aIWT?%SWWRuEAZHOoCm*=>oPE9?Re7 zJ*;5?E`pMCzgnRCDdv+X^0wV4;Cgk1+^QA)-BpORaAp`r{k>M8v)!#*2w~(;$(A%# zVD9%SQtPS96_qOb+VPkE|9-;6x_{#pfa<3Tz-!ZSo}nUnlIlE^4YUQj4Ml{~{2du| z(@1nHAFk|m4+)O#WsiC>{}BRI2=&$65JXaLg-N|!6F8KRf-if!ko-78KC(XEhPMuq z%+YN{AOD8fvzNskBr=q)4>BSJv^lFHg=c;Bja|~wxQI(QJ54-treG z4Hn}72i9_pECE_dp(;owK7K5}F8(n?#|6oy>IwN)GCQP^*AmoC7EiUvfb%zdyC)Avqf{q$VNkjMD9X1>DYPc;)&?es#Gd z+cH@4Jl8u=(qm8dzi$P?b(AZC95Un9u))oBI*htR9PafCOJbLC|1NA~f*qmuc$9H& zs=H>ozm0IdDo7>IA~|GUe#U!(q0ql=Glz6{DldgA+c6Nbe4O6KBSrTvCQv3NDapGU zSRuW@dfNWDekfNfCXbEm7ctqcoECZu4N1!M$*gE8?p%i;`W!1mx^s)9}Qr;i2B`S&|&rJJ`=51so;pZKa z%KmUzpGp9Pq@a-C*sw0!+TJbY5HmrNl&&wGIhw zv@fR8Wo;9?CV$KkqhBJaF9J9=%>syI*7TL_MiG+NtKa!T-ZUoUp!+y^p-deb$6OT0; zRYY2gNbY&$-A6h6x8}qa7_bCn5(|NAapg$AxpZc8w z8iZRH(GUa|(c~U7z{k282awEgpeY6tfHN9yTrE}eH6tdYzRG!~0SJwk{?Ni8 zq|6Zr9FW!nqrL#W4mB2iGkW1o0Ar9L3aC|41AiUdVvBbU4N@QG8uKBM_>Lcnb)sgiZCDrlPAm_0r_a- z=->i^{DT+IrbV3;|E?81?YGCX*cuNFOQ$WK@M`d954Dqm6k2lj zbT~VN0xo%h)4|S18%IfU{!V2v*_2l>ynn?V6~L3E+A;^5Q}2^19!hO0!!C?vx$DDUqHw@yx! z$#`mJ1}vVLz3#sjPX(Ivuw@}h3b1$*Ki4q-UOZ$*S66@2B=;i&Y`UoK8?5zrYc0W| zt|2B8Vuvv~DXM7w0n3r(x)5N-b7meNm;=}$B5D_4#*RTjNob@`$$3DsE+tO9U2Ks; zc(SC!h)xMnIHTNcj}SD_GkF%nI|{Qv=;%C9UpYvte!jT-_20Yj3@H==-mln${k&Yb zZx0T;Cu)+(`S}XwzgXjQq^s-e;2-0^FwpVf^|z6?&iB)tAue~~WmSgGUJ5dR)4Dx+R0h+-!(lGg`^fDss08M`2+q*PgCF3@R( z1!ZZZ)9d%?g8eTGb`FrBd`_lc)8&1Gty3suP@_7)n7g_ z%Mq`G6pyZn>i%0wYi2}G?v!6D3%ep9c{;P=P3@va#4-nsx(eoX) zNlJL{t0ctT<(21sf3iL@^2`Tr6cbOVq&?WJ3_|I@y-+?l2$fT%6FMx0Mr%0fW8WWh z=Q;vbPFYFX#3vC0M~>ROXbCfD$=Qwa1VqgK39>M2x+5Z%D``U`P|2fLsst%DFy{9> z?PYlwOx5quKflXK9=igy<*^z*Q32ry54u^d$Lj)DPBeM_eg*+y^G+cS-}2ToR}AX9 zVDsBLx#awQ?;5awW6QyaCv|-x6GX{Q*-&QO`j_i$J%mh;L!JZc6&Jp`dI%mo@Di$S zCazaq0eCz&uL@B7P7<77+%|Z1frsU4lG}g9rqz#=5xtH${qMSYe)YoL>+A5$FGjvo zMU;(^`Id?cs-w&CYYoJCQ%k@$MaJW)z@eh{gJl!koXhr`|Jp2E(D`>Q3+QO^kLKOz zBzt^+JF#v~5E0by;aYK-Bo#DG5q$~B7!w7;Pqi=07s=U6)?lnffHvIGJ{M5xE|PwjX0jn0Zbm&j7dX}Y@C%rTJc)675cJH zqL!38z&z=WKuw-OPKypif3_(g2t@*JhpVBk6h>)KW_R2XVZR^+hk2l5$n<+wFJ8A6 zo3r`Wv`6Xq?(HYDB@6id;ag0nQ(PYDE%icbBU)W;7q9l9k|4=;(0!PHAGg0p^luN) zT_(~E%93Y1u?ISt*(Fdz_MziHGR?!g-eV-yg*`LgoPdlhj}!$^?;MF2O715j+fm-j zK+$r;{nvc8LbZ=OSSg5CPcfH(webFVYQiL>KZb<6u$*<#8X*p#JB!__naLHJ*T)L6 z_YtD&NyNo$U5~tdq-Q2HH0FWi{Qw2CXzzF2U}AUb77d+G3l; zI2^=?<3^ilod?@MFzQjG8h#M#^|JjB93fNytkrW9e|r5Z<5i}=%RN`@dxoFh-GiNU z)*9^J)A*kjQvn$m<_k1>xRF&m`8I_$`X8=<{kH~H% zIZ4ke(xCoF!)pS-8Pb}@_}@P$S8ue!Bm-((iCvVbwI-rgCNEwnObs1IJeg0>YI(VY zD8hXQBp%)FEI^x0Lp}axm)p;Z)qF6~r`>_M1~3kh4rM+3m{@NP0n_}5Sncfw3)epX zwv_b50y4=P4JQFUkH}kT++7jw`_}*8<^I1Cld&&Qu}h4SCTN;`hyhojVk6f~FnIJO zYwPRU_TExnd4PM*F(S}&ulR(}3Za`~dr|tvWfeD66|kWRzb%6#zB(WTyiKap14y*{ z3S#t0qe1Gn07_^>EQPda>l#%4HQt&2N8V|Om^u?NL^B*ue}yA}rDsfGz0#!*&2?o)WD2|uZNqDpIpIhRunKFw43PYfZYNP-Nut6b;>gQq;6X)ggv$KLQ>0^9N zNQaL6aqx|*Nzo#9sn4Ln7aLw;+ywR|u^&6Bxhvt9z!6nZyf2n$D)Xv!i2N|}Os9f5+9Z}v3r!f~U_2Vp$o z9>Fh?hSRlMItBD zSRc*x62E;Dg7K8a4aZE`7)mr)tFRS+f6*HKvrJ-_U~6!CcimN<(4IFN;r#TP0|D5_ z8S(}XhzxnT7wdjSuP(l(AH-Whh$a6MiTpdJ{L6j)iSm?*1c>`-pG4_nw~II)X(|8ls1G!$@Tyep-l0JUK9K#aw|j|>yY zU^!=Zg{O2Vmk*pGE#yExVvMv0(4J8m8HqVPogSwbQm&kySyXtWIPS$kFi39$CJ;{!X*EO|33Ga4V1cV^V9X zPkHsuOIMs5Gr4-_+=C%BG+HsH^X+bVQ_ ze4kd%gNwnhbyIO3SqZcFjLTf5ND04e1HihR(qUE`N7C6fgOntK@X{02S_OORvEP#q z5I}Z`_0C1gLqcvCcnYtQ4$IHq!@|q08R;3@Ez{oiF{$eXYAi7E*WUOF=sQ~}NWZAs zr8m<_3=Skj5d(&`OS+|Lyz}#Rq11U_c$d{b^S8UWg|4#ZSEI4ZVef;$jP-D4id7N# zuUluybX+e{U8=ceg{21!*yc5}6Iqn>MR=r$e}3oxogTp3B4k_r0efiLOcVCe1ETh^ z134x+us`r$)CkdZQuc@{UC>x*YC9== z_#`u>xxf9C|CqxbUC|wNhgVc`dOx?H*IM5L8It<@G4IgDD%2{}yPi!;)f;Os&pw*^ z{9*9UPu3o4qd%{3Pdv|vgjK$}bsKGFX(^96mw|B2WbgYrF@pmC8N+{j(d&gqs{dsh z5(rELn1KRRD3ftzgMBg>m&@3dXi1fA<`oayVR#`(1TkpXT6Oep+rEU+7L}dtikk^_ zDh6$UbRh{7jFXZ$YB8Vs5P?%59FAr*mKM zILoIrLQPrLM|s~-$riLK?}Sy68+kGaVv@87Ps~+!$_HRpHPP`_%8KVp>zohV8x7q? zkB0vbd*2<_s@PRelzo1GwYRr`|hE#om0r@V?)x@ zsaug;9h|>QB}DRWYMSawx?E3=9fF6Rk3uI2&PCo3$ZCnp>$0b%@Q8l)Z(8Dd%ib|DrA$o4Unl#(VD%lOykoJHk)EF9sVEPBj}IB%&#$Ik#tip?qODeH zp7<45DNTG?@f%vkU|Rr%=weB4P`Q!hFZGBEA^x1!jfk!=T8~SzVr@3L>Esw{7o0)< zSGx1-f9Vrn{u&Y?PWnFn3~&;e$2AcZ+e40?qxEY|My zesHW;sA@5tRi>uw9G2i&I-OM{{t8vH$S=<@c+G|8H#?TPv=8DXyPa}%WBzlTv1!BC zpsoL~@PAo*aaZzd`5bFg4f6zq^PV8z_x3q3ZHaO&0FeuO{^Swt^031eD|Ieug9c9Q z6q)77HR~n#aAD*Ojp&GLF6_j%%q^0-2buIYS4Ww%y!^;Yomo%!&o^r`_ol8CCA{z3 z9fQ9|5xY8K{7On@fTHSEL+m#l3tIH_d%wsrV+x=&UQ5^IMhGc?oJ7BzuKIH3-fOna@ z6*gNJPMgW=a-VI`5+GQnD4Rm9Rmne8+>)NQ8=}8M1N=6p^}b>=y2s-sJd+EM;}&y+ zR_{SY$qOVT{5PawEf&AFeG~vV@YB5a?;!iHB6xO*AOhdS+A}BPedDsr0w9SK+gJU~ z5l~j%ruB|=6KF&?z+5=-iW=$pT(C^9Gk%K3Nlx3i>Y_BTVWutLn4>Y-qus}fi!D+_ z?{gA+s)=U86pyAlmF7&ADbFYJ!t{S@Ec@Ka{m-fr5FqH8vw)ng2{Oe8jH!K-(i3=XArVZe}|B=JKE(hzPPDZ$oH$ohykV;7bm(eX&I0g=RY|9iA(uowp2>*;$|)gvtGG;Ccf9+aps{umSg4< z7>}|D)>!p{P7Ch>NyV?5Irz8bBtWZjyJDoV6E^*4bvQc7-r?v|88t2Ygrtr9r2wT$ zI7c3r7-~e7lHCEpA(Urpxt>}>9J1PFmDONKPnsd(=4skdmO;WzpFSPy>`elnyQ&dL z_v==u6yt2NHLXs)Oq(u(9Vg(jTsnd*5^^1RJmcjc%pD6qN$J(no=eGgPIOhPn>YW? zbHs6wT+#}iF);i|_+|0S7c#!M7*PZA=#eU`O}^7U(9Uv*AB7gL1i#}fwIicH^u>xM zwU zQ`P575imm;or$h2l)B4uYMGkWNl0?8gZ|G%u4@Gh>OEEn05Ei|9_&a-MWp~-a4R1otf>Wu4%;XB{@$8M2);Zc?tK&b42n%T^bsW3p^L8e zbB$5Y)K4a7$o4AG>+naJo_QEMMkBvK3}9`@KLv#-*6o{A?v_90rX zm+!TB*Q1S!|L<7=hDat|z4ZtrU?74+@k18c3S5xG2}yCwFtS!3y++ae!v#h~vz+`Vw7R&g8`h*9-- zGpNIxJ6joGf7c<8+FSk(ZryZXEWcU#VYo`3hHTOne!hD!yI^0uRZzg zYkwY2dT&y%^9+vY?=&|%2iR&xm~y`PRwaXjv~ssMrl4>fYQ|N2(fy=%P3^E`kM%LM zvvMZl?_!$*fq zY(ra-2{pdUyx-OG`>hM__@koTz(k;!6_u@cZyGfIDB)nUqe5dsf!sig9Y5Zz9a6Gs zLaxbqr%2fTZ-V&$5h{2q-@I$~%&#cpHbI=M{6rPy%Ah5*dcH{vPYajY>R1-r$kBI_ z$xW$MzlygQAA2zSX=4TZ;^Nou=F+|tFRdV($vs;B^BH6`$>c$IzTyUc)K(`+q5Vml zH7b2D2j@$H;Zb2>1x~nKK^ueN`EeqYi6)9QN_BfAPXwfrsbai8>4tI|G``n5b>3+x z>KW*B)L2RgmSzk3Hi$`)LyHBM{$_VOpK1N3$-gJ4|4#=0`avR#_)ohYGtI|m9yys9 z2};XIQ$3tS0dGBf9kB*`HSr`!Q$JT9#HKiyqVvOMO@W!K7@Q__5==I%3qIMvCt*q5 zhkUuTlWJXQw?C}v@U~E?_E-^>X6t*G0bJ45Niv9*gx8u7?XNt`X8!D9B^Id@%0jDf zpXwgXtWV$9E4ylZ!$8mY$XEYUGl_To^; zmhuc3{)agJ{B6DbxY43kKTz4o?3PvALg*P)RKAU^r}t)x+b43CLJ}LO@}6e>j2}+K zmT<5R@E~&wbW%Y1^4gf5Nz17o27A31PFnA_&}JWzFI)5Hu4FYYJfQTL>jBv^{j)i; zrk$e($~8AN6DIH7Ol7vAGGr#v2v;slc6p}RZOW|hS*zsb$d&$~gOCfeH=_!9K0Os# zRzhINvc7CaGC8KV^{sc;zJ(ygexMxXQRJCJkkl@4mc;P;i;gZwE|D*@e%uza202X& ztrX2HhjRuFVfs4e7qYdWsbK!+zE6icP(XQ$7=~^+2OZRMIWJK^5xJr@g(_LuOZKDa zbl_Xp#gLr-9;YSF6T{d2TN2&bQlTkmU;M9d?|=PMX?7_<^E-1?+n4%%%}2i=`_`r9 zY}pX8?7Jg@lK!_5s@Ptna7V`?$7vgiqQvjxR%Y{z1Nm%>_COXV`H-XLxsDE|pI3}~ z=HZcsVR=?q{|vyJl52}e`stF|ocyin9}UI1)A%2YG@HFJYp4f&rCD}iEEt$!Ay?$w zO!dna^HUE5u-gYvE#B^I^8TV z+gYI};W*yZpzH^H^FC&v!WWy*Q{aKAJGfo*_D=rW0$0=9Jl+n-I2#0kJHty1`=ip zbkvW+Lkb>MTu++pr)@ZRO-VxjukiR6BCZs;^iZWKr%5ZY*Qvhh>+3Uj7X0F_dqVXO z@>-GEj-R`!3SruaY7`at`}!4@em9Ru5bttY(@*iF4Xy7gSI>gGNLxT0$Sq z-Q}G`271i$Af+22B$l+pnGjtJ!xGYXY2_I*6Dl*mL;`L8G+fu;3#KeEpZzV8{|g`R z$0V7l*6&Bj7Vv>ToXM2C_(BG+LxYqv3SWAfYKCK!W}wqdUJZDZ6)#&=r_L6hr=(kR z69n0HqNZ3=x5l#^ynaI68jYHsw5NV5FEZu0^}*oMfNd+&SjtEsaFad-fZ6uYyr=^2 zGjRp+`tgh|y6vyJAhor;hjTEaNxVMZ?6;JDfO=R z%Yz4`z_>!qgZ_d6}p#|la6dL|Q% zkpgB5gJrF9iU9m16<}ZkK`yPepS$kI5DP%@3@Jgem8CZ^nm-FVraPj{u~RDoD_)Q) zY4y}Y5vJU`)~VS$MMr6`WjS@y^%ny~JH}c5i9HeoxN)IA8MOo(%0K*zx7~FDgUl)8XM1LcR63Q4>MfwiE3;gn_`?*x zl1)>-$;zF$0=9npUi{j2nyiis0wgDlw!v{SgCQ0~l8U-K#uLqSe$~iYJtKpPvq1ma zq2pCs#EU`-^$ok+*UDqpfNvK9qCvKRJ7N}FQcXHsZ4 zW0&!(j-z|PwC?JxQs-J~w#4?g&>|j-!r@2Bsl$??qgHjL8*;zjZo<(v#6 zCf=nM2XgKHHL!ThtspHycPaO}V`0p9W7~2u&%mxFw5m&)=I9#?@@B~kPpCJ%} zb?yvKjvC%Am0F(tY%rIK5|~4ZB)RfMcCK$6;dG1xi8lRUY2QHBW+rga3dX>)uBw@i zrt58F+WPod(T@9Jfu6GduECbUunFdSAC0K_-ppQB?z81D*?0e;jw=vYhK9??wqJ=J zoBq9$?OYI9vV2}>H$Amh99PAPF}0I*f&MfPb3a#Q@><=tySC1gPO+F$>&qV`jU9Uc!3~XsjAqCQwfyP@s<}3eb z;1?2&2kO{d1HUdPtgvfN?^Xpx^dqW&rb9~Y#3A8;xx|KnGZN%7V7xlO8!|Gjz1~i8 z#~!-;>Af=jbPn4F;85(eqM{=$l1m8&_3(^TA02S@*`Br-sp^ zjuUCInh|p3H%)-~uK8`%u&c5VSgD1zYivosSZXvXqgekl2@r)C+%6;Y-DO*R8^m?6 z)u$!hT4x*HnS};%yCXgLy`Z1I#;r(AryFY(5souh5rP*e@E7wfK0tEZygkd)T)tUm z*9Q>EaY(|9i~a~$$s&JpxYZFT6+F=nY}VRooQ`Y(4V1PJqn-`J$ib184%>0nSl`K| zqvW}aYE#ua!dEF*2e90PvVJzHEEA11qlx~-W_7GleqgT6=M{E;R=zBQU&JxfhArFvtw zh}d{9agS~9J(SgT%Y8;MHnWwoJb6BwJi4zb?{TqJu}u=J-A^EZ4OJU~JMyXSFVxg_ zdLlA3WccmrUCT8F`xBtgMw6rYyR?{Ti7+;2M^=V+rQj=$Tqlcb2Vx z2>7|QaS6tQOp;D#xi2dh5!a;*_&(u*oJ;4Mvx+4NM2{VMWvBis_#1)HKZW=&u1{|z zhAPZ3mTS9eJ3AbOTQ&IjlCG&t9LUVPjxms^V*@-@$ZHO4P#ZW(0QoJaJzr>x2Egj? zkaU}{S|Yf%N(KvST(U3Bi%;=7hjoI<2Jk^>wc#bkSpL%<7<%j{jOCMhKcy znS|Nn)M&Bk7aWcC47IA69n`=sU;%H3&G7l66s{$Uk)551ed(i;DRr_@FK(zG z+?h0<)XGMg`;qW%6^s>l%MI34ZO+K*I-)kMwSz<+_G*6Gi5w1bz`wc3DZE7Dk#y@* z!<~PGo2eIwRIVdzZVr+Xz8=?lLB}k|qRsd_M5nHCwQdejx^DoNpMvJhz%lSRorq-)nPw8H%LtX zUK2C8$NeUU<2 zQ)_HP720lVS#0L`(7d~*yBm0Fjd`BzY@;`02?EjK$4!Jy0EVwTCfU$1vM^oRtYH$t zEp7f(ePG4tO|9Xb=r;dAh6M(UX)im(ebWcj>Od_~vnz`4>Fw6VI!|=YHXoAXY?)WL8FQGU<4N)=sX#y9tO7QM96Yf+@;V4eEXzr zSK1s!CPg9#Zq&#2PmIMhLtV5M=jSi$7HH4N(jpzIB*|YjgYw>XY!6#P`<{|>By-4{ zEx82886Q0-zgth#P@<)6`aXekIFv-hy(Xrv0a9vL>LM2g$k~;(jAvjyopd8tvd+mN z*`(nNL_tdWa2vZ;VhO99!?dWe;uUI?%AhTe*&yO`|JrNJ?gU?P!&ukT=(w5BS6vpw z(+gLeoaqx%roR-TX0c4lUFlGsf0%;?YZA8dj6@HYh0an?36knvFbY`&wC>N;0jGh& zSc}afa*m>UZMgC$yCpz_Ut)xPPQ^8jAAJ_=zAQ4U^h z8y+!@h=%KxMM{QJUyh{ZGQS+yN<%f4)+@vKovlZ#g+`#6SYYLRee(MD(%y}N=+_Sz zqQdg$6syw+4yu&`nI2ch)(wNgX2;}VVv=R zn+|+bNX=#TIvk%VnZ&N3nGK6vq>jewOh}-ni&_A3$*QvGQr(3Xv}#YMg+vWNIzEYU zWm3yWrXcWT;Lr@H%#WsX}W5hlNWQ8j9r2ePo` zo~|;RdEd~auC5vCrU3UWom@A1vtukfShifBg0RAu^b97gHxgO;duqUI@F9g{p%cjd zn+#$JsikrjR`mAtS$x#$qXB{$NqgF94htm#rT$TGMLIW}jG18Km&p~9J1Twx)SL*9 zFM2uQH?x`Crk1Ur_I);3w;b$s975H>zOA#x_0MA2ca`S|#S7no{!??tcgnm#%P*OY>blxn}>H#igDjvZQ1*DVc0We1p((d+5cyxOoR#!F@4!9Q0>b>=V^oanpRfqqfX$2s2R1+^S^srmZ2>#WtF3VL*jJq)H2z?Xhze8~ZHhKb2bqnNsJbe4Pg48Cb-XUGUKJa?G6O z-goqWmXJ!9$?HboWza3au5x470?~S%fbf>uNQn?q45n}tj!LFmg-OBZVizxKmpB3iwVPU?A?m~W z2tGa4iNRPc$2O@|b8K+fm5`!+Es!>IGiz*KAI={UYi(5?#8`+INt1_xgS+_4)E6*I zYG$GdacSVorER|$rauCJzr0e?BIsw*j*-=`IAZ4RxaNMYmmlOd$H9C9umHtbrjj;8 z%UZf(Ji`&7DF6$?Oo#%q(qB{^F@xXmTvx|(ydAv@+bG^NZCBNoXi4|a3Wa7C<$)Qx z;eZ;esF~Q(7rbi+AdsudVgf$91*on@^2rBBhN0nF&Mw7cRj+qYU zIpG!nuDfN^u9j}rDJr&0P(tYh_1k0gVX`GZQlm)ToZkMY0I)pdypZAZ{~ZX=n5t&w zcYPBxEy<-ZrExQ9s%niW8?y?szK=rTT|e{>Ikan4t>qtYa0Pzmi6Gn6Z;)>GY^Kvqr11w!>za(&fn+JY-9kNI7j@-dHM z=}3XyePcq+CK)lVd1Nva8cS=2eb!||T9N#02Ez^pKg(4^IvQFUKzyn+jaPiiDeeEh zV&jhq>fgL@Nh^>TfciCQR+x7-sz%G3@YJ)0%;SBV6xMDaZO^vOHJ)!uA$d+yqcJpJ zTZaG%$hag7``-7o3H0}we-`EtU8q+kxO;)gJoA5q(tl8a;RD1qT%Ei*d+$5{DQ^5f zYM+@v0&Ci-fIpo<l)mA74a54sH0n~qX3so z<#wQTe@Ezs_{cntM|$AYukFjS1j{m0$)*s97Xy(P_}?XH-UgR#tf3n69KY28Rb3EB z5v`(V{5-Laee;Hq_659Bi5PLBxk#X4Fk4f+xG$`h6V2^t`8&A})t>3f_^g0)-{EcS z4O$`>^Hn}@vL7hrLH|-jmjcqy&F#KGgdrZBrBngI=jM7ENReyQQ&a8W>$ia3vWFZo zN)mEm`>iIq7EANFamJjYUP#17Y+NnWuNEk=*7h3Y z4VFRX)LJ!DR9^M=gV_-UfUp{EX1Tvf7b_pqj*pBzgb`(*RrraMT((j0JfdX5vDcs8 z;wHW@mM)$I3sne@OL}i@ZWV;mD0xq#5j7PV2>_`lAzog9?g(spT(~A6eK(dX6(y9| z-fm4@O*pR?RQUF7YF_AMEl_b{^6&Vd?d#(sx=dHB&uSSisr@)xh}G;(?3?9`!5hSe zK&4l)NmTdE7Sh!V@*M%D)Vn&BsCK|oF}Xojj+c2JwuyDTJUd^TTGQFKFc>URkW*ft z-pKOk0VzJWs(!XZjZy^b)^>MCN<=1o(z{+PkU3c`#)kEsP zVeTrSiD&jT7lUXE*pHV0nkBpAyu6?f91Tn2*^mng*KNE__mB>2ulE=o*FY?PLr;W{ z5JwM3jWon!WzHBB0XD)Y!88xBb$fo_nm2?m0A%9sh{-iDn=QDZ3pM=TIIjRS`FeWQ z+EMRBB;trKjJS7U`SIoI?D~ZRB!4r`EpKt$7D@ClJ<(moUxiVr0z~a;K}TN+8Zzx9 zOyw<0#ah_W^_WuYg;TAz)-a-FCPX$l)kxEP?c8q4n+rO2BUqVH_g<{&sC(F1qtqX4 z%D-N*gb`MarGLW&`fFuBauFspp-mk&?JlkCV@cSxAPea>T?i)y=0#)(mh#wYPae7f zG->pn>OA1SPBP-&gSqCsrnxs}{5Km2-c8H|wQF)L8`S=#cTcDYdKclkft_qE)41*3 zbYF=xHp%dIe!jv4!RGz+&O2gyWm$ZhHr@2auCvM!{gMiQ@gCZp^7lTaKjmX8r>_w# zdRm};nfVtT*GNKuG7q70^(#0(=Ih~aiDx!7BX6~w4{kF-w9Ve!FSoErHZNfp2x0-k3>0d9}HP%N&?JJ1x&Nmsqlx>RnY}J~!uy0%xIN+5= z)U3V)*$~uvx5hdhti5T8w;AH&Cq>pDJ9 z&ecD^y&6sevfo2j$j2uWbb|CC-B7YyzC2*$4DoArNN9od()gzzrp2vj86I^H( z|82+?{l+V2yTJcyq<_49!Kx(8q$DiHUERC>yMnTO`F%*2RTp=e{&#I>b->~L;3s}8 z(up}koWm05&hFGp;iecrOBZ8+=1-n0?mnT&HMYo?!~rC~!iKR@YXD)sI}d68&Ws6- zeMm}z*V1GZz4+x!o46^6qg9!1$E;CH4Xo{Z?MzM9SN+(!aDK0Rc%YAJFB&QrxJD};xv`a<~1_k9YiM>7~o z3zmL2-knLE)t_-gHBo15MkQB{AqgP$n#MVLDs)>gsx5;&r z{W|XK?zmXvdsng+Bj%7`bRI<6Ib~=#klnBl)qVN3d1|5OvYNJgiih;#vW4od_=|?f zpv8rh{v~p~{b;xXRmnoK_VyCf2`|KMVWwuxl;+QNQo_TDr>^A(uq0nd{7ZHFL{d`1 zBj{Ep&A<>N;@vD-CA(9+A{n~TV~Q+Yo0T!RDTd2TEGcOw_H(qwv>+c{IbL(Ib{`I0 zaa;dJidouW0LMJZB-ALS3Pz}PQL3pTdNj98(n{(9PT-`S!&R)H+p>mEr`=+RdGj3k z;_526DqY7(gLSJEcM!N*u_Sajp5^tt;>bH_zKk06am<{cdqfvl^3R;*_Jo1WZ;B9t zIEQ0zUbK0vapBthBkoy=7Q6k%k#fT@M#!n!7034Pby|6D@Z(-bD=~r9zXD(ctIfPk zULYpFzLchc75|YHKOzcg>=G&7vn^doS1pk<^vq0FF#psqG9U&7S_#_hn;resfZ{)= z#P(1!m8lndfG?A)U;JDNaHM&Ndoc-@-A5;+WG%c_ozaZi{(-rYHB_kR8^j3G*7naG zjD`atayvf28MbxLq#Kt-PV#(v-OOUq*j1C!6Lu!Lw}lbD1oM$M^R^Qxwziym6=n^JN?chMoJvx12g>f3DBY(*E+DeV**?NEX4tQrX90TYu;o(dh zRDJ!#YqMz>OVnN-RJuc3Xg@h5vLavLxj{m^a1e&7I*(zxk-Ij=&u$p=YwsWow!(JNnY>|(2Uecs_A56&QNHZ;Fx0Bh@bML;vH5GoH zUXFO}X4rA^{Ue8O-pUV9jz@>pTIbx!M&8EPJJL5lIt@!AX(G2bLksc&h|Jy6=~4H+ zv|+f!7F`=*yZb6Hub|Czs@AaJ&4JCPyYZ}K2>;DoIzd7oFI;XZAGW73dc4Cm|8dw$ zS*|?=;es>lup+p{N@A+*kujTEE$!j$sn{cV_dSN6vzb|1<5&@|p|WCohrY6BT3)Nq zN+wEBzIlMq-)r{0RW5~W?D?rIdlhFHE)_6{oC4npspx5=@@Tm@204q@EM+32-1`en zW)850xaKdwEbIPYMKRRts6z9#lk>Z{S=D^~6Jb1s%a=Ya->D}Nx}ztNj!W~ap3TiO zbAaqXTKQm^O8>XF{YOWg$6uC3M0BSF*3GuN(CZ!cLl^bRo#xDA`G-#g4~F&dN9JJ@ zRfLlqU~FEvAjUqwt&Z*_+DwMwFN)Qf41#tXV@t((DT>ut)3ED=jYT}=z}&=nvA$;N z7RQA;TKVNF9>IV0Pu`cA$0bAEcNraAt6grleKp3B1+VS~NK}VfUu(#O?@v5%@~I1b z_L!qo^UipatM%aI(Ih5n4oRyQQv?}FDc|}yv^%9JlI*@#A>%EQmXj{~rI!s=J(yVr zDirP;N?$3Z1T3zqNI4?XQQy;ZgXJ0m3pMubDguWbO=SwJ%Sbq^uAt3KhqS&bre$?L zlWXtez%$rey~f;lrpSLf>6`zS`t&Lj6Dy&C!uv8CcW1{+48=;RGY$ni9x4Rt6t6h= z?}$3pII1tauQ>9`ES;_%b455Mc6*JT&QHXq)q8nij~Cf9avgHJoW30se#G|LxW}>h z_GdcG&$TGMRqQDk%26>6 zpw5tcZtLb)b2!;{9pY>7qr>YYb{lqTF#p)vWAkkne^NBhPoo^=$_)^8DYk0L%}!={7UnjQfV-`-j)OV@v@r0o}a}>iHRH zSyWDrM4pL!_cmQO$m(8;HMu$Xz+7a1B`XyjuWV0?T=`i4p)!t`)5c@%n3A9s!$Q{C zRIXHcanfsdi@hra$b|QQDz1!-o#t3b<4GCnid#Yn9kf)Xey==Jn8c1!N9vBRD33FBQ|_cd2pCxYr=j> z{-*b;DB_Ncp}eP5Xp+Whir60IVYS%t(pQw0Q~P%Tqhjc(1O&Fkwf#}pa=BtS)^*#f z{Lxi5{$i%PX0DU_rPqvYOJ?dV-OhhwIvK~izYksAI8RD}k#K zGJSp@7JCqN>N+$>8(XszMSfHxws$J-vAyxgaen=JTfUygulmH`SL0iHN3s>8$AgB7 zi{tSRz|8MEYP`5d{;d(|)?J(N@o$gKX+_Q8ulR41d)&!eM7(#Dw1^yv!_wq0UsVp} zHlmY?HW}`RxMPu?v&!TkSs-{Yp-roeQOHT{vysFOh&K|fmu21^sRoG&Jhre@NmqCT z3NHAW1b_1WF0lV1_MWb_g-%m$rzGMs{>u@)P(gZmvhvn!YyWxN0j=jg<%y~Aos$R; zVhBy+aX-{Uy+gRLN~;gppLMdyke-EFA5fbP6S-r_KCvBQB! z4*eClexYt`EV|I|Ie+;mXTM&zP=!kkh8p&B$nSI@U08HGSY~QaQ4H^cc5modf_Y9R z9v(PXXD?p9W;xiE=NJe9YxP&Lsos{!)k3Ng5l3fby?fut8IoBE zJ6sX#@#n&h2zjaJ9LD3zQI(>J5kLA0oIE#L^wwl1%Gn{=CP|JR0_pv@fy5|ug`n5b z60R(d-)O<4Xfbq8Y@Z6d)E9Lq5-W5`fKa3KNS73|+h4!hk{ne~v3vNrxXYhj!Hc^% z0^{h24Z7+yMF?}6yzaG>w-gZ`w`}0Ggo39Ecb zQhwA6O<#JR6u{0^A#Vwe5$ghd*>`Pg2waN79e5obEiPJEs&AF^A4^8BsY+stCfeJB zy-z2FeQDC4Y)ys%^ecVBJm$ZVQv|l$sL{t84|m&&c~K zf8;(aI<-Kj+wszWX@2lC)z)Dk4oQn!5$dp}jpgqtpw&h+6+#?ikUFQS6dLc6Misi` z^R7u?NPw1>i#aIu{CiCix3m2(xZN(WYN*qcw@Svacqje2n6I=4a z9~=6_5`&KBaQ$7({!_9cb>78#qCiM)zP*J!v)}V*7t`4}JIU$!7MM$m zn&7}uJLj@J$os4h#WghhO(?T0-A&wu8)yhz+XqQKWQEG~wq zG#QnpPl|oH>Szbk8QshG+;~>E)H$?Ey@c+k^qfB>1%GqkD;7DCFwsyyHF3no;TUBL%D2$gZ_j2(@*LHk*=VfLtu zQ5WasqKzg(sMO1><#rM|X&ttF*kr2vv#=b0eq~-&r!rGGyD|mkvU`1LK7aK)xoiPe zR{NXKK|x1}PH|dEdiwOJlarE_N$8**z{fr)CWzP=r9UdyUQoQc*%p)-? z0}O>HL7NJy*&Gj7aCeTmJvwvOT>Q5boJ9sU-?x<>Lkj0R8)8=>2t1wJ60kpL@fk*F z?a*Ltchf)ubxCX2EoAcrXIS^z=|;oOJJ6V0p80Wb$9!azb-(G!YzJxPrrY9{*l8WC zGery^l+wQHj3ePbU4+3DoV9v;)?iC|A+kHCoc&OPRki5K2xQi&zoKVy|G4wA@Q8&^ zD3&pJpl*B!z;-hEtE?-F=`#53M;*ur7f9z*Ht;%4+4tg~I;Q&?Yk zf@?0(8{TOA=~FryJv%L#@Xc3UL;v5;G@V&g+FuyDLJYZ?N5j z3Bqa->|$^2$M(E&KP4<{rjliVjjj#uP=DxFMCH#x%|3lrw zjfiD3hu~3@=L}=@jd9|}(62dbQ>)MF)~7!&A*pws-@|8S73q}STQkzwtUdHwvZXAV z!#F!=_coq9nuCB^(jA7<9e31f0ir1`B9X(oWj`?kI&ZCNv_Pt=#=T;t2sQncitav1 z;doZ4F}u~Y^)lz(A^prM`%c@L&GPhPfHq4SfF9Nbv}`HzCzpB{%tp;&^S#M5bJRsk zf-l||w!ZWIA`s%3r|5aOWh-Yfy!5^k*I`Vi%57zGUB5!9w(JNZN_8hb3b+~#) z^{DBTOtQ9d7nkSBG}8%X?mk^d$?jqcrsib6Kmby_Iyu>vTf%6Sl3SfRP^B2xpx7`aLdcSI6(}9aV|j643@6jf(AuGkVTj zN0*qk&C#8f&Jv zZsS!lA%&+3uOGf(C*vE)p?^E3pGeplnUBY9JV3my?9)q_?L*$_5tUM!9BKK*&Y(-Wdk4Lsf7gLR)w&aRO%;M@3h z5-DNh$2DHC*2rg&9ZcWiZ0$)qk~fdvj1H>rBY34`i^^pdK(0|DxAwu3i-Z8{YRlYN7^T+1Epl*?0%dc^VUkYFNCb#T=;(N>*^}awI8K~ ze?JahUBCYIn)I~`Kjb7OC2yZ>wRz@2oz}+O)hY1 zG5-A1mrI54dU%b?{X6{Ud;r-huj$3>&nf-b{>l+1qiju@n$NC!_+)77ZmqyR&h$?G z(cl*C6|JX=+A?z_6z71(^sXLMo?$?3@7<$q5%^W6P^4{mOOl*QT44%`zwz-NVUsyZ2P37kfk+C-G>F}w(}66bvEl5;JN{2VYzr`Rp#kdi^> zJ>Kb?^x>^>q7OLoR|g3Wm;KuB&F(FqMr`uTqn>vX-y4K{8l*56gAY_<4Aw-h$@c3y zEswmm?1$3K5wWyL=g}F_y_bT!KOXDa9wJNgQH)m)fj}&2bGqbFyHfqwvMiyPuI2Ql5P7Ld(T-8oP(d=c!KA z#=kHGwy|>^5E(576hF0HypzTvndY=6^1(zt7bkABunBtfb*54jlIDi+`*`(XWojR0 zPW-`B_ID8o_Rz#D3!;w~7FuD$=f}|f!{{3LxaWMu%8v8VvgF2Gx#1iovC(Bp9BlpT zdWJV%%j~;03>Q!JNReKO_;N?i6zr35(wz*Q7~5SH$VL z*kWf=W?C!fdG4eTdj8Yo&t>eZ9eK27y^*h9%-i&s77m12Z7aKr|9XwDxK{3xtO2jg ztwL~gKwLGqW7yF7KYy)dlb#fx{v@(ilL(O=I>!Sr7Jz7S233eMCD zy!iCqJMm27df?y-Mw}Wh;)!uQZ1q%%lIci_A9^I+5f0xZIZvZo;qltwe0@-k@674_ z$3n(s1Gdjo*Ka8&sy;M9U&!7hc`uW*POL;(8G2ol%Y5_Z9oguE$2IUddvdvVA}2*w zUv_%lhcrwMQPl-C1v4j$j#eb}$|ZMC4o;c3bw%_fyke+HnV%lm2zHncOO#k#s~BPZ zG3S4+8Y}Rg9ltrJT4MC=ni2Bypd#CkS7`Y-Fjj*fK3-im zpTECR6NGoM|8zW;|7OQ6*cz(^iV+W0+E0*wb$EyZvy4JY_aZk16GiTd*sLLscUYEo zl-=(>bsJyAR7j3y^I46V-0qGmAC*6V_8)hI^was0X46Ud@4gcg)*rjQOzFQ?boCuG z(TAgz`O8!Cc1CSxKSr5lpD5X{CLrGM3v7ck4`TQ83W(yKJiX+^4Z$ALLME7e=Q|Tr zzSn*pQK>a-b-s1ZVYQkW`TUC1g6OLUX7=yhIJ0!I$x(&Y*RSpEt>IFByrNRw{P9Yj z%0mLPVkyMk2r0Mwf?TKA3{r(ncT$!Q^&iG}oG*mplI&?23|x6O+Xa=xNkNt8YV{=~eBWEb^X=$t3>RAA2(F zBUD_23(6zHxi3#&4b1u(BzA1f!2g!;9AeOjy2?Yv=Dme&T+lx|{W}XB6iqXKxsnuAN4H?FU>W>ZKq?iW81bmHaoVRbZpyBI$E*av2C2S>)uo6 z&)zkwzTe-hni%7KpD~9c>ASpREk%~ftoVOl>}wGE9y_~(k`6I{=dkqwKT&n#&`cxP zMf9D^h(!_Mx+EpSu@k_eU>6C9!D3cqciLA{${)bw0w2F$bRF}`pSRuLNS2?Rx2tS? zsYoaC;WX;-lq?Q{TfOkmLr@#saCe3NfCol#Diw%foM$VfgP{|Tmjct96NOVPA73A2 zpf!3hkM3Tf`ZD>B23>(KzCK^Mb_-SW0Pb;OB0>3_M4lEq5fjSkg2)4D@mE zUwK&QcXBG`jO?%6x9eBQypot?wdjUaiva+K8i)%jhpr;m_lv;AGmaa+S68DJy9tTO z{HOZf&iqhU8(7Lp(XhA~Z6u1-8dr3d(#xk8ue z8k+?$>c;o!BW}-+CL_j|fc>&rldY%!tb+!pG@e{ZWKhhp*I|#>=YwZEs`dtYc;#I; zA#%A8;z|x6x<~k7fVtTF+4J<3_JNr>EeFBy@oZ&Ss@R!|s255ksiD?OPey3^zEUlt z0(eucUEV0W+U}$~7|#{oP_>xU`q_BMu*=L67vn{)>^PQ{D@$Y0X6UE#a>*|^d(Dy* zlhs%iO~8v8rt2W%!S$s6_~{a#TB9l2`E?LwQdUBZ_CH5M+f6OYk=48}7f6%&dqE?dansB^C2O1lkmwPv?)$bH8oQ)9(s zZf`QjJFtt4+Ux$f$z03O1F<~r@BT|vY7{e$1yC<}cm&m`9Ufy$auE8y2}(~st2w~$ z^MG^U@=K)@h87G`e=DHOCDd3uN)WbxPxSr5)T-OPIn~H_sTX#6!(enG=#-|4)7BHjSr|`kds5a~XzOL75Jw_!g z?degv{XT-gGEt9NG{n3xQUlYwa1#1cm{5MbAAEx!#Y6w{y-g=%roP+ljXR#{A)vv@JuU%vR@uJsnE_Bi^*HRVh$3B}!~(u0IX^&WsVBUms1C2-)W4PD%U3NWi9hK(56 zZA+qr(?!|vKh`k9N+>fPiIzVRkQZMHK76uWGN0s{1 zV9&;JB35sYZ3x_DYh#s0LH+wi}|DEXRcVl11oFzksi2q1iBycSH|dF zJ&JA;;we|3ImvEl%Ov(nz7?+#u5%xMrymB|W=NY{07dWV+VU}#{RS7ikB~c=gPfth zJ0&pT>fnm%5~^ay?_D_PSv54nVau zxO)oAHuiqbtzEAhe#S4-<5MvOre^RoSy2YKHEdjl|0veF!<^52$jUhv>NTwwS?H4D zA5Z*yw?@3Qyll5Y+X2?+a1J{PjT0af7MJle%#Wj1Nw{8OF>;|@ly3eCekqw!E=x`( zwU#9Yt~cJFkLq$-TlE_Vu!h@HiG>WZvteX45+(-I{FEWUhGPeZ6X2w+EBc ze(Mirg!gNtIGdc=nBj*5;2-$DYY8p6Tw?g`{&~s;GN~h#X zcy<74h&z>Df2{9zhyOl||E)X(rYmNVTeFgo(=&9w8(}3w7H9q&f`VdRf|J64*NwG) zQp-3MQR(3n!y=CN_3!!?+r=A>IPYoco+Cj1*C@?hruT%K-g5>?Jbt;;M`nS-N{ex% zqd|s%Q&H=tS8?lAACTQ?oc{G-j3r6n@}pd(xQOQm?M7r-`! zr9iTnq_6~gGPMqwqtQBLT$#*|*+hFzlF(KE_VH?YT!2x(>%zG@#H)fUH9TcSPgtCV)c72-tp21Ot6^FE?#)= zuAOf~gm}hhYFE}EWV)4KpsePZAgKPYTH^ z>?!yY@VbfAi5CEa!~6>+-bKQ(Mx^Es*N`B3c*l~a#06?)C$Of8WfLnvz>Lz`2zrfM z5ODA{V@FsL<6J(Q)t3=0Iig1w?%Z}SZTQ27NSD>2V&$RowBYiYsC0pp4AD)t(&stQ z6BY0z`rr%`Fqb5o&6DNJIarPB6WnW^GBF?jxw#1rtTt(zMt)^_@v7Ra`@vN8ZnutH zQ%vX^7P%e28|<}udMt7Q_TR^s7vN7j4%smZbnxFMumaWbeDa9{C3aH+C8|%jIwOse zC1>rGostGuA@l`Df@E>&$s?^*|L86~K{vC3^n>@H755FU8;^b}c&2f&LP=zznIzar zSX_R}Zu9H?GmUg)!yW7N>-XB=KWL@k0kA?i07GL4T5?VBh70dqq`$XMUq=XJwB1tz(p! ztlR#D9*pCo!bT8$OmckJAdV$~ISHU$VIuL7FQA8goFHGZM%XXgXmutJ9b+g!i}HSt z2h6g2-bR`&G1{z9Z5P2=f9$POctggqS$Mcy>ZeFL;WsZ*0k(S@54WN{>|#WY@Y9!VCnP+H~&gmPh22j9e1vsO1z^hLcDrjgJW(-W2YM7($hx+dDE@+!;|m zx<)|_*pP*zwHSd=&EbVB`_QMJ=&VVWkb z@Y4h~%M=r8h2qYo9Z-AV8xhpTC;^41EN7NipM#L~p^J>Snw^ll-~5on?ypEx`@EKG zoE6p|7^+g3_L~<6dkKqQ8Yz`!vyM2iZ<_Rxg;3vZs670J@@SV_x%f2P-b;|}4lRf@ z_QLmDr2>BGa8xTWWN|pIH62t`GcFT)Ec4YF&8yGH3oHMz@{3=-{9?zn}Ld4|=ZMppxNYyWD%x#`LIoMfrQS=nB+muMf=aaBH*_M&*e!Wz7 z%0HjM`MKHs1dz+-kPLZvU?<#|DFN#DMcdf%m3LH+hQvq@U#YK(Q&4W#-Kj@i5du(F z2*&2DQL7Ro(0qmXJ6!72XRoN_m700vawxyDzeB)F#AeaD?I2$+Z>mEvQM=+m(hL~W z;QlJb4Y14|dY$`oYC`J0&}J1xqr}iE<9@l7Coq*J!%WuUZIocwFZ)f%t%r}>G+};r z`%{@0P>0e3kyHShg_Z_%n7wx6SW?CEL;5+5dP&8_w=z01!2ObG{AEACj;+C~Uh|y= zx4v{%^Gjym;YoFs=@M}JrPz1swq3tBds?S18IwWhBE{d3hRmxLl4N?aT|Kg?7_pZWp60Y*YFZCwCwbD7Kp0$NNpk5K?!! zqPa%S3=t5>#`A9W#?O`k+M%Ve2yH$%j}*U=@xV~zyrzx1PuSYA0vdkOg& zM<{t^4xxoeT+d?-Jt2ul+FH(&+Ys^xpc#1Pv&#!1#}q3VwCYn+tJjDdTOCB=;NCNbIuAa^mhTD`|uXuCy2%pdiI>cHRwD%KuY);WM5J5!E21pLh~{T`WTw; zj+dCnQ$D;E|8o}`kf&<%`*9~t6vZs0NwPbQ*3}v;um$D}S9ZxlI9h&UHOR4cu*qwvuFmZYJWPd#tK^gF;vPaSH zZJOV_H&dLA63M;vuwj~~#sCLFAmr`oQUCXwR4<7Mwx-%LMgGtl%nHXF0-@cvh9RN; zGQ3#-v^&-@bqd?nHZv;UQ>Ym{D>%vfXnx7aH*#FU!U zSiW+lzhYi)U>U8{a0pGK<@3&#wF(*HP9!`oB-iS6$!wn-xDEG@v)1dMYlWHVT&_rF z`{AzQ@V@5X|Gio*_EgF!M*S%xM|t^XqfLheytO8P1oQ_Ej-Z9>^T7c!4I}7=g~~=4 zcszW}gDx(+VP-+0=#7N@U85$$BOV8W2U<2&dUL%!zvT*-!l}#NzSUM=T{us(yI+ap zqUOi@ViTROP5T=3axSM$Y8_bJoGGQ`-+oj9!8i7}#j5ErQslBcCu-bO>_}JJF`bF6 z!}P_v-9Fg;sU($XCW7tOdMTlxG-1ZyuwWyh;#k4ZV-5C&OF?4ezaz_6km!%61q~gC zp62lCS@{cMc-P%HK8lffx7L1@ew!(DG~lBDVo zBKsNx!616bE|R9!1zAQsu~4oY5~&w=Du>Lu8I*T`fvlXa33%uj4+w=x2pXQq!p|bv zq*BctoF&BvP?lE#CU24~=JwiEWbI53ReJg>g=A)u$k@5`)mhD?6GDxPW(|B$1b$_CAv)7c-pK|9}02#Dd zp0nPXcshd0zBE&o;0#!6BII{sLfA9o9QYf^7Z<&uBOc6qXmXb%qg_jnAnm4NY&29T#|CFU& zFf7oKR)w*bwe@C>-w8E(Fj;#)v*NOzh+p@mk7%tPMjQ_nHLf!pYL@t%B z_zcC%U2Hm)m>^)bV-;(wbqw*iDx7;Q`s{R0pA3F|u8pMhCse<7N_FRmNgs`NLZg~f z?mox}qt8HX&M#YH>NPo+$2k{tOg!zEOp<2Dfjw%jyu7558Sg2Y&4+veGM`dCmHqOV zxjZid3k0N-srU5bauPu)c5Ps4g`|u2e?4=FP5Fqof^m*1z*3;Ym1#tQ4Z4KGmYR|a z5&k03$FTF7=k?MaLmTF(Wbr1=cyWpi*+iU)WXP7J^naUX+^AO`2{`rnpyfmVynQh@ zVl;Y+MWdt+gqS@_o9B~5Ylj-8jx!tKF#knJ-~tc8VbsNjHrnHJG^Nll@qB%!;rIGr z1vCxk%eA~@UWo0y%6RYU4J50wi4ehQVYP7XGNo z(B*D`WhUthO=n8Wicl%}X$`Iwgx?3>0EuVTLXShuBN_3UBN|b8r(rRzpWk0dIUA6h zvw?(h=Wf`a9OSt13+bZO#6Nwc)A7U_edcx$8B~W88(c4E#-=iuFz7~``{YWIgE7K7 z*-C86)z^xe(TuSCQ&Al1nEag?jLopbVrH6*r@yD;2?#NGPMCW}J7fcR;exdK`P1>8 z-Fg6lDxSh8BVjPtr00=3Ol!2642nJpPB8omH5@Vk0b8^D(RQvXDoa9hu7CC)h z1kDm>?r87tXVuF@G`I8d-sfVO{SR90XEqk#H;!J>N$cia|8)@O`Sea`(28LWVr^xa zJaWK-yyv#1pRKCu52j3dh_seB0X2jyZWW+abyfu!B2&HlEtA&%RR}p^q6P{_CZARp zx|Y&38Cv8VOh4j-f9e9+aIrks6R<9jO7&^p0(>UW`^@J3RBIzKh zfm2(m+AcCLHw;ve^E6=91U80-j=YLDO1PdhzI%F9bD%kNa8WL0I|0MKGp27tHi)ev zP|hkX4=X|Q#&C6U2uX2;4R#?lr2i!)rz3Z{et9C|ON54D7ATm^DI=Egna1d$o}y2- z@`xVw?DotkKY16YgY{QNiEL%BUB=kG*>3YpqLj_B>u>`&^1Z&n)rw?7^r54O>!t&< zS-LgnM|qZ02|AB?^@BB_Oz|to4GZ$%4+JdCSMIyay%No*^s3bF+R{|;ka+DsrZbau zO#$+$XO7PT{iDittHp`G19kMm2A}N4qdk@N@ST8HTgBaN$p2n$kL&+61uVNieYz+v zKuqKdr&6YY4BasZ4+%9E{=PRuM0M#CU=&_De%0I6#zSEnaLlXoUr~8uwoq!_YCPG) zc-?+4+aOB;TZQbXTT7K0Oa|Nrl4-=1(^Lfpjd@l2UT&Sk7YP+Y&|+$<=RzFVvlk-RV*gc#Df^ILF~^+v{CY3F)e8LU18Y#GEBKsCFjqm zDnM#}7~T)JnKESee7~>Dw@vUNO1qb{aJbImZzU`?=ETnz&X>I?y#RLmo0M5Z%7aJd zZ=fJW7=w?V(?K^2teWlxYPURPru74y4WoQ(e?)?=CnIDPmM$+?| zFy6x8NHv$kvD;73Y_d(cNsROXp$nFS6;LHP6zShJTYnK^FlzmU&4^LlHjHz{Dgk>` z1@mxOOw_~duEuSEIkz~>X4!94Z7rjxVQYHxipJ!T@}!yGnm zzt9y7C_>r;>Onb)prUWeVfSgaC=>W8^4T;EBk^HaYDG~o6yb9{N5Q49mifs++nc8@ z_VeVL9>OwbR~Wn78L|}VS68UEO6efIU~m~h9ZCUQegFIh4ko=gm&9TuVK*2AxQE4L z{$x9(PZSTaIU%{4i=OVRZn8xF?;|7|24IZP_Z`i$+IAf{; zNGH;p2r%X_l)d-Sb15WDnGiJOiJeK<`{*M~gByRqGQan$GT>eRSKCb*)8K5h%?v%}QLdb6sh{M-V18WEpk3os1Og$OWbf&TDFbi~j7 z$da#?GZY2*Yx^z^rn7;k-!5&tQw#fy7UkrUi_F zY)HlBTJ6m#dv19a82X#FpP)!IGd5=ymxB)oDJG|TN zzHDIdDP~-Zny=M{EGcGeM+}7l35Em!3Vt$nWGs}e+_VKARuIIs(Fr{POAUqnDDo-puHAFG4NL&Rs6 z697*oy^11dB4QW>n94}&9ou2ItOLbPaMD! zM7~x~W+`hK4r*)BcZTdd&bQ@6t#z_=dJ1A0TGjW0??5$;1g%+4SS+_|iBGFW@T0UF zybXWq+Cf=DtK$yopYarzf?R?dI_HpQY;8vyZ7;2561*t0hJNcQw(Bp!C?%`l5Qx}3Bh&^{vf+|kK^xCX!3fN> zLhR@`#MH%_3E*8?q=l2OE<^5f(y0)DokLd{&pYv*4lti^%Wwc|&30SLNG!JDDU1z^ z3HLxDt((n1P4{xW!brn()#bl^&*3(*dRQ8EtHqrxD{V&IeP?)paS^E7jHRqax942h zJodRJb^V&jqkGSnQ_4DuCDVqs=V(=L)|iI|Pd2Lbnv+|Ee0**DHYjZ7ES^sy&92v9x9w`4rhYu8)5BTiW2@daL5xV_PVU>$HVo59kTM%(yR|0NTQ8Hs>qLni{G%mAa4c z_qM6w#={te-tw+XqB$v^^&rBPBl`@P^&!O+m9G&}Sj7=(`;?OCmTgVD3S+VPBLa`j zayU50+%98rv-YQXKg+%Egk=0+5g&{R3V#qef(r@eal0$+Pv`LdM=4~zy~V!)Fb>4F z)sZ}i>|4%Ta3BfV0rZn!Vfk)m%6-3C7Xc7hD9fK2^cu3BW&c}Rb zN@q#Il0TNp;Pu7-Lv${WYFr=I0Lqcj4QWzN5Rfk@F5Jj@nvZNI%A;e}lEDx-E!MbT zs27y;@`xViZtck)gs*N>=vv%{JUw0%io#LLq&{%jy+41M^WP)cYE^Ir)7K|$uu3p> zE?A#~o&VCHkgJHxrt~u7*CeN+Lq2Z6ALT`O9sZU@+gKX&BanWPCjjk;LEq>c0M@v_ zJ-JbFnfUBfYvP__yWDGmg+8X7YGUkYxb0A8bvE4)?zi!VzF48ZI@T#;dXzT&yOA<8 zzq6)q-&XbXgNvu!R~k5w^$&&F>d+9OSGOnlou;t>Ci?vG&tY_>sWh4D@K-Qo94Q1ON*HmfbQ)4MP_OltueUc zt{6X9!1{k&5RjV?wGb<$H$Ai=abV>ERb&XSe)MmNruTn;c}v>VSx=idz!RtK3v(2UFr zQu)PF-02zjd=`suSxEg&#`d|q7V744HYUck3Ap^7O@$?P9dlCwGj)K3J!kMNbISyZ ziRH}Dxq3TvP=fIt-~oBJzeLdaTL2(G(Yq;hq4R^axz!whd6$zBsMSzepm!*Hf)HP9 z4bw+W$0c3u&ouwXHfFCs7-r7|urq$iIe1_ZvhER3wd)<918~vEz-m!b!lAFd{TL_} zP!rWJa>{{GcqYFPU}Bn3#gvXFqZ88Su9E$`L3U^WUUV>7s#qOHOwgo`pLlir8OO}H)=a&yi2C-Si`-F;Q=(?%;k%Y zC*SQjM?jnr%4Z1m5wpdo@nZDKab2#IJfx<|Y_KxBKC%w018vIwLzc}lf$a!&9;es;c)f4+Kd#p{9B`q~;wi^^u?zNMno$Zt>j_Lw>&&UcnTh}T0 zt)n5cqtms<)PHVf3~U_@TN7Lkg*G30XZ=^!&vte5avw_Yl=hXQsJsMOSOMbe4R%y) z`gd$1C}Ji_K|Ab3nIR9tPu=R`>G0=4$1}}DzDmU;7&Ll0;~I8i1l)1G5%Y(KM5wEj>b3yKq_Ji_lDfy6Remd=pk z9kgk+uUObnf&ek|(Jq=d3?>2ALCJO-EgE=bG?Lg%_Okw6M1k9t9@)PlT_%yjsoFsY zU~~cJAnOrwXI7(-&SN>9Rt|5m1?s7shaj22kXj?-M?!D@?Xxpsz)ub1Y8BC)HtXPD z08|b7%-vgWrd513yf%d~MQLm9xgfA)cel!47nzVTQQY)Mb3Q@+MO9Whxi zY_?IkX{EWg5M=Nvvj=*Np@+^8l1<$d%?G|sTmg+T`fo8XHQH4AadBr*G1~zJ;ooV{ zh{%4mUBgBf`^YJz<0K6LTySy&Nhcj&-l4k9^_Y!bb(mY>c5*l3i}5G;Ms6`BqiBGF`gEd7grk+P$M%galBG*+y=$Yu^-NMs~_b24Dxc~N|lNI z?bC>5*d>bSXhyl4SVS;vJl*-Pulox*Sv|y@y$v9TkShX&pXFdh5-Pz@={=50`wiGP%21{ zCS^u|7DuVkhT<83E?@{E9>(hD8IwSAsD#I!RF#lzMzVS@aXX!vQ;ojs{JUeIFjwj= z*{Xz7jry&A35K}>ptXk0q*hQ?zF_|`Rg`aM;oJ&(-Bc*-l92CDfxJD**RrccAI5k$ zYDhY_`zKm&emc=Y4K+H`*2+y0+53(;Dg1@tJ8|G&1h>yunSDeC=THUR%qrEM?w>Cnr%u68`Radktu!h?&|y{Oug?MTA2JGg{67x#>ib3D zIz`pmo#sEq^%sSCBC)o;&!TEEvaOpl;zdg;jbZdb0aUr~coRk!^~AwVFyxJyGX8tMybe;0v)gSyhBcGxx6nJBifmcwJ*nCp$tQ6Ull0BfpW`(J2P5BF4 z&D!GLWP(Ds*AChLD$ELb6F-B@Fez+EObHgMe%V{<3h=%l5rxzB6k)BUsG`9J(H|%q z#|$&G?9ePI@dAJ$Y{TU_gP%_y?=Nh$!z9%*H=)xF2jeqoDZTmM%jcQLSkdBW@ZFh8 zR|$3p!P1931_S$9mA~hrhYykT=8yifSQ=k`e~J{&WJ*7{b;X8ms@t*&k%&Xd9q8U2 zE;cGGRh&TLKjx5hzEP9U<*~8e`v$R7=ud?HS!6ixpgUpQQI#}Gi!m`)#6@`cg6VFo zd&VJ645dgxeN@}hDswcEwE2&FwfUR9Rz$&}=RxK2St+B!#Y9>$+z zdmdE|K7{EKvbS<+JM^Fb`$a7Em?poeAki_XjruoooFZ<}zrW`~modyq3tHc6zO%CCL5>(-@56}ERv zIVBa}|0a4&QI~V@xjbu>y2g(@K!|!(c35}R&pP)0-?sqHk0`RofwI&u=|fJznJZ<}0<$bP zet?$sbM05HVOxXf@yPd1d-Q{73*MQyZ0}FI@u=*yFQl;LN++>{+#OVN8s0$^0yUjg zyWz+zSsP)D*^bLY!sk$1tkRx^Ycx`Rjx+mg9e%IcL1d!{Xgn>cyTf9HS*OFz`fiK0 zhRf_A)1Y?a@aMPKV(*CP*jkr(WmikI;;vSsX}%i+9$ac&t7ng!?|Mo(RalN1?Qf?0 z&E^Oq;CtUwvO9eHyvCbI+wN7*wpmCde|oK-=fH)2?^L*nq=l7~ALaut|0e4j zi?p(8;h6jk?<A8{uXgj%0H8A9_no< z%ja=Ru6jO2(?_5syCRHX4NM9#h(6T4_uKDi=z7 zBK2yA6Y}}|OiPD4NF(c=_d~LyJ)-YZT&S|+%;fR{Q0&T0Y>f{}2Fm^d42j21_Ng!p zj}vFGiYv!4u%!JNj|sS5vCe2c(PWw00l&fVT3?areuj50NRxXn2nB*~i#p}h51;AV zuRO{e5k_l{Ceo(7ur=G{vU;-Wi*i}32FgvtizTFRInpQ%~bBOG5+1`sOAKllZ8c~NuKeD%g1m*b_g3f4? zz?jO@G=p%I1zH)b?;xr)HZrAJdY&@2XoC=t9V$#=1SOaD*_A$eLo*dqw1|YwQh0q; zQ0hE75e#`JW z1*4ZAC;1+i%{6d3{qxUuKQl<%tL2(a&e};G7~a;+(G5ZoPO|S+J8S0D*K6+2$1m2_ zQvOuywd-Y6`c-wfDS<3hSfA9o#^8pZsARZmSRR-C*2`u0B!B9q1h^(-7CDic?tkh2 z(UuFMIhf$E^dvF#mrdd+{@Gjk1(-dL3W+mZN<%NNvE6~Pc<7L0x7b2MZ?32NXjQXE zj6p&B*C&&UVM`;NN;13sX4_~tF%mT8y5Ck#$*J4r^1I^+N8~>h25?QZ3q`_q(#bQE zOX1Mz$xU;9oVH6_rW09{2Aq?VWuABY`6iSFQ#5f$uAc@dK~Qugd~^U&OO>l2E%Lr_>j|5!^A&X}N}S6*{0gGMxk z({a1H1Bm_xdF^W3Km$Hdogkayd)v*)R!;8;lewbzw7}3yC?Zy%Xt?vS1L39&ssR2G zfdqgBtS)*8Aw?nYmQpR(z&O1)-NNf5GED{mfV<1gW!0e^kQA^`96L(`(wOTWwbR^W zK>j0|JOHGJ_AVf((`!@rruPD5R#PtoVJFgC3D|wWOe4(ZD#`kO zRd_&L%chbitc47=dIN7wt)B@^>&kV(t**8{s1~wsPj@MTAQ~vWC7h)L4`P^kSb0RLp99%2m&(b>SOG6Q4 z_W-!o(5@=J>$}=ebLe7+!kIX@vqKk!5;F1FW5}lag%LgeK66+be!p?sd0)a1a$dJf zRDUZ^-vagKNJtK2f7qq(h6X7`sop)>r6r)d;dApn3yx72tYNWbs|58D&t~wp_3S2z z>i#W4C7DKaryI6c%02mw;c%Ou1;K0G-|@cZV5T}M)z5}?wsKuVKH)XZoIHU(>3xCHhXViUIDUlAnZ2lqQRyPw{1oLitknY-XH;q zh`N>?OrH~ITRa)aXT&rr>C3`3Z$<>cjg|Krgu?&?7Nb4~*x~F^-yf5%ORqQg z&N5?9XBU7?vM^x2`iZ!fw~l&zTc#Pi@8n6UMymk6tjKWdwI4mHx797bv|g&mW1`W1 z$Bhu!an%i-PK%1<1ES;>KF(Se>huwB!qSl5yU&Ox;y(ivas)taA61KbASBm<=s}e| zKXG1)i`pofq<+So*{!8+CP=PZ&X-3_(mF@bZ8k3~N5Bc$)o*pGEaxktij~cINr$8H zf8mPeEQrmi|G+7W@?L)*rn3`Hg&kF_`Uw^}n$+f?QiW_H1u<~u!A4nETk-2G)ssc6 zdfw{4-q2tdfio9ill@X~kP`5)g@r4DiR{53I4ytbpusGkK`F2T00*fHe-ZFY)S!$P zezIeZz?NwzylpzeP_sREY+STiJUqBr8EArRTw3J$wyo^?wRg~5KXEpZ44p7DC%O!7|Njc@o-srHLEds`v9ND1Bv4mRv?3fsYWbv%iV zm%)HNxWmQPuHm;gN4RuVpH@<$++hoam|K-5i(L~R*5>6u{%u~M&eRLmcc-dFJb5vW;PA$fy&tngI0~yQmXYwm zsVtc?EQ#jOlt1B5oM46pC=njDMaE426zFE41yTI4DM66Xe8s%zn0vhPgO%p=vqGOo zLp!?^eClqoL1Z8z3w8hF(RC?A_rFyBE*505*nQY5d{}u^AsMh^ZlwV$&!HXDwVBk1 zvZM=q>3(pYfe-?3ARF^fW8!$uji;2T(vvu{u;bfdx@0m3zgK1@5wFjCsLcbYBC5DN z#f32?n#sG;ATY>tK_E8Y3w%|Ik^UUp)=pGAII|&Z&)jtiEZg+TtmE!L)Gq+K{$1$w zKFtT#@X#*((-$UFcAotEP3a$(M9zs)g{+aWPH97V^dopm*)c?-K@~F7O4>9AS#|3i zS%VHAIm+SLJXKkM+aApSjGn>ncn5{Rr^!LQlwZpJgsS!ztLnYFtmCzL< z=^9<$)=7Q4R+YYP#EMjTpAceg4- zFh`x0lsq9`#{MQ z8xFM30HlFrqR$8FgNda1wIMSBuV_oLWr)gP=|>bciF+Zk?2ggpgjVCl=C#|U*rjhc z$m|scQP$2bA{$AiKy9IA2j;#d*Vvr-px^*c90|~z-s#14x6meqXj6D9(QnIP^82hvO7Go=DLi=>> zpzQ8KUjJKdqyqPW>%;8BzJ?Gg0xuflnbUw}_&i^wi^TkaYc`%Jy5gns6_5~V*)zMD zQVBoaPu;8__K$nZ|56YorS)n9BVWcQUFt1W3{H?4f&rM_c`Ut1E%14}8V%(VVVCCg6^xj3GFDn&sc|-l$VT|Gf!PJCqJ? z%|5myEjiOEA0!ugEvTG&4JL%*7}oung&wirM4{~wuz6C=QDwpe~m*9WoV!Wmh zcgUu(malwbUolwbqZpd zX;en;Rj(U;NLZomRK0iPym#yPu3K8;jM z*-9C|_ND~GU#g)fLau}v$yV%M!}3?sjbdg$Z`5n&Qje?3YnSP)B9Asdy#c>rEO6K6 zEdMxahI)fJnXuJE^ZK6xq1>)Fo5|dmB634A73hjdd=wpY!hv8= zvsx?TKs;S%Pz|DInI?~z;*A8}2Dft>wa;MwF;uNzQ$G72$SOz~z4s>8Ry8+FrWQot zBqpFFW{4xLOx2njfTsKA+XqVkw*)Wy2Hp_j$qQ20B7qEl20?FuAQNsBpG{igjmJw~VT5S=K;t zcPF?@AUFhv0D<5V+!I`b2ZsO&?(XgjUATwf?iSpGyThB==iGDmIXBt&?f3WH!5A>s zT=bl?C5dIGaBOq{#tQw%!c;D^XhQziD>iJT8F8RcRJ6g~2s@)2SZTpz zGJVu*A{2Nhu;_iPcn)b$5O}_BtFKXBkU6Vv70AV{&W$4&<(OxxLK>1o%(a5x#6gEv z;E1=i?oKSY8=)fb#mc(i(iBv^ablI-Pv}$1%;$W=VXC2k3BgTe|I&_5S3;7yrNX*K zDeoO`OxzF(U%>E^C%oKd2LATwrD(-b1ouq&ayBCu(L@`{V=UB%`Kkbp-Ay?AcfTPDbB3)8Ky%y4 zs|hwWBL(_KeM3xY{>ldz<5bp-KV1C2pXxoPir|dqS#e{H{7{LTREbmBxCN0qALQmz zS*Lr6X{Z8;U)_2wp`}ghlS0NzX^eFPRMj}mv-pqO=tNE3Fa5L&(4-2|1Tl1;J{!4j zkF`$inGfAQCB1$NQg&@Ulytj?Uaw#*nK^5UU8~!`%cK#xwP+atTi}>?<;(UMzLv34 zRD>m>H)>hPnMW`ux)X{kx)hjGc3QkR2+*S(IKt#6zvi@2c<-tI1JsH}bHjrUM(I)? zVMQYpusX+?D5LU_*LJxVA!)i?*VX)(1njTU*o)gTzki$&cH6J-GuuQmhJN+3o+zXU z(RAMt#Mis9n>EN-c5c+5O6ID0B}8^`e|nhUTkJZP+Lw>r0rO~`-W#KQT;0sh5PpVV z&bsNBY(8HcQ(1zMB_B?F9lj+?Br`-blh;^NtT+=6GG7`*bUa^?XH*K+A6~`;=1l<` zyD4~y^*IHkW`hdpNGK%%c1~uCOyZwSS)E}f+`_F)oFQbvRvRQY=^H#~zQ7d0fwty8 zV~cy!>GkjO7mKGNp*u*46ga+2zLTLwo#6B9J`PB@xR=9`5SooY?x3nQp~MM&O~-R2 zLcYnyBPiX*;vbN4NS$Ir(`T^dY;x$Cc@KNDkemsi6dH}oghyfp`Q~6UFlFHT#2Zw7 zbGsi>wPNe(Dq%v11M#C?%ErEjc9McRG+MTpJ?J5( zU0S^9z<$S&4@^ZC@~;;@K2h0TWJ%i*11^hhA<`c@f%D{ukpOLFolj` zBiNVXI96O<&6k%%k@ zT_bu)pJ=G9KA>xp!?f^w-D)o?&_caLqC)D9n8iX><+4>u5B-P;sV7OB6KXuMBZ6p8G9x7TqRg!R1g9 z$g9b<)qHH#XqSyIQl>pKls&Zye1Y&<>dLF5zS2%SuIcJnV5K2#vM*&}aOYvdH)D7I z23cs%2V|wmQPhdyGx22I#TR&2N&N5tL-DD26E7v>>Ya{sQ!a(z?KpoxgI%N$ZRIZ7k8ko}0E_{Yt@PouugmIWgwqC)1gQ zN8P=o&$%4(q#qYDA_^X%;X}iO%7jf7oImN?q7v!V%DyS@R+;~rj*z+haCa3}+ZUaP z=ysf5dsP7ax@FJ71eeZEXaweDJsAu%FBx(*72IZ5;b2*)ui7hNw!IMC!yUBkjt6!l zCuIBQq-}dQeE$KQ0O7qZGBA3JX}k2;0`a!-Rs*BaXl>F}&+|fTf>&##XJWSW zw)bwlTYg6R=#j0BX>PZVegB2BM7(xHak#9ulab!^Kn|0OOKjumj{KEpQB3Q{neZRO zz*?;&f)9>>Xi5KjFVT4A0u$UM9LWkrFQ5lZKD$0g;<;V36`$7S;Zo4M)6QpKlU?o_ z(+n1@fZ{LQcae0oYs)lCXp4$C=^ZPZl136)wJ1+ZV(~|L}7d1zX{WFHdz_Vkbg~P zS2*L_*~1Y?@!^GG<9WG=3;@>PhD` znEjZO{c0{6#zcl8uyCyA3gcCwld4+zg6xC|i&{vbd8byshm*0?c|r%=@T_@ zDG0b_!*{rh271(}(rr%x+*wYjFqw@V4^4>p?}uxZ&MqBOk6b%Qj(%LE6vF#WQ3Sg2 z7!HmaEI4w}js=}YJQq~olvbhI1(l^OO_&bW4h{}DJ6UJ~wPT@=ksk+r7;1!oiidnR z4DG^;>GK4A51a9x#^LEB=O$~1`whZI3q+?|iQTnYYuRqz_Xo=h_xQ%aMES>ewU#3a zwAr6RcPCCwkWIjsqdgLE)%xpP2nudX)60ei@2BSFQePE~Bnkwxn@S%!2^(yx5f)UM z+$G?z-*5IRb+SkqvNtIxB7` zH#GxvBnJ25e7B+^mKuqro)YdG%NDL9P-~rAv8VpLhEtTfbsxCSZ8U;x1f{ugcu#*k zykwoK6~DeXW|JlapBoh#!c6n3Has74H#7!*X?lB2uC2iVwiSJqF!STsE87D%zKd<% z2~U!JkS2%ev4sGGGIb7M9g;lS0y@9QkbMiqjd^!`Q^amJPn@IoLo=f3>SY_crc>m| zr=8khCf(N0J}ng!amMgokE-UYQvHpY#Gr10xns3uqL#0rR}eX190*Ox)1#;YwjH-K z+pu$eGyc=k2)vI51DA`ml9S~s68qB0ZDw&D9~#2Qc8I1+Z012m7P%a?q*DEv#Hwf{ zLa(M6)fGd;pRrI+m<$yJshIFj?Lr;+X1cA+>(3N@DC+lL{6O{PoC1RJU<2(-U7P&{ zi%MKEvVrE0w+sk|p}CGb<0*I}X_Ta9MoAY4;f2i~caid>;=jE) z(q%#b%m|n)nuhC+6nnd#Mbl;0kQn0IS{~V8K_t9Dkjud>YC#1~VW+rw=N3utvtVQ= z=XZ;uU_ZLr=UTK$`}3|U(_lmE`8webE(iKNHp+LyEoS?HkIkd&_fo9(-*Ikt+YNzM zwefu)RPu&@y{o_sy_thFkc5Me#SsRAKn$`MOQgRy3L2j>mkRRwBqb?4c_{2Cy}J63IqGHC>DDC*gFhTbI;mry`lO2z$&cH_eqgoFqwduEk( zh9U8#09@WiSFPDt_GlPU-44`kfHEF#cAC*g%s;j1qOa3|D!qAJW^O1s*{|NU1r4ZS?Exv`~OOvPlH2j-^=*p4$=Nvo9^NK+iEu zI6~wh$(L0jd`}@aRZN6K2JD?a^8U}z-xe!|cdBJ%Nyw-Lu`a7xa+y&2UA}FT=gR20 zUg>~-#%E9I>m=1b`Y1>*)_C=Po!6^i-uVZONH56(_j*ml`8aAm)gdA!xK244W?5eX zi$*qcBd}8`W3#;O!Gj;C!;CORl&n7EO;Vj1tmn0;M}K@5%Cv}}hRYYWC?7^lf=KJI z+PvvID&177m?7Qzuh+UMZP(gVsCRiXc+Lx`)1ht`Wabd25IaOd75uiXfh)CXP5tgq zti4rg*j{)I#>zy3rDUGT`1{GNZy-%pqpix!=5kdfwc0Fvu`!gjx_D7ZctuUR*c67X z@|z1#+UYm1c`P5gL7#u<>4_0>TR=G-Ov+p7u`xnn)jhV#EuRxh8Khe+)u$^h0?Q-w z-mD*Vp}ls$gIK}{zV|qj80~-Cbv%wF{63K>@6?$te?0RU0*C6O@HW6BTFl)R+9&OYlFK9MiZ&8OHeoS)d<4G%S5HV1w z$u-*v-xHv8)CxBeI9+dbZew zG8K7S-3YMqj(Yc+nUsDIAU2fb6e43l;4PO1-7+I)N;RxMaDG`x|Hkhv9ap}~)r)mG zu6>x4QoEmtngT`FS}Ar_v6-ht@}-G$R(T+fTcM)U3pd@Lw;daifWMUm0e>l5S3TJR zaU?d0E`Dzh5zghsw9{`Qt5EoMJ%Z=2IYnC#GP6XURxu*+Bxz9FRi&UvsMvbh1z28d zY>wshWG~l^UHL*Ub9_9&Tx@ku$nJiMOs_zPDD=3$)`x_0zuZS$eA*^mY<5lI*;~%e zq4Ua5aj{j@FagCn@Dp5Frfau*MBPJwlu1SR{?m|w| zxfywYU-R@{e(e0zr3^)u<$r>*I};cDVMjtAwp5)8?t+tz`fGQKH}Qk+8UmSxzQIeG zGArky#7FEO-44eFnz2xx{?2eKLr7KMT)AxDY8QXL#>^CvB$#h6YoEPYU-E+*{lpu~ z!*CpfVjO0P;-hu1DH>03#tL^>AN@@A`Ac6pR(v>vvSw#H-B9B16Pw*mQ?=z@#p)&O zp5};x5f1I9Xz{8*`RS2#Ppuq1kdCxS5S4Z@oAA$mu4MiJwE7ITue)wAwfGZLM<%cR z2lR}N9?@rsHaJ%3=R4!RT6Jb-vyd-KL?@gbkGJ(h*%gAg2H$B`={P|fA>x$;<-jB7 z3o2MYJ-=8_LVy*KEcHYoW%GqQS*~2CgGJCzUl%hmdNyb<$&Zqo@ac#_16#FnIAi_F zW@47LzUlCYY7ekQ0Eq_Dw_~MDtYwwuIDVcD|WJFuGOIjV%r{50SbhP0NKg=Wm z$wN9%2AAtp%4+UX&=3{gNTeRG63zbnN*HFxbSqVYR<|O0x>me_gJDNDQZSOQ##I;R zDy4&}JIK_C0Jf;l#v~}fpjz%rxqA?&kFn9<@?YN zA`nUwiZjbx>cTCeqzc}|Mbpu{EAx2ysvE=Uk6erK3xs}ezNph;9!D4xurSkCan+Nd zr>#Kd-Xc>|hq|kL-?KsTbW^C@W#5d=Mi+qGMbY(ez@qMTqR#6)ZVWV@^Af}&h(=&J zxfV0~(7Ymg>Di_vfHPJ0NCVB*L$K&qS;Z@S4Wr(l@LWRh4wVDayCZ!*h|HoA;WJ{$ z%gXm-tDe3qGWxf~LWTH-E@Wjq42eu7Q<-^#^Q3GYZ0}EZd;-X|adis?Gk^JW9PUbv zHp1bfA_;tr#riq9ul)cK54 zM7=7P1DKvb>nNYojsDjL&|+q0>d^w4?|w`iJijIP2s4#VvT;>y^kqNl5XQDH48Xbf{OI_!@ADo{H zm2~&QpN)q=3W~wFCr^==Dfx)zz(R<9u)!+aDf2e(NntDDgHR0L?xhB{Z)OcGI1_rl zaff&p|3cG0nY+*!s=VLL_1nh+1p;YZchszf=G_HGgZTZ094eZ3ZSRG!D0T&dSiC-g zx-Tp-xSK}O+a@=;l7+0FSxhuTa(tn6p7Wff_svYLAU>T=+gQJu6{zmvaNp*GvpB$M zS1u6}>ZA@5&V3Z*cc_*a=fmm|atzHd(W(GCF(0KadAMZ6gXpy% zdB2K=UWCulhNt}7V_{svmn1Y*H$usYbMG*@WZ9X-T%J1gZ_2|AY`-1RZNzXEg)Ni& za9FCA_qO*tWy?QSn{=vu&2Wo|b2<$if^v=hP+lcK9d5AMb(E%RZ#1xRe)n#w@^$2^ z2XuF|Q#iyc*+eyd_T_9{`~oxU!n>q$?|WA&11ylzfs7b#8&^w{ORg^x@^L^&0<0pN z(pPj>PfA*0{H_hJa=>`mY=~&rvgbhKBSNSHD^Sv5+8)N^?a6Xtw5oP=2pmEV(kpI5 zKvV49UfZ@54WWo9J86iD#kmgK!;O()OBwWiOwWT%T1`Z-aO^2%^)6 z=_&C2f>XW|yAOL4eCY_Vk;~yKEXA8&uxG`sOuM?6vpixR`lu9MKJ|XW(G!|(<+%*o z*U`$vawh!Unmd}yfR$N-#XV9QDiuitbm-@A>NN=No%=vB2zPeZ9K%k`5-DsIC z_r0g|>W19Wmp0YwBolU}wbpEt#S5b1CY4Qj8H^b5EX4z&yB|q)51GW@rDqFwO0tkZ zz=H{wS*JaIOp|l+saX}>EYsNMPQ^}Y#Q~DSx6Y0}GGfBxn@BRc*(umHAD!OmM}(|v z+Q~koEWI27hyM>A^F1X(bR~o%fe3gtv$xNi>qvVO=-@%RY!R)yT#EjAiX^^d z&;5%lkbJCwMu98GV!I$!O8qp3^b!t)yircT0v_-YuiGtKjnwSqu!|Oi31{@o#ij+yE&5?tP^_TdiyIo-Ncvt zvWXR+a3lQ!9SBa;ap-Jh;qbm?(qraKglx0GMq<$&uXU*eW3XY}UB@LVK#AdtFk&{8 z%KNENIInK>CB^wlXu7U$k@30Sh8m1E4w$pvdbVe2RG+=#;ZC>}V=Z6E6GL|E2=(m= z&%jzi_Roj+;ZXVPD8Pf)W6cAxjQx=}%34ySPkzu-uj?^E#}2kI1f!5(j4`2!80qMy-z zzBn=gddGX5#DHUBMBngMqi&&g)O{?w429Sy_jut$ki?#g3xlRSGgT>?R_rfq3ya+E zWbqcu8=^mb1?U!uaK)!n0wkU%Ac$~GzO5F@v!(Y(65=|~M8QBy9K;xt!(}zqn&U7Q6cG`-bt(8ttogh!nngigtI;6Y z;4XTPBHb!$s9k7lnX%Nb^vO93f!`Vx`LLfa~VL!GhlJ38skWNRMtis~n( zu`WH6Cb3yV@$5Zevs}pb*v0jE2!tWVYZUz9q(Kn_j)hcJh3y*nC0O**<@!0!L14A} zW^g`qd*Ph~5(ee4wB`T-G$L4Bb8aLAo4f00c_88)`9g0_^N2!9O?#jouzNTBx<#kX zUWm(LspH$0RY6Dv=xo8mPrIc)R z5?nXo_t>_LgaRNZfzLzc|AQ5h+1l#eRVw4VeQvkMW52`?;7ZVC`9#(PG=!{;UXy>P zr&X5HdOlyJdU1|?#^w7ZRn||@G)^sI&u%45EO60H>&y@DOBWt7=QFH6$^mGeZh40^CEoqxCHx_A}6L5Mo56~vC=;wTEcE`b5v=;_1k%3;X ze37`X3fgmF)bGJ((XA{F^bpX4F`uvC=0KUmY6`WEgF^Boflk&e&jTuH8unhznE$RI z#Rr~J9ASjKe%5jCQV>3J9L|bRnOtTzY*_XaqoQ0or3O?-?G5+sQkyN6u7G>&9hzhv zDM#<=7>7x5s3^-vY$MJ==4Q9<74$Nb$erqKlxh!L2u06_XhPsv8NWN0myEzUxBB)Z zb&%xPBK7Jh!!W(4QzZ$X7OO-jYHH>x(idnpd%vO{rrO~(zCgXW=aWs|$oW4V|)eI7ORU-(oJw!B>4;0~59-ue!@~$oN zq-jmihjV^j7UqX+@ONtNLh^h~Rv<5N#ygLb&DH>=k-tT6bYY>Ig)-=6S(A0SIn+>c zyOb+z3fF%lqefVK4Da*fup4r-AGe=<;fHNE?$I4fF#oz> zIUD}mbYtvBZEJ(2KNe-YM)&Xxi#C(SOI`oOmYtjIO$Tk9TnWC)g8ZU{l%-}FX|++m z2vs60GcPnmhqLSB*SvNMo(xmKgAkNd#!|tcI1-`}QLFpiIpsjzoQ$MwUDwYL(KxiM_4f zEDfX0r9@(o`@?*t6`=+5tjr-U)n#bNs%gBQ*B#*i-}%OssPR9Ew0icSwR9F|pnNwyde+90 z?tZcvSXNNpyzhZZoWW%2MAYK)V=m#m)_Nh8zoe)6sZwQXyeVu%_#yG}eK*C@8$|wQ zI=z$c3{7I+4nL=`In?6d;P6q1A&H47+vj|L)7 zUhd#I*Jt+`7Y71Kc}JCRJAYm(J<1o?_eZbvvcMDG z8WrBTRhd-}IfAIbA;159mYWFq4Qy%1;gI&lvX}FdgWdH}$LmsBa|#*cEeW2IOrwsG zZX``Dk*eYuy*iU3fxAiD^P@ZVgT`jXClZsC4g6~`qml0t>#Qo8phuuu{A~V6ftgvZ zxH6ZxxoCgnXC~0A1X%Gp8;0=|%7s9EKX_LyL=Ju`ZQC8D@y$=eZA7_w#=X4T`pkES zJk)M8gg;N3!;;SA)mbP(oh|0t1E(BwRhbNF6*PU&?nYvn9a{H0A4621Hj!YqO4oID zWw*X%q8l`BOF8)Lhjwe*qh@TgB2@EKcNC3vU?|&JHtkgHq(piQ&spD^fc?7SN8A+G z!e?79oOe?$2Uo>u<>#Y}J${!YgrJzA~=CEr!#fDrh_mnMgRU1u5X+P#*-B9L#TwaYqj6&X_ZtzLT zeGEHpCebeG7qq;rb1So+S-qDhFi*s@wE!&wo!^`nZC0}-uEjOexX4vlkmcYky9(tEfFr4 znW?^j83(EF-2tD+WvZ={D#P$qBR zk@q7+Xzuec$FlK&@jyH%S@mSk>4uwKq?%^>{U;s>qN_CNc6`~`qj9t3dU)mq+7F}S z9{@z)x*mY8IL)e>w4bFp`#;*Zt~L%>pvXzAvxkdRA!=N)O(#2yvMYrL!7>16(#{@l zX{b+LEuJ+Ue^iCOgfCUC1UJcjcixkmu~4T~ug?*n^nri^&Y1o4uM4aSjIQYe{)oSUBp__G&TvqCvQ!UPKDx}iAZ_(yzooaCKHh2XC zuc3wJYICIG%fA=J(IFXq8>2dhTiSefc`S2>2CA{o3lyH({*GZj)p&Xua`Czw3gk#Q z{$h6AQ7}MR8Hb7N1ykgUMYleM7tQjG&PST%@4vkQ-cLjT_PdC9w*Ep$0b+T8Pg;qN zXQwsh)WzZ5gl(QnIqAwz62e8YbyO54GikPQJrprSGP$9GPIaHPfZ}ZN!_#vD!t~w7 z=qodls<-*vTV2|gYNSc(SZST{Az>~R4ZarWiswk}FyG9lWRPKq7ID+otn|o(WBN2+E0?b(-fv&5bql>a z&-}hoZKiK@`!tWf&{y>!EBoyo3)9#S63OtFZ@fG%X;csRCNTeDbutMNngzG~0waxQ zUZf#ta{H}!)Ba1Ss1&0xq678kZ(Dn~#o*9SOLJVUs!ja}#UXrQ@UJ(jS*U71l%pL` zb(auTmi4z-FMHm)OA@~R1z?TJJ#K^c=W8UI zc;uo)w2F<4jDv-lb;qmu_5?_%X*_fG8Q;XLT>6;ZE8B}1N9Wy)4RU65G1iP5i;$_D z)2ZHG5>oe&xKy1V@MJdXZu0^HBKL)@myd6U{~{NX*3O+FQ%9xSK`k?!2H*e;O&VUsUB%=lr;N;j)o)g5629 zI}w5{Ny;W5F#Kn9{1Ysr7*OW(C9j*fArGLM#F3CfatjMJN=pVC{h65klj89r9Uo3C zT~=$X{nhhrF z8;Wnfe}$@xXR*Uh-(jFAEh9s-;m^XQomiYD=6%z=yK5dDmHt9AN!0~YFD1;Xe@5s! zvh$l)sa(>115=`~O6!wX6x?f-8uw!>^X0NIt9iocui38-_?kgr%eDkZs|EQ+rvvJi zM&}qW!KN7#{3Q5)f)Yz(WozMZl1T0q)_DI^3b(DD4WAv)j1B$GTunm5pRF4h0^k7i z3VC%10(s;|C_i)p>dwz-@wWLRXtv)~Mw+QFtB-sh$7?K2=|ma~*J&#wH^+^ie?4n} z-j3i?DQmh_c8QhzPfGyU7$w-M8g1J<^Wf>&a?c$@$&iQ9f0~QTO@xh2{NBb3qT=tX z+P2Nomt>ro{oAfk|1v1#H!y2tU?v$M@k<2YVquAoLW#irc2e7b@yvH7eYqRjcPBT< z_#qE(r%D;Wk=eAVGMT;kg+cnS2P(nV*Ul6IyA0W2^G6ElV^b3348 zz+y-EV9i1pPI>poXAA{j@y7ht=jEB>W!pwPx@=^_&lyS3XaU!R3l($@xS1fk60_a2 zJU&sGPI5CsPXYo-@)OwoYRe&^0dP0w@r}oLjRW0wft{Xj&F{IS$PZa|Ff|<1@DG`O zfUVCzlz!{A(VSg{r~;U|S`kX`gl=XtbKMO*T-daVyk)YwgfLI>#9#<0C%lSa@brGQ z?C(_s!gm92WnRyoO#c$?ry6Fi!eZ?vyQ!#^htdqVN-*K(17}t;`HJ7Z2wQ5cry-qy z+GJ5xwopA;8`pL{Z)FdMfO02Se4N9z6CQA{V8oO7mxcLL2>g$0fP?u^4iB)f105&j z%TL=8$qJ>TQhuxWK~Jd$bp&8s?jOW}&{xjEoCoXz5`f+4Vm=}4`$hn0X0eZ_$w9Sc zh9RJU|KWiD{E@r?Q2K=LJqay;P;I6GSyrTe)aNR3AtVq20ksJg^r-u+E;ycnVGRcS z(@fXbi?fd-TAomdW;P(q0$q(tWrgc@-(?s-`_DM&Pl`cZ2QhOQeRo~u^2bHg=YVGZ z5acZ{{KKJS>X47M$*kjnIm1f_9U0KI;Aqk^X)-WjlEXyo>_+F*?oj@UgiK>V)5?vB zO)s&2%EVv<5V~G9#WpS%5gR-dv+f@^pLVKm!5jwh#%xyoV`-jCx2?2SrOFGY7=Lf zsLXTN)ReT{X0l-LD?M|d(cm)CJ`dE;t9GHBOU)XS4BbXlTf8q}VgK!0{!{XqqA-9N zA`dNv`AH3V&`)aa`~dAb03~Ak#?y}Kw92eM1A}=)lbs1|Hhl(4i;XE%nYHKP{T{6K zpe_k(Mv8xmUgodVIG(1xrX}8~c~1MMP4;d4NsNsiK+I4`1Ev`R)X-)V=b@+!vjqc4 zdsB)WBQiP~i-DfWg5e1965H2=#vnuPE_B{>N~rpBF7Ge7hV_$cd`tVxKe;Ay@RJ(% z=PvTY&vg(A#@}hc8C5cir--M zt&gR9GwMIS#wgfU113H<{Jv+wf;>j32%M(ATZsx54ipCP?bQX1WTA)xwPv(`LKrq@0~RTJ{}pz8Z6!VSLkebhg3 zwq$-7z^-*(BD(JerrGdvo*XF{TqkO0r&xP5$Z}MyQKFrn2TLu;%cF4o4~($>2aNk(05I<6|C*}Kna*tantTi<`Od}s z6%6x1rWX1Za4LB8{U^$8f&vTgwdu6_fY#DRQsCy#)Y^-C;rv7kQjQ~Om}-oT^JVtb zc%!p3g#XHdkSoRkCZsspknay_s}MfO33^FJp9NoQo=GEo(A%!DO1#xl9rLq19MW-1p%(K^7mXfgw5^uGY`uaNzNMP#(<(U~dexBlSQU%YuCGRoeE&f4^MNxZ-(H`Day zkN>@2_$ArC)WEo;4fw>xzp(bdqTTlv83SC}Mk4e3Sn8LO6^RDM$(}+F9{z>Z{}pdU z9$*o)rkBHM{yFddB{{!%Q}RAw9PJIH$KA1Hd2;!e+WeolEo_4j9k^Ynr2f5=_$3L{ z4Zt{R;r4yfzd7*#VECUR_@})74~Dwoa(|6uq#)A4^W{H1mJX_^23;0^CD^f`rO z;^TsFaPejAD#Sl^WX8sSrpBov^ZfMr-#yFkH0WPWOpY-!IhnGk2nclZq=DHQ*hhbS zVjKu<-|&=l=n3S>YWsmezG_C=Z%bGEfuNku=uKgjuYu+tQ-}Ze&$7d)IL-@Tu4bR0 z0VRETfz4=U9yGF+{cbKvJyUcb(}7-vb3EAuafY)k#{S~QL;lB9{$EYpe`PZ=&0$NI zaxT<#wX}Ym>*?y~WJieF?TP%HwD9n&jE~p!8&B9+wCD*Meu{@{^z3<25S(`qq%aU@ zVr(pB^1AW*q1Ekx82Rr8C-<<@($aaE6;h{X$a$PN_T25o+O;-uIl93-<@LtElm_Is zd6{;DH3?G!xn*WQ<&{iia=#qhO!@abXwY*52?7^$mYK`BqZb%upuD^%P1u3d)Ng_Et1pIB$u*QI`CT?-lqzN!zRu=5 zl^L0-uMK5!nU9XYir20^{4n}GI&%mz%=+&}n~lg;%at;x$ib;=p}-oY1)kvmEwYxD z%c^$mfg)2>X(@_%T#T-ZUHspQV}JyN2~EX&_4JKxe2b{pQO?#{G#)%_a^sS97uBtv zrmZnjLxbQ*<9JddIi2y}xZq!ej(_MEc@ZoVhZ*nJPoG}V$;@WyJ})rc7hl|+{Aiol z#Q-`tWhICOizI`G^P-KLBOuHFUfeFCf~4U*%I+Ue1C}+UOt1)bAFZk{oZZzIl(6*L z+R~zt`O7)&FK`X!gdD)oif3)hlw#6OEMx{UN}zKF{xc-vkkoxy#B0x>A77pSu69!) zX?z~7@}FkXHY4m5x3WXk!ovq_j-8@MQBibSTvQ;b753lLF@$e#+N=EI8NgOq#wgg8 zU0i17n}Q%bRwIGw{l81_q*6P3Ks+-z zG|Lzj8+5Z?Bihx0wVekQoYlo_{wo;%)ioa~gSoHSYnd9;tW<)`S#Q_yz$kEjO>9uF z#@Vx$psi5;o;2hbF%ZmZ6_LITJ>%Z(7H|3Zy%CLt8I_mi;Hv9@CdWDMk964Y5b_JL zNQp!8Xz!SyVw)4K$Gf2f^!ove9Cq$~;`S!me-nS1NdLH1Nh0VCZ4YSgSg~+$t|J!5 zou14lT5wC^?}{}GroTFX(q@`9iaY!?I>?c87Vr1DxnI7k6g@CcLv(sMOYnCGQUe43 zKR(gBxh|h+iKTb%Z(W*njRjXVQ2vJeewyECeey$G=78wMm)dd;P0(FupqLgKUTGR<;(S_#KI^&l(8|;U!5r`JNw;sB^V4=()$ueTjw*f z9rH)1GLhO78ymZ^WcZI|m0xJ&KOgB!jSb{GjNoGzMgR3rW(2;kP}R3K@ukeorPMWO zlN)j=6j>mVckn)+OD?Mj=@%QB8cTov{NjIw>8Jnx3y`jm(MVx^0eQ6EL5+e)M)sYEP!){SgFAl^I#@l5c4AWN$urHWD{>573 zKVIJV8y-N-Y|j_ae`jw3b9@4r(lAot)|FLMI1v&k%*`Q5YFUXF1$#~usi$OM?;#Pd zAF!m+c_C#=tjvY86q7c#j4*3ui*tsC{}mAa()dv4h+xAo?>ev%E=&El{fk6_QtKNp zM%Rk#U_#Z@dijDTz{i-Kcp?A$m(x1M;MQ`F=%^@0p*95|G)lWlZrRq_G~wFZI+_3F zGye1jihd&B{o=ndS-zwc2>VwIGfEAmW;hCDnx*6YnNl_|z=8NRD`l`B4+P^A)R!bY zeOs^C$0xMDJyys3FAw09gxrIU`ctSZ5`srR(d1kD)qozy9?JG@mDQN-m)Fa#JXYqb z((WU3?juWnoc|lC4;>2=h7!XGzazu`&j3)!K_PqPh zlEdXv^%eQ=6S@C{EtU%Tq3#zMj?zgiM&`JMzR|4Cjl!JpDdYmjr-VdX_gbX?vIBuQ^y6hI5(;mj&Akrz zQr)8{od_(MAl=L7+{?ffQu~65qzIhTGL?G&BILhD{s(?%p?$C6nXe4quea>19pUwT zl{hon&JRVLpi$tt;<%*LpEemK^o|JLj5-2GwCuG~whxZcxy};G_|)i8+hyi&J@}BPtp- z>mKEQlpAj!R;^4uOxn8SiUorrD6fkSSCuTt+w{b7H@^FKsjChM!3>@;6x ztbI)bcO=XzFbI(UmRV$e=)DRtQ#?AI2mOSJ>{NwO5OyxOK+Jf4*;P784}p2gBHlPU zC5@r=MH-E2XF`&uW|hT(R^Q0T3{t|4vJP?Vcy#6q)%>%3>BeO`eb1XDoTGVKD#>(e zVZQBGs22I|dR%O9WbXTH4Ns3_t6{F|VLY4Q33=p*qrP@nd>wKQlR<>?cZ-b|^6Go5 zh|G=#t6u}Eo*wT4t{yjH6yocaz32oENh*+!GCVJnN~f;o846Oz4Jb5@EdMBw_>&Fz zH!1!Z&ynAuygfG<3JQ2!Se~4hj}}FN)xgYW0QQ>f)XMZ2j+(E+t(F=k+GII3iiY^Y zPy${lKVz~l9?CUKSS@$$73A@T5x_TlV5O4qk0F$ z#QZ#JQl!{w7A(&P9*9f*ZsmH`<=q=(szd((M?&EAl0YJ}s(rFZh3Zv2cTe?*(DNKg z^|$1pW*il*#`YfU)<~{fL1U2VRhj)h+m|{=tV>`~=b4hvQR?e&##4V5#{ZO(9j->5 zSB%C;j+z0;p#bf|?ZA4$rT5zi-2hOJW85<=V4mliHJrxRzw&SuCzQ;V4b(lHVF$X8 zj(-gan#5yDrnA-P9S>5SkKe_!NE|Ol$k*T+SbN35cpRed7vJ>^@TZJXakl}DhMjnQ zmv?z#&Lrt`t$r|0mFHll0~?PRBNGe!wE!(xl_%4=!A$2j=~3~kjuNEftOXMiH_u1< z5KVQd-O)*trHC;X#x;8Srx!H#!e@P9$bz^F`)M?kmCY5L_h)?#X>e&j!nUTKhFMLl z)YSl`S$znf;`K;@lD14=prXy(Kv8Yx9c=apx;7IGKTw|W8@7m~!ZOhrbxF|5rsmF( zAB;J>-1RjS^d0+ssn6jO!o$Pui&1!zjAz!zWjji)QA0R%zd1i+7;n|pCUm-F823K< zwu73mhmH9q7!#%#2jCNX6s7ZXbx`EYl9$|iB<>JmlX*M)Tdi#2yeiK-HHLwaxX^P> zhOr;uhn>g|kPL`$Tpqg#Y9RYO z&y?x$A{qR?{=Vtm+W=zeICOp2*X#}sx!M_zxJ08yVq^L#;o?-*a_`HUqPQEB)QGHY zSd?AoSHFD$X)3LYKzH}7J&+NV9U=~mt^ z-Q{+3<>lu~shQ-1EoWZC9Zsmr-*yCABorOEm1qIwbJm-e3tn1N6PObR5kU(V)oZ98 z1$#%GZQq@=zj;iBHJ{!RB%NNAGMZLCpu<3oYk8}q@tb+`-WIOjHgSOZZw`Vgj}#&i zGrVxwMr^&E{2oQeY2PKgY|P>7#qm1e2hhQun*_NZ-8g;xPI7%0!_w=rT>e3F?|!zq zmFP#adyP)!ZkvNeL)PGD5h$eD?Js}jmrgKd3k7Gq@;iDYWa9hthmz69_j1OpXUcT> zicZgWZmc{yyN6EeBs0PhEV`3z&*DL+Bi=3a+o`Tq#9n5UIA$e_k6rWl`4pqkFh9#F z37WgQx=t_a>!@?H`f(1{w4aXNW;zyYX!R;L!LUqZ8drcdkT_YB^oe6Z+I7-iOU`|L z2ruK9_`$a29g%ACMJp(2@o`bKbGI?s19w#uU~RjM4I^Wjg<9*}Gd=e=Dcsi7Doup? z4K`u1=7@t!g15c?Gy0Jk->h>)K65-V|LOW*EU~wHc}mVxR1IzF=mK zNozVy&DeadHjvvlu^B8Q`KCO5G27Is+p=jX5qa<1y9ZCT1(OcoFUgKI9^a$at~4F% zUYg$2aX3j+u~WqZ3o|p8_E9~$P#k)X_Y2cByJ%wW<{!fJ)0W2ON84k1?)&c88_~!k z!3~5!WOn1cv=(SAeeU8>T5CK|8+h|>NM(_;m8f{ad~RfObF;5IjOYT6qy=8f(S3A@Rx)!Yz z!tFyuPu~`E3a4%n;y@M7P`V}0GQ+fSJsb#Y zU->)Tu>m!KPDN{&?1$n?^zs*Ogzl8n;A1E`0gM*wv30p-S48U>MeYmEy3xEepQn>L z9+~GLH=Uv>hZfAeqD?+pOZ@Z7dHk5x_|_KpZ*CS51#vq^^XhtJ1w7n1y(c}SntKAIE*& z5AN%CJ@X`vBRRg`&*$}it@mG*4W5gdN6Sj*eEmuX>8=ym%faZhZ~)8GKYulx6)7dq zZoSS1r_P`Xkyt(X?T>+5XVh6$a?`p9hrI7QU-_}0^&U2hIoMO3N4n{^gQx125997H zCSjX&B3O9uWD-s3^c41gG|52BF~%ViZ$EWa23s_6x?zlsTc2lXC*NgJI;m|8;55%znae&Y@OOA=r>rth;7#uyPwN z`svy$+4&LPk3|5pYR$8=g(z#xyGGJJikS3Pg<)Olau!hFEVgz6d+2_v^7FGfM#-&& zmNtBgsTuMRt-90u)k#;-+y&%ZSkqLKL0KXhR_{20r_YuTj`E*iUl><{gi7@91^H8k zMB3sU$qMB>w-;ICmK@i9FrBx~yC9+d^RY3M{Sm z`NEYH1z655@OLK4Il5o|ymUISbukXnc{>V2ye&b_{E?9X+K+$TABc6e8~L#_s2YWh zmBmQktZbP3u;ps3Ge#i@`c;@?r0-poT{_jvKPLtis2_;T9>KY)-Y=OL6yavY1m6Zz z7RN^c;6*P=XAf(V?{l(IA87kU=QWa`+HL2-i|41CAqyQ@r`k~RG^nekP$yNg>*xrV zbuMhv5fe`)piNRM8yOJ}{fTLi6HuG5lHzWUb68@mqvKW`KA5BWYxD%A>2%DjuU|)I zM)-gr1MZLCmq*1-ogD4jZcK>ngQ=0MI4%X6b@aXYyOyKte8w;vz!U0}OQoDrW%F@l zgkx5cZUzvoxBDNQ-v5Tgy)Uyv&YNp|s4<@bmZjq_ZT9Zo5!2gy`O-_ptL(|wqSLL9 zHVZFKx9f-sXdDl=QJEaH#XH-bq|28o)A5@=uWzfb`w7k7nf)y4DmYl&qp7epOm{zf z#4yUv#YoGI&9yo*Q95yn<@YtxoX2RX)c5iPAzDpP4uPJb;IV00f{?@mfDZca@%Q#A zP_fKXBQd~_l#FR9+(KR zCjPjzuzPTp^hz1G61C120YcbE54Y$0z$Q`dGyW!9)fH2iUJ=tuaBa8PBy1)~>W8zD z@6~Q@Iy9HOYUIE*~yV7vDj;Ie*0$nZpYTm(W?`iyFwz^ zvQ$|?rTx8OJ(DY-nA>8{>s%-Ac`fxYioSW<^PKQWoi{*U9uUVca>mINbSA@Ka z_utIt{8Xf!mP7cE#O{YkL5NETh6@uCkdOo+B}LK;zoXj7+*=a%y>0{91@uZLl@>+R zYTcs*#e>MigT@Z-^{Er>7B3XM*czvEJh8=IhS-^P`JF}l*u&@NA>jDxki zghsMoODqWp?T$=vK~j(9SCJ;_tHg4I{nT6*s5DA7w+}z}Au$STCLEO{{EyX7DB(kb zVo-dMTubA(;AOyYH~68d>hXmY5tltJ{`(SUH0TKcHGt&YU)DK4ewU%^o)Mo%2)|r5 z?$N8~tg3aIjiiC&ZE;Z1?ng<(loA|+q^lDL?$+u1FUCgz0Y=$TQJ@crk2dgp`)2w0 z!0Dye>d9oyn=wNU-#=R)eJh{h%gt*1_nk@N+kAd2IiCdG#;>b$^TjG2ClBx274XAT z-ds>&ss$Gmb>0am8wz(_*WBG|Wk~{(4=ti+e`lR;M7%Sd{lz5uT}z~)jZr|M$in;V z>;M~8e>-^OwR+b_#w^3B8X568(X{LT2}5-nw(?svaw0U=!q^-p8t0IL zT4M~%oDV{%W=9@~yKo-$^)vCt(SxUIm7hFlp23M6em3M9y)e>uf=|VE=*Q|T2YUz# z*^zDMyTov(irhl5U;eS6PTO;;vvwOz_IoST#aE;qIUo?9 zq6j0KGuv3QDqgO6H4{I@eAugW?&sUE#z4k~c)xgB)96Q%UB5^z8n{Ow|C?G9~EjBHNh z%3{r4DjY+0;*a(A)Q44s5Z5)l5T!9}8%8mAnk-te$M9u&|9UMxx6+!IRq7d7*ciicQ0+R|h#8Wn zVc2|^6>(!k)1(C!{cy~n#s_~*>infpxyaBz?`Tv1hHv!KoquE@ZE@H6rZpwR`JQLD z(*v+6IW5<93=>z=9^3M11Pz-F=(lYerkzmme){IcMgmcq4;1d}v~rRpw_ZPJ$44Ta z?IMj&CxsPHKM0MA#u<{-XgM0TXM=$S(1+wCX)x)LDYy`4`o1Pzrr1cBt|YiTcy&*l zZ1`cLEP?s7SyEu%X-gk%k90fQiHFgAzbO^GC)@L#xX0yHx8OLf0CrGPQfmZrLXuT5 zs84=ZIL#1VM??G#`(tJctt?7kWwAy^HCZU4zgEXr4k49@t6yZZbWUiGhF!-TYvSt|{^I9w%iS zBWFd`)(a!5>CF6XFS_KF^r|xR+Nn54d|mlf&U%!D>xC*7#bd*n6h(CkBAOo|rCN#9YoT)23QpD^?{4Vx;;xWN{J`S1wS)ewM1@ z3HoCl7$s$q=Ij&LcMLzff1~VX$tE+}fS)5Z$P$}@{yCZOKGPJR0i|?~(|D+;(+dgl z@ee=o%1N5f4qq&G$52DPOcDSid1maVeNQzTp_6d6n2zJVlI`%c)vFvF96L*C?p<56 zpMJ-NoY-&#ozo=<8coUK;FZmVgh1YZ&S=Lnx62eMMZ%$*03#R;yI${CI(AgOU1f$M z_faMrGVx{W>nw^VFLejjzCs>$nn8{l0wsbXyi~pctyC1iqwlCCCFP^eYrMgS%D#0< zC)=^3nd}h`Wy}BK=rYpWr`tuF4{!KAS1F>Xm*N|t>yKbFr~J!>cd0zElizVKVWy+~1UZ3}#Sy{f?(vH< zS%H)U?W`lW`lNP22jb~R`e!pd2XT<)z2vtFFh3@4uu*4cmand^;<387wY_N$XOHYqPwwy?vFHh2q*o-P+8^J$q)2x|Bp4F8H@PY(%>Ua#eFHH!g~ zO_|M`h4@dmK8Yn&N0Hbq--Sl76F(mX?zK5&`aSa3Z=)Fb4@tC8TG66p1ELcxGw)OC zObn*FPZz<1%GN!~pmvOB`Qu%L5!2!6@H>?)9YjncPOq}zMHn~RaYZxcWC|_rGgYQ30n%8bl|cd@X1X_>)oAv2 zP8q`rE&MO;E)0vd3x_~pvb6SV&B7Iz=DZx-u6l+@z`;66gmc@}(7X)RX?V%{Ugq9c z(`RLcM`hhp?~6qW72w~pBi7EgN1|#1RsD)bsncNQ$kezX^{k!N`Mqmj?>Fgnx;>qm z?#L@rb=P*0qSQr0JELJAu61(8X0p}3%up}CSdwAd(0j3!!in*R4wnw#(!0#|A*mM? zG|F6(YYW{@TYg{n|DYsm4i4!0G?>l_`= zuSZej@tS}vG^}+C{p!zvPOaA1bV5^TyT*LMd(WCPhhuom2KPT^%=@V%l266}bw*o? zB;?K;1i{fdr|)fRL<7RmAE}f|>WFFZ!jA4PgN`qIWM1X2uQV_U*!t6=o5Ya7R@(ZJ z%e_gA`$cVcHi|%jb0*czurRTUjHE&BaWsVnzD(xmqg>@gW|=Va(Cyy zJlkgz{$0ElxPMV^VyBfcYut3Av%(3?@)?4-+7SxA+fA^9SFK8UFT>XcBV{n#6sl)$ z0=uD*p(*6dwhWrZbEQc}Hh6bRkJx6_^Ke$wnw`tzZ$dGOn=A66u>$7zoqI zwERX{|0F5_)PidX{5SGN2iab|s55XbZ>|Uy*Eh_O9?Yz+#;HOlJGOfBioh#8VeT(}(bdS+d9`TGW z1-OsP&n`Ay(#{gT%mel+uBzt2@Zru*skl{#^c)LIUXuC7SrT-11(WTbaKp-f^;Awjc>+^*Z zrhE%@o$jkY_46@aSwrLCR|2+9RN3P*>f)a;7LP^>5~83!1Iucnl7X{}!P`-08Khd# z+7(JYH0%yf4KnDY*B!zF!#J^@%#3Mf5Pz!d`Ez6nfoU&U-*;j2Jkba~-tI3a-B4DB6J{$8CI#X7 z{z<4mV@l`yxo00RhQ}LkyF54j*X5cF;S`1a&GSflAl!v=>I(bOGnP&C0YjTgJ*P&? z?-To3o!$-NJz+43jSRNfS0DEY4Zp_P0*(jJR%wuzOMwHau#)S$Q$+PKSb;Q?T>kuEqDR`&2hY%)^kuCalT%3|~ zjI6|_uu9lYI#pitT$pW5FB=voNaFye163k4)i36HxNF(vHZnm@3#+J5;Lv}kv0n(u z-W;wgGez8Q&LJet_z#Z~H9WTl=oWTGg(_xf``1w&*^4jAf3CWXxfG)?#~r4d#Rd-? zM`Vk-&%zj5XAGR#yrDUSodepv99B!C6zq1&Ia#MLwE8px)ES9BAEFL#Zm7}E4WVe=AXz04M z(88jeH)&`xV?(|#T|w0T_s|lrWEFO!)0sFJ-nfI_Zd-BDFR3~_@6ESENo-XRVtcxG>dXGdST>-yk7`2*l%`=+bO!J3O?RJ zh!mnm@HwRQ6HAhbWsp%Y?KtV8 zwrQjc8JlG3Uvl#ihLY-1dX@i0S@8um&h@9#KMNo33vOJald*Ne{!PO-@M-SJ>`{~P zG7zuFa=6hyfizaUyY^U1!Z=_vOpnG$ksf5Hoy~2Ojjmi_V#*+YAjMpROPZ$Hv%=0x zlwY}<>=_#&Xzc^KD@|@`#<~eOkQduinAU_G;I}GoMV>fe{tCSpl=Pax)3~ z&EA3MXji}XE)>Rdydq-`eF1IdR(Hn>HA(F$_x1e-T|L8^%rN4?preRu;HmXG=K>kv zO2B05=^1j~nN<_+%=W4-{w32jGpeDGHD%~#0MlhNgeu_c(ImT+$yIMQ$B6UlppEgO zq^pW=vdPOMRas^!BZ~a3*W{k5l$9@FSokB*bfzWz)M_vdYP9)hB+B;+ih{olx`k1= z7Or&!ri75IR=2z zo%8Bx3OrKqJ0+kOGUt1k^QkGSox5%q#drByB8P;7M(iC0>pp|g7gQT^3^150c&hO# zE%RTU>LUtC5XH!Jw59eJDo{5Nea%5Tt8JPIf=cHnh|lf1N~e3DJ=Ff2M=-SXQlqL5 zYxBE7ec9E^oyJmViJ+y82HH8$Z|~y=f>2=8nJ3V|rCSCf}9_z$2f4)3#2O z3|ZEPrZ6$?7N79@1c-%=1D$J&>@Hh)5-N0F0RsZ}wV3e@S9lSi>$PCh$|iOVc(&8H zI;k_#3iNnap84%qZKqlQ;ileGHI-b0+HaOQH|I`hI={;uVM68=lueABcGT}6fP2%f zvTv%7nd0_tr8VW(QA=msc%krZm-dFH-bf~p%pQxrCV*ZR-%|EGuc|O1}f0 zW-c`_m0Nt{=ax6n-XR^Dd$Y`YSD2EINy-c++cl6&qkip*zXD~e(gRG&Ef+5_37Z=h zvcF?uib8(3`(m(EXBt0CA9}HC{C&RBGhyM!1I{w5L)Ag-ll2}L*O7|6a`D$clOCx) z^yAFD>I|FXI4&L)a5Gg&7;7mWmhvrrL6;u9995znmONJE>){cn=rFCQF}#*i!r6HB za2Tmr=p$dzaxY_MSu2Uz#l%QaQ%7U>Ft zv+yJj(O;d|KqV`6ZGaGqm;=FJ4*A3J%Pu@fZiVCEYDg9BU2sm8aL_$;g6|y`8|QsB z^6QRSr_H;%nIUA^BI-M{l}fOJpq%5;W{47xWfpKN(%55%L4&YL@uf^IJH9VX;|9*% z-ds@QfY4yaW3IH1LbX=r6s-Mk9Qors1Tq= z*{Tg(bOzB>2UA}WW3#f+hvj%jcf>l>$L(hAU(u}HTXoGr{x3cXWBQpn}^)!7Yx-^{T5n~-4kq+0!;;ySCi(n!_p zV$xSnhcCWJkv^Dniy#VQ+*PXHNCEWauACkspY`+A5hJ6+-kbmXGDxlJ+ol+s(UL-V`hPq*{aLbK|8+Fdc|Db^_o@HW5k?;%1ajc=Xi@xCMD z_|NDEE+;3a>%%tD(}BDF@Y9QRb`?!)-L$4SA6`(}lUO5Q<91=1HOAFTnh6Y**6^Ik@&!<)Qm{25UrA;N|pDAbGm zbdz)UDS5WAHo0Ao+fSSJ`3n;k7j+%C*HdCX(TmLZt}8HKQ;TrhxON#HxFk&t_fuu% z=NcMwG^~NXyS6P zgc~;KvT}$6^O@rG%F9fW^{M4SByM#2=1CILyVg5R?lm;qd zIml}G1mv&M0g$l-4ZB9~oK$ymU$?A0jf*QM^r1(E%X2FNmJ@ru2foq$Qr6-^#rtj& zY@_!xY$`{G(lV5KGJqy$lyPjgmMG@-Qq`Y@he_r)?!?}y-)s(OHF`v92vIoQzDec(cy?Q{-y%BUj`gCyrXIMx=Tqp1HwD(RYaPtQd6Yy!7y}^*& zv@23>>-XlV>(TF47My!XfO^J2SgOJ0p zY471)Fe_?~#T@<)LWtxIp2(S%npX1nF34UiHG==@=k?heoSjvTV(WUroD?iUa#<}+ zq`Q1=ggnBM7<_shzWnxor=tJ+7r5@dMJp;hixuXTW&v+riezf5m__$q$!-Et@;-mi zCVT1f$-wdxV-0GlPVNZdp;{ATtGKEPKDkXwfE5ntI?i8C^+s2$*X^&%G=$A|@}9l< zC|{!B*w|YUZ!#+UV$F@NmI`sl_4Vz=IE%hJ(ya`UV%_>;T72!k(LR|26B)GMSS#b$ zASL+9X?JtFfc{L9cTPHsa=ePMT-Sy1mOH4(I64h4iJBS;ILg|=$ZZynOajcJS!=wr zP@S(GvL3O>@4fK-?lxR>lYi7STB_+86L+zNcpl%|rp+G_=I(&8S{f6@TzzZxvYAp( zBhQ$WQ%nSlF!##tk<^0{kUHkCJ44H5o_0{<7}uF*BQ%A`C%{$r5}qzi>q%9Wc4q&o zNRn^xfs7!wjpsBc{w4heXj`lIK$4y%}YMk#@8lw_L(;NanlN+6sb*$ z85dJ`8tv4?8JC@GNCZEa=}DfygmGK5#;Dx&KUCVDt8+_BawCx({CX)OD%U=r#9XbsJNDkeqB=81 z%5C@&6+=)OGguskR_?wkUpQP{j^m$ZYvz`GM)z7;Ptpfa*RDA=Ugs9)*2m1Fn04mq zzOgh3Wjcec=EGY33JcbIACONijLXNU=4oSb%EoA}vW(yk!dUW*EZGH_-?_g&*0n!w zC2EFpHZ^x2dnY8+$Y9(>WyhY_CA4TTF`gY|224*b#;Nnd4Sx6k+97(?1)S~i^V>Rx zRH@1^g@FGa#FwSoH)eJ=l4#+Ep-6<*e!A#RpZ0+tldR(2mWn4?_89F9Lsa|*XoJ)0 z0*^eaA)N&1zLeCA#UX7Dj)PY;gWZ1&^(%js_Fj2abg?*Gu^eQi1>~3HLQVRW;pJd! z!ZRV~n6GjN>7Tn($-9(8xYaor{rbH8EKeg5wv)*cpx7DEEI#&cmh(RtDty?Ay>(uX zzoI#~u&>~k75BAOKMz!tD^dEF+ah~R{~nBNDjO21%@canh+n=%Ep1<~-^Kgbqf9hm zQ=$HZG52x7^{P7#lZ}0w&Dn}z#{ofM|0wmzVO`P4*Xuk3Soas(+&IaebSWA8x4c4! z^KSQJf#TNKMksmV*5qz;+Y0tfMR&BKCstO|>zM~cx1h_&g;rYidmT3hciP*2ymiUb zO(J6*N96f31rp85V`#$0${q*d|W0w2rkn1C~wcOcWdGV0ue6r`jp0Q*z82zWAL*pCDA9lXljm^4i>!X1+rttI^63AP|WbeY}_yt0|YhkYzVO$t> zRYSGkeO?ya3&BHA7pL9>%r<{|geA6QCvHT0c|G4jTMbkCOZP@cj$Ov_kb$8-En2zv zT?^o*(Xe&&PT-N>>phU)Vp7e`m8gCt1OHVEJ)J@0@{+@5mzfH;BaI9Pl`=DT_r>3K zLV|+o{`M{dE#epiT$W_D<~4P&s6_rQ>Sv7jxjWbEW0OxMq0<8tsS z2R!)Q#zgfjM;X&5O?wFMgmeBLn2DwsSRkA?Xy1AX;e{p>gns3Y6*S`Q*K{O9&UO_N zo>$Xesi()y)O1K!r{3WM^TlbZeCz*PLby9nbE#}@?ktQF=e`VxobV9xw^kzB)4S_Z z2VZjRp7Hn9at4SP$6ehNA8bvtx%G9@EJ|F;9$`MxM6YE_ZVI=?yn)ah3f+GkEe(?g z2o)+w_4fYelPMmb$deZb*^Z+E7{AMCMM9og(w4aNzv>X!glpeq<27s5=TV)(!kaEh z3!iwzUkFLWd|PqJBR2&c*E{darAYdvPV9RM9p8HWHx9A0@>i+CXigBYpL=fMNzYj1 zal12oydpMvTDfvQ0DsJ!hRN%Dhjc37fa+C677(-Tj5^Cp7tN;j*jSOsFc;p^9eL%_ zTkPR`MX&1Ig~lR3;vevvp#Sdg{gL}2+tQc3aYR#t+ zQJEl8`zzK8eP#T^GwCcJKtyDUV(N*R3z9ZIsKqTr0{u+pqK8I>1g4BO-@v8h3fC2 z3{-P0C5osC0>YGijrFH5&1&}JfCMh|yuh&?kmfNUJ0`@Yl|>d50W2Dux;`Xk_I{R4 z&d4a>|3KH?m{zItdBoxiz-D%Ds*adBv^R*G(5S{-CfE}`b~*?7@OUjJnMl?h;5;!Z zC1PPYB%q;1=rB46`hB{{gk?FOScvyqVNo;ozOa#jl5V9~C~n*>Ujcox=imD>uqPek z@2=K_^;*N^XjJ{_cW>6nJX}^ z1$M#?W@yog0J%^N_#wHxh9f913IlPQqIKijMi|eeW8Z`thke~xdb=1obs1n4LK@w| zjTWZTOi;J!T=pJixEF@pk75TT(iHuB*4NOXom|L0qTw#~{B%48R*9i}cd5V_>yBuy zOP`QXUJKIYifhmkMW>+$e%tNra1upfPL<<-6RiIyT@;$nR(~?*wYa{DSge)lG~#GN z1{Km)5A>ulYpb;gl$3!hAfgjW6-@gUy7RU_UW&C(apO5d`UpXdW7Ytm(qJ_wq z0|+a89q6zC>g^+I3i;JKpC@Halx+6M8$idrmYOR25`;uDSoI6y_lIw4JKx+JNmRfr z{%nc-cu#sd(wkM*mgEpaA$QC*_VQL7o7^fOwk%0g-BqBmrTro)vig2g0%y>H=^#29o^i|*3;GiAjvYthhSQ{96Cv&y8zBE-8pz~JY1s1B-6;_P@&W>K5aW}#Aa z4^AYL)hKb;aqZM`a45S=7?DGGLe($-`|9m)^Gm{@l}{ zcNaJ;-=lrc(wgoFcq@HXX-kED81NAD;&=l7)S7HVfm1AZdBSM`r3F$WCCAqN90%Auj5*I#>2RG;igoW}t- zn^c5<4*_TwfzR|oLr`7w|snl*f~E`sMF3B zS|{2M+zd>4`Zn+`oH~w$(nS6F=ma^x^#ZQ{64T^F{hWB+YIisgTI1Zy;1=YOv@yE$ zYgdX`th27oT(QA_vyX=)Z&FnjP5hpEBgm5{t^fNQ-zfTbnO%t2?iNI{j8x(qa?{cE z`M=9p`@bdvGT0(c@eAdhB;C=(hyd^Pxd*$|Z`rc8&OSxau$2b+0bgkRaFOv>CT;J= z)>PNcVf3e_!)|lti=*#F^{OYzqtj5hQHGwwW?#sl;cVG$pZK;W zP)AcU63IAn%W1qK!M@Z9K#K}}mo5iuTq~7t1bNmV?5Gr;8aJG=Z16_0 zeV%s0Mdp{9)mM{KS%*JJYe{`X2%;k=n85A)lZtK$lGVFi3tuktoUx-PKM}4(J zj|eBq5jCPp=FRdQoJD#XMeDAOTEsdoe}T&3-mC%=2g^!*N=wOKziPWD=t|76o4->Y zsB-i_-Xn3DCXJN~-T8@cD%#Pb?=Uhpsdrcmx3?1wPj{}!#D*keXUsm~Nm(5q{zm9xb>3Q~pZ!!n--9S51gWKVLdbVQ zc4RHo@&)dVgHL4z*GkDvZ0VNqK4qrXen}QlaI|X(j}&P$pE}a}a;iX!AEU7b;F59k zDn&e+%nF*7I@&Nw8YwA_9hf^cw{x9 zcbR8gYlc|;XK^Flyuma~1T){{1BThnPdnwMbYw_pW}WSqLa-qggd-Pf>bw=iU$dBy#%%l+BXVy{f;6)(*jF-{ZS*lxns76Zdq8VpEi@XXs_Wz zCN|-}uX+Kc-30qZTu!;9%UHCBL22}x!$q;cl$-fSJGjc;GA!=$a&I91f26_rSJ43NLc+C+0lLcDj zXT1V5mNL2~pWXY-Ok$(@F}dM(RAcdfYv{GU|B4WTMQ!}ZQ@`eQ_NzQ}6m>HENBC<(U#JH&ByZ^(yT_<=^+Dk|-ph5X(Sv{cG!xU8$Q(z|Eli z{y@(r_^h`ms2N=6q7{AawOr20Z;ZKQBBW>`q<2CM|0ZW3`4l=bNpoC(^cY(8-pS5r z{5qp>Vmg4F<+gW1EWweCP}C#@9}+_C9Jbc+GZTLn6=&MuoRPlsAb+Sc#&gk*{o}?m zn-kzeqDdJ*{F9mez>A`Qlin#a=^n>rW)mwLUbcg0xW-FvGrAJitIA2mEwQ=1FtgQM zosS2bGiG%BH>KW)n}nr-wd~bW)%?~U*oAXGNXb1d&)302zn8EWmxG4Fca=u&;tce` z_MzWXtMw&J5*_3JJoJCD?onanQm56+Z8+An;T=CK_X;s9%MrTQRu!)t;H?;U^6O%` z3Z0lwUzB+?qs-8WNwsLcf%k6HlGpsfnHyFRRjGw6<@ zr*@cdmeHrkNjK2g4?lQMqHa|zW`B+i?f1E(J3}!sE0J|Vc-p=kSUgxic)t|$xj87n zC?Inxb=GU#LO`kU;KHfyWA{@0P?TPlG>DdgFfxlOLlRFfUmJajX~3j-&%J=&{e~Q( zR}~uykZ_Rk9CeEc82TvYe-raU0t}6^cG8|>E$(%RfysJDX{X2;o$W0v;h4v*Hs6`P z|1+$o1Ymo2L`H93vipq8Zg(;$GVFq$2OWGl1s$!OpTthnOrdu!D zH$TpsyVQElw^ULTgTQY%*H@-$)24%|B=NVuE^$cuRyF?|(VcR6?`;BQ<0|X#xzhOd)4f%RY29TnJcT62guGgseCNLjFvyGWao4L;b#GOUFYlX-4wt*U zyYY8GB4qpJXiy!elPs;%>R<`e+h%OLp^*Cb~TQ71Psw zwt$G!hV_bX*GEldHcuc2Cggh6=JR>0%X4>K>l^S{SX1Fnz?9_awDu(jLM!i`cg zcSzOmp3PrsDrnT12v~NzLeLQ$sPQTijz$O%$4hD47&6F5*&lHXV6%R(u{y@js-~9I znCjk95Mi{V|DKh0Um&$tyg*e;HX#X6;>4l*s3(SGhARU}ND*ALG<3D&zUNwN4E()# z17}?vnq*w2F?&&Au$%Xq*`;{%S-F6w#eSA%`z9KX;+K4(Yei@r%oL z(qz~vWP4Y}@x8C=y8;xMwwA~x+wNVV^5)?bS$BAMq~;b_V`P0}MBt`#KwK>t%cF9$ zGd7WhJ#bFAlhUq~>1*6fnL&-NdEPfVoBhzPoVNkU?Ea7*Dfw)Y_{cK~!{fcZu?lgI zRsuM#CG+Rm`3$9^nKC?ymrjF~aHK^<>cv{0-jXF}$uC_FJ;@x%47f=W_WDY&5`FYn zgMPf%GDD(wvvfQOV1|M)U#UR~$LT2^iKfW9B+`;bGN1dZg!gPWxM{&n!&-%-g?MG< zL^jhSlsa!bpGw3FDJ<}{v2nYSTA6wE5Dzy+!T_-lAYn_Msx|0{<>iHf8UDB5=RdH1 zvzMS7Q#U1jr<3E9PmT6X%|kng^a{H(7>BIA6=FdtD39~J<>XIdZ<$fcIeIxJSxQgQ zex&Lr!qY4VwhZ_tB#M2NSbnu{4-{YjK2xEwJHx8Ei_!E1Pea&+c&3Z^CckycGnga~ zTxva^UZk--^GlEs!Wz2H$sMu~Q`xsHREgoaWy|4YsdeSB01x>GU-7QJw{VpQWwQ*a z-bglL1==?is5SOpdjHf~S-OIKI>S=!$lb2zlRj@Mk=iaLfDrzd z2|L#94P7O| z1-M~GkondS-=~h8F24q;f5|)AO8E~-GUeDk-I4Y=+6XzjFGKV;kaA|s9N~3raKlSi zKMQ5N$tZBUb~-J5gr zB-+ZjlJHpNvdN}fL22U6-ox5;naht5TsyphRPtwKl=STNAhFrygHygI{oO|EHa8rP zh*VzsJ{@@ApZCq7b}#U6JH3P+8-Nl0I)M#= zTeE>2WgNmbuZ3NTWaySw2J`YtDOu-%@=r1dqRmHR=0$#+KYu<3KFWe+%2PK&(o5I@ z#}i%B+ycHMWISfw|B>j%iw1w~|JGU%{qhZw$`l5UN8asNlXh_9UKG<*y^td7H4`uD zQ6XwMitJ|U#CWU zm6Z)V8>Tg#$Z6;bCqoabT2gI`W6_6IS&2>~-&cLj9tW+Cq87-NhM5ZjO4w)8Zj;vy z9kPgou;W!mHb?zXnxuC%o~@)8DX?|zdur+`$a<)oYM2+}wJQGFw4E()-I97)YJ@Flv zA~xqapW>{}?m5y`0tsdI13x(_)49Db{pkSMv;E4haCXa;OT@8!O{VWF1T@O@eSz7X zz^xWRI)KvQpCFj0;`+1f+F(B3r@j-Q8mRzR<(r8Q#q=lZ8?4W#BnMxd;cNdC+b``p z6z_?&rkYV0{K4GEySmjRUR%0GPlqN8%fyHd8YR9n@Pr-ypd%s4BD#j#XEW$)qE?mXMHLGw+nKM4xIdJ@h0DfuXSs=2nuAzvt&a*t8v8tJ_=L z4BmP@AfIF@f4>-8y+0w%D;L;l2AcSpH4!buO6`GB8sc0~U$b}`T2m8!aUc}MBL!Mgnl|8f0 zfZZkfV~76c$M(vJ#wFt|$7mn;v3fe@$*e^Y%@JRsrkq&UjyE!%K8)%v+>Sx`Y!J(}?lRm}H$$B`4(jtSb!YU|SQ;C9 z?&@k7mB&psEjEmdjH_G)c1 z0$!0!(uTG4?6&G!jsBcfxy&H752?NZb)BH73yL<$cWSV$@F;1~y%C6`7p90d7ihDa zsE4rKm33~D<$ReUq)I=jZ~9I@ZBHcbBv-%7B{8QZk?;UvX5v)90tN0XXn}n;gzXr| zY~4eDIPcE7f%7#|rTHKQDGauc9!kgeS=2m`kWfL|y*nLtP2hYos2z}=jJuSvNi#v?KmZGXL7|HBbXi&D$=Dm3nb)pGl35`*XAK+YEK zsY0b)%2aib`h-*PUS3xHsBD%fW-s?-J5K$Vu31@cZ^&+Dz(Po?UFlAl!+^&>hGA3P9Uq4g-Ea_z(W9;K7Em7joB#f$NxTxr~(74T%7u4uGGZA0KXi3>(}!mdzFW z(#L;!8@j$&nfnpMzKM)$6s2tex4bXZT$g!xz?3RgFFEI*^)wTJJ)c)f|La$X(r%4> z>4l`YwTjwVRx=)tNgK6mEdFL4kTuJo(~Qr~X7bp8YLqS85t8 z3Uh?`O{`~>$pXd&MQ~NN)*!qViB^iYybWAhYRe@jglzA)2PKSv@{XLru#coGw4dF3 z=`3XCG-dh#uhdn^dlGem-8|P?0wGK=lp!H^O8TgGDGGZ zV?56oPrdI-Zf7s?ol9#4HsS?OruGfe3^$6408fQ}4>94O*?cDM<%-VzVu>z{=QEq0 z+Mf9(r*XQIdVckiJYYi;aMfB0iys;un<+tMA5ri#9I#SrncZw$PH_mV`%nsn$_!lu z$n(O~W9ts*D5NKDy?@qs`Md@oDeL7E^v)r1^HL}nnVlA^AlNx9Dd5HIQ5fnw{2d#y zUeIGTjte4>n})U~rcXrrEidLx9TBnGjL(WP;})xbh>#laVPri^ofM6mp8We)|JQKX zyYn{Y#eMN#gvQPT=r)7!JE>@ifcSPl7O2NLt1=OT+mk#_PRFf)glqS^cQq)T{C6g6 zK%MOlz6V+yW4x1feby&GhWZ-TlnuA&Eih+nuM0FkLBr#tqd6K+_Lv3u=Jtb+3%L}N z&)&j^2lWiykBX#9S`CtgwkALCY2R(9h8{Ecw4Hci8YLa;`d;@K>g0lHy%aQMDJ4Qp zPHhu_G=sb4ux)hhk6y@@$@$6X&h{LalYh3G=MNAB=UTMvTt=$^me;Dl-L$XK8R~O0 z8J-l`*!d=V#{G%Pnxfz>+yRyXR4nW(b8iUTQ=1qm`k~BR9IneqTVb)6lXKrB>#R_% zsJQcRYlw}5@KJl{^90g1HeJnQutdeOlSesna&E~{Oj3G(sUoue=+2AS_y?R|J$Vzy zd^X4hv*0!WZ~Fmc-7F{ue$y(=tXSeh&(Np-<49DzMM=yJMonjt4uoR)?Nu>PY1?AU z#+{t&9U|XitV**|j22tdBX)W2J&}GH9{WBCunL*YG@Uu7S}5tF?2~EU+30}m z4m0Ix%)a~0betNU%*D+)q!1K80#{i9#W(WL|0;R__K}lNHFTdPsdtaHq^clazjzjW zi)$go=)^CanFTfJ=wx*vQQ2)+Ln}bctdX#J{>8z29@l%K+4tR_Yys#5A6l0yU;OsT zm#)IwbB^cn+2nw<5ibzgiCQ-FWPR9y?&QxFBBmDK*6#N$Q7-Sr3E6*XJUitq3x!QN z&Y2-kwuK@(im|t(xyZ+pj=HUvJvf|d$aZlwF;o*%3x~7yjj>p-M@yCD8&AD9TSv_| z>qzdod}QbsE-*DNHJ|og-?H?xUzz-}L&rT*7^zZSFL1nT(e2Cw9WLsyf1HynB=LBH zvq$XYH1$k(1Y)58#bgOK`mXTw?zJ*5`#f)D)HISf#~t@wD(WJ5s+q=XW^l@eGmeIS zmd!XTH|;ah^sW)K>i_7}PP!+%CTzLhk@i{vUUFrPdUW1kRGdK7LD-RW4X^it?nNGs zZbV`DerQ}ry>+GhRqViz9rhrs_P9y>gebHw-K2}_z&Z35+*Xw}`0bKq^aK%1N*Xss zI6B?|uz$ZRGChD(H1dNup==jGujr&}e5coc+{){ZLYdT}sE#^lENJS%m`&fEu4DM@hcN;mz`VuO)}8E!X}YOU`4Ecim#0|j_T z5o$91{Mr|0{vN=_%KRNeguP8|+z{;9oVeewLiS%n@?7S>dJ$6Nv02L;c#_=ROFsUA zG7%Z5Xc|v<+8PDYq5Uq_gK$6hhr;8G5*a!Kb<$wIBZUXlcps^gA~i#&;nq8~*J5fq zj9gmI0EiZa<-(cJ0NK5xt@_5}deDh`P&p_>!yVro!7nizk?_P(r={kERmAnOa`4tB zfuc1b19@DeO^O~}s$-QrYQ-nfo}BE+4mtEa&|BGILXGk9qqO^tGM9dCRIf3gZ-3k= z9M&Z}-NT=ORK)iD06;|6he*@qV)5-JW+qBcc1TcVz72N3fQ+z?El)>yg*MZsnLy zgl|j9?^Ie&NuC|~BL<_^Ug(S;5j_P5{amYLcorVHmz^! zt8U5F3W75sn!y!d`ACcWvIFC9>pde&%^@oC?KC}^&fuaCw;vpmJm=BFX&*^48EPO zn8=BeQluy?z1CysbG%kV>6$%yJ}kY3r^6jk@07ry-uyf2Key`fK3eM~2;TQ|Y)4&M z4e8N`aks3CS4L*LxJn{{G?N;W@8PVJ3>>o!^!d9S*Sc=xOIKPW08_Ea9e22r5%Bx- z&Q>}yp$FDF`@Z|-sUgESF!Zn)-+GqLV_B1Yc9gM|+bK5S@Y*MtSKxt8jq_%vk>4#C zqpR9m=*Y*a;J1lodq$ZN2@A0E3Xr}7RQ zrMsfu_Z%y2pZose>KTjYw%e`I%EV}aOS^etI;#Wq_w7(vG3?HUSMuz+3-*@d{<~UV z8SZ*dXUa)^Ojx^6qnbx_l~Kb6sc?ZxU*r|A(*CoagcZ_zK(gTc%t2mRdC>T$;;Evu z-(L3*z4e!?BMg!S{?F{{hlcG@V9}H9TF6ox06#!7wO!_OaM+j{E!yzQNTYbL8R}ct zWnD*OW`T^sLvaN#X<9Rgl2&c2z2-zkZ~xRU+?ujwsz2%Ouqo1m<+Clm!T;?NMR7Y( zXa;9AN9eF=n(WtO+szq~=LA;pH_shR8S}<*je?lh7|T%!uEg1k>(n{I6#ruXIZMq( z-V{>ZFlYFdzLA~2Q{4pSYptchJJ|0O1Lg(9?-*#3bMd=q*_-e{M@Q%QCD!-omp^q< zoKhWCnQvK(9;*H^!bZb`rGmt7A2+I!ZKH;v&3%f;x)IM$dYtW}8UrYqlAgX#KUs}{ zISav7n@$~5z@wAEI6!(9sox=eDq>k1&{q%#Y24>%X zkeDb{)|&tLNWSgQeA2%WHemUy`gX>vJkq~NN_rCkcB>92RB)ML7FRhVPS~OKlKAak z1C!r^^t6-lyW%xP`0m%*o7#G{s&9dqFKP3(kmpD3=)N;cm$TJJxW@f_g~jim{Qb$n z!rePOjjJabf)1@!{mV4VN+Pm?_EWT9TadHO0jW=+v36?4q&ch=Q!`ulO=YRwl1`fY zDo3Pz`W|Dg;n12_peNCKwpdVg{UioNJJ+hU zoMK;J<-Ib#m-t(wzM)0ET4toYKMb3;r!z)>32yzMZ7Y{*h&A7Cd2b?}f9ALSZ_ajG~uA7&#T6#iyV3Md~~=mDSHzCahG4c$D47W9 zd#+|VHd6|{s4N12Mye%Bp{?YeAvS?F%DaivCz`&5iRr*(NQ8yh9+}SgM@A9n&?<@F z2xMADKHyxP?b2AB6vSd1K)BKD6~&*(ML!m!A~LF<*95?ioI0Y`DMszZ*3n~nps!nK zln-}qyd~ZpiZahlDuTf@3%M!s5urY_ejxBuT(APqFRkk<%s%^%tBuc$jxunu?u9gHWRrAh7#8X*t*WtqR5WwZQClVKGhe-=vp@U+RWkKnVQl`qii5&d z&OC=q-*;7!lC*MWXZwwBSOw1Pu<-_^VuX6bX^&_tkx+fBeI!V`pUCo58V)DlVK6#P zC%u{FZkgwXr7d0aQL{#mB+n_)8R~J>nH}Xww|h1=h!<2o#526v_gOi;__`=qS;dx= z4rqUl!-eUa^6V3L8=Y_-p3ct?8!?O~xfgjE@GRF(pQc!>rqDP`mICp?qn*?et1dM9?`aMm&nT9K~NUoAd5;wAV3inM^Y;rlm_ar*a zuKa>3MdZm*pD+6qivooiqoA#J)g!+^@qEl9p2qaKR{C;JDLmcz0ko0+rkSwgf}F=} zYaE-nxVV+C=U=qLrMhz9U^GnYCGhr5 z)!ej$U|99!yAAVL&rbyfc~l`@X;}dmhxev`eVI333W&1`!5+OST=k$(Sv8W*y9;FG zl$j(S$_KQw6&=aTgU}I<+BX$4`qNJKK&69kb2K zuO=xIM?11N64^M1i8uw^S9V{UV`;tTe058|m|rM2S%t}l$3OHD7_u;^0Ztx~dgLNA zeS%DG{+{*l`2BdUSDxtI(jE6i-=xQH(@!=A+7~dEsT4MAW$Co<1J7SGpGj^lG-d`^ z#1`6$*SY91awf#*Ay!Z4?HlKnbt(>Nsu$s1{uezDHo?@VX9tMa%t*cLM^JJ5^IdvA zv(7$jv0} zZc;nAWoJj6EsffbGK8mGKWL0UM637Qu{L_enIO%lU&b@8V4)J*XH8m{uV|^5xIPKe zrbWMNEe5;NIQo;WSC8IK?47dttbRbkm(#KAd@RR_vO5FtW;^K|>c8hT^D60DD4d5W zXC7l`Iq$3=7CB7LW`Yk$^>t5YgNq_WOU{RgM)5VL7L+ZC_c+HHfk@Q)%9rPhwdeT8 zEFS{$I&No_xxn|_Q((x)KnH8RYR&sPvEl%}Y?MI58{y`yR9lZLbH!$-+4RzjJ~E4+ zT0ORk{935SZW zsWp!7D%R#$!&@~9G||a!*jqQ>t(J`P-uK^I>lkvHa56;89cAEsl{~F!CV~>0diByVfj5=D{uJgK z>pm{po9S9&=FLqlp9ErGPr=5XaX38kLwCuPN61zB$;LquR9O4tJ|?v4R|1K2vnoIUNp^g33|2!SsX9m$>X0H z8mTT}5}H04j}x%Swl^KA!{J?JO;zcJ_=jdB_1blLybj`o$i|RL!>?;A8+dCz{P0uT z_IEJg;1Do1pFSgI%dmqdb%3LMyect6Zz%l~JK|z8Ee182(`apmDr756 ziYq_4Pno$fUDCLVpEd&hs;Ft*#{;phR)qHA!jjds*V&=;qM9`>6zBa7HG6zM;62BU zzheQclepqBJdly%xM&WiWS+Sf;tqPaY6^5)(BP{x5tu(vkgr1%q zHSgi4%2fa`R93G8=Kl2t@&q7Oc$Mj=(KwQvDxXTo!GNm#Y9@n_LtIY+aW+H+ za9;H85K6MQC4(CkWG=*bQDLINr`=wu6fkJ{duo%>du2b{1acbemIq8Zk~JQw1ToiE zmd811mKcJ`sMh2B6DkKb$;(B|JJY27Go9kN%k)%Z1Td!~BSm`V7(`a@sTF?82Z#p2 zfO@>dhmePTaK!xVW6ia0G&PY<8pq|tOyAxwem;JCt9{Og?TGL+8HwW!$L`Fv^&UpZKyVf zMn!e#fp%aAkT2{CPxeY)R)Am2t7W&k1Ef$CQ##MrgrETIeFUi{evQi#Eo>@FdYrL3 zR*U~oIFczP8lRg zHdtd|DG$L&E3d#j4riq8cu!*Zd4||qX%ei{Uc(n4ZD=K&kX$2-HM5?S=~kSXLV8MM zYiriHfqqK;n;f3u^8_J<7)^QuHp!BXPH$^;8T*gujUPJdbD8fe$tG#v>1b=Sps;7) z)nT^}N-w1^z+SQd&F$u_V`73A0msIwf@rhHvyd3f0KUyYt9FqHY}zGn{%0QMU*7dg zU81@RbQMefT5cNGrGQADZ=G9nrOcLFk+R!1F*5V$viDiz;Pz!K3J|-}e1yZf^wGw1 zD8&_IoqTyXRY-q}m&V@k^44bg#4)W^ymsnWg&m_u^@ zRVfA2O`j2M>n|g^nvl}0ETmmA=NpAe9en8SP0CPE?Bt~F7mJ(<&MkGFGLx(Yh_QLe z)P}Qik8xg)w~coe8^?Hsc>)$8SN@h(q$gx~;nu6)5c1l52J9Sc@_E@8krr(mm&%qt zmNc9x@VbwEJ>0N{fBXxD`{#xHNemOf2?m*0IEO5iMRW1gHf`8dq@Nbd-htCE! zM*eR4ny7-!Ur^k^Jh@8kn=L%%roUrAguM;$sQTrm$VW?`iYUC+@ng%%?C4B-)7dM*Qly(@#bQyT9Gy@9M2)RT zrp7m0{*6gW(%@A%Ny4r27p#v$6wqc1UppOVAB?_2D9Zv0dPw2DBPv-?88GFBM{yO^ z3dR|%`qBTUK>t|=fIPK}7}ht<(cDN7l~lYUQ10=@Bx(ntXw1fV`DfIJGj@3T-2EI^ zQBux-UhsdEYAMs3z=;K9eD=Jo<5SoJ0%ROtMUQ$Yq+7VwE%C*6@ zn(3R~ee87XfzVA<5~AjUf1N))3R&#LA+vjJ}p%T4t5fS+5E+?t6}V?s8k z4M&QQ0b<8-apuci`QGlq3uwjDa$7j(V7g3tCYxaN$>iPDp#s!Z1~Gll{S~_A%5;DR zE4Pmbs2Ygw(L)LsjJ;{R&>ninFjXtgY!?m9JX&BPMsZcGz4i`=`89h(k{LJiZpb*Bavhduic((XkJszHFlyhpBjEGyERE-vvZvi1Yb;R|ho(z#SSM_0&_)R2PXo5M zIMB)Kv0o0?znF`LX)w6#tHw*Xyoq)Xlut8f$uJ+1+qttkWBK%tLqzKI=0gx@1hhn= zT&m|;V?n2=XnR9aeQkNlY7$~D4VM}3_CGcCBRN9$H%%>=A#?;c>w8E3l7w)UWSip3 z;>`DE0NCp-=fj7QKm6`nW3yuc#;sR1Zn(h(zt<6rJPsxe4dxXK)`o}kao_$_c_qar zB5bh0VUcR$^}ZpHzjXp8${5Y=dadQH6P86mwC$AwnoTE>f}?|%>KBOU554+NCNDRK zD37yqFvE*(xg@3denA$X>5jMmLBZbXHYHr;8NTV?+WJ5lDNT4Cos^WRbXz-`q{nJJ zo;B+w5xnwErXn$yLRKljhgS500->m=_%0!@!Hr{Ld9?(P<(_{NBayOC479LN>JjR-*suS16S}NTCCf?b=5F!zuclD0PxZ zm9zM(YD52jd{;~MYX?#abD%!kPfvvYjTHUU17B`Y`HtKL8UbE7nTLb-R2mXDb|5_67e3UY&8{IZ@wXdV=-2UtD{_9oP9rDNl#7oY|?{k%_<$P6x*`?50y;)xiS8%dHAb{Z*tFhM_4o*JoF>%3Ozhy zulw9R{;sg6{ws7BTY;%)ys*o&4(F>@HADc0b)13MzUYM@a≶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

" + "style": "IPY_MODEL_fd47487fc8734594823f8afa00c4239d", + "value": "Downloading: 100%" } }, - "79184c8c2a6f4b7493bb7f6983f18a09": { + "0d80273cabbc42ba9a408fb1144151c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0e382d66f09f4958a40baa7ab83c4ccb": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1026,13 +1053,13 @@ "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, - "align_items": "center", + "align_items": null, "align_self": null, "border": null, "bottom": null, - "display": "flex", + "display": null, "flex": null, - "flex_flow": "column", + "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, @@ -1062,13 +1089,43 @@ "right": null, "top": null, "visibility": null, - "width": "50%" + "width": null } }, - "ea95ffd922c0455d957120f034e541f8": { + "13525aa369a9410a83343952ab511f3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1600b9cd09c446e581b7912e35c9f56e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "16c0017f65b649f5ac5bebf1c955a1fd": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1117,10 +1174,10 @@ "width": null } }, - "13525aa369a9410a83343952ab511f3c": { + "17856a72e4e948039a66c51e8244cb50": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", @@ -1132,10 +1189,48 @@ "description_width": "" } }, - "b2be65e192384c948fb8987d4cfca505": { + "183c55d5d3ce4058ae338c81344547c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_70efa83bf3ea45b4bd8cc41f57613328", + "IPY_MODEL_338747810ac74b4e83e356a01459c8a5", + "IPY_MODEL_ac0bcfa1ef6e4e78a7769c4cb2e8762f" + ], + "layout": "IPY_MODEL_6efb7939bb954dc8ba116680139eb257" + } + }, + "1946386483ed4947a2184cdb4ea6e434": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "23d4e25ec6c541818d5927b69576d278": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1184,25 +1279,10 @@ "width": null } }, - "333b42ca7aa44788b1c22724eb11bcc3": { - "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": "" - } - }, - "0e382d66f09f4958a40baa7ab83c4ccb": { + "27f6f437c5264368bc2c679942ad1e53": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1251,26 +1331,32 @@ "width": null } }, - "6a45ce374e2e47ba9457d02e02522748": { + "28004251b0e44a6c9dfa7ce1b30dcb18": { "model_module": "@jupyter-widgets/controls", - "model_name": "ButtonStyleModel", "model_module_version": "1.5.0", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "ButtonStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "button_color": null, - "font_weight": "" + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e98cf7a63c814ffd94f69928f0700ebf", + "IPY_MODEL_6a4dee55cbae4959bd7fe3c4d92242b1", + "IPY_MODEL_8dba487876124827919079519406ecb8" + ], + "layout": "IPY_MODEL_5c211704f90946afbae2f66a7586ce70" } }, - "765485a1d3f941d28b79782dcffbf401": { + "2b2d7912186a49dd9891ae12c77482c7": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1319,117 +1405,14 @@ "width": null } }, - "3499ef4dd9f243d9bef00b396e78ed69": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", + "2cbf0faadd4842c8b22e10541ff9de4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "183c55d5d3ce4058ae338c81344547c5": { - "model_module": "@jupyter-widgets/controls", - "model_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_70efa83bf3ea45b4bd8cc41f57613328", - "IPY_MODEL_338747810ac74b4e83e356a01459c8a5", - "IPY_MODEL_ac0bcfa1ef6e4e78a7769c4cb2e8762f" - ], - "layout": "IPY_MODEL_6efb7939bb954dc8ba116680139eb257" - } - }, - "70efa83bf3ea45b4bd8cc41f57613328": { - "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_6242493d251a47609c0c44f1dbe82958", - "placeholder": "​", - "style": "IPY_MODEL_f439c1de68ac4c799d81fdb29d053d10", - "value": "Downloading: 100%" - } - }, - "338747810ac74b4e83e356a01459c8a5": { - "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_e4c1e9affaba4045a3ec903091b6f454", - "max": 500, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_1946386483ed4947a2184cdb4ea6e434", - "value": 500 - } - }, - "ac0bcfa1ef6e4e78a7769c4cb2e8762f": { - "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_549a30c85c47466eadedbd24da42e304", - "placeholder": "​", - "style": "IPY_MODEL_bedc7d916b9745f097094c5c51a81f06", - "value": " 500/500 [00:00<00:00, 5.05kB/s]" - } - }, - "6efb7939bb954dc8ba116680139eb257": { - "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", + "_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", @@ -1474,10 +1457,10 @@ "width": null } }, - "6242493d251a47609c0c44f1dbe82958": { + "2d7a0b901d7044d5b1f273a3e9bea560": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1526,10 +1509,50 @@ "width": null } }, - "f439c1de68ac4c799d81fdb29d053d10": { + "304e9682570b4abeb1719001c04449d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "32accb0adfa24c62a75c15c8ec88df8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_23d4e25ec6c541818d5927b69576d278", + "max": 128619, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_54d9456703324160aced03ee5fef2943", + "value": 128619 + } + }, + "333b42ca7aa44788b1c22724eb11bcc3": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", @@ -1541,10 +1564,34 @@ "description_width": "" } }, - "e4c1e9affaba4045a3ec903091b6f454": { + "338747810ac74b4e83e356a01459c8a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4c1e9affaba4045a3ec903091b6f454", + "max": 500, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1946386483ed4947a2184cdb4ea6e434", + "value": 500 + } + }, + "341615c971b04033b7293d82fc40f35c": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1593,26 +1640,25 @@ "width": null } }, - "1946386483ed4947a2184cdb4ea6e434": { + "3499ef4dd9f243d9bef00b396e78ed69": { "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", + "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", - "bar_color": null, "description_width": "" } }, - "549a30c85c47466eadedbd24da42e304": { + "358c3a67f8b54c4c899e095611fa116b": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1661,113 +1707,83 @@ "width": null } }, - "bedc7d916b9745f097094c5c51a81f06": { - "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": "" - } - }, - "d12f07e25bf5422facc38c3463700994": { + "38b3054ad59549e4b4f2de4697139a87": { "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_eae11f84c2644ada8295b445c924baec", - "IPY_MODEL_bcf766d2a2c641f0aa2af596c7da1b18", - "IPY_MODEL_74bf69aa6eaa4a8594b2ea9a0fb20957" - ], - "layout": "IPY_MODEL_2d7a0b901d7044d5b1f273a3e9bea560" + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0adb304bf90f4079a4031caea1cfb924", + "placeholder": "​", + "style": "IPY_MODEL_40021e0b59fe4e1e9bac351dbec57c6c", + "value": "Downloading: 100%" } }, - "eae11f84c2644ada8295b445c924baec": { + "3bd33a372aad4c438f64d73c97f14c6a": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", + "_model_name": "DescriptionStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2cbf0faadd4842c8b22e10541ff9de4e", - "placeholder": "​", - "style": "IPY_MODEL_ab32c7daa1d9404fb921f39fbc4fc05c", - "value": "Downloading: 100%" + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" } }, - "bcf766d2a2c641f0aa2af596c7da1b18": { + "40021e0b59fe4e1e9bac351dbec57c6c": { "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", + "_model_name": "DescriptionStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ee537ee5470f4d7b816a8c8f96948b4d", - "max": 17719103, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_652e97509a914f3b914665c4889c6d11", - "value": 17719103 + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" } }, - "74bf69aa6eaa4a8594b2ea9a0fb20957": { + "404f7ce06a01470fbb0b747981d00e84": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ebc9801e164a44b3b6f8dc7f590e1c79", - "placeholder": "​", - "style": "IPY_MODEL_0821b47ae70444dfa38b84719c4836a6", - "value": " 17.7M/17.7M [00:00<00:00, 54.3MB/s]" + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_38b3054ad59549e4b4f2de4697139a87", + "IPY_MODEL_7d90af87c9574f5ca21fca058c39bf02", + "IPY_MODEL_fee75343289f42fb8d6dfb4bf26fe368" + ], + "layout": "IPY_MODEL_f21c0c6379d74898ac6aadcb6fc14a8a" } }, - "2d7a0b901d7044d5b1f273a3e9bea560": { + "407e250e244b4985b1ce8c9d32a8af7d": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1816,10 +1832,32 @@ "width": null } }, - "2cbf0faadd4842c8b22e10541ff9de4e": { + "41eb32a6fef141ff9cc3ce6e4d771822": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0d10fb0edc9144b1a1fc1f2c9e322410", + "IPY_MODEL_32accb0adfa24c62a75c15c8ec88df8c", + "IPY_MODEL_bf299285318b4a04a88569cc581ecd75" + ], + "layout": "IPY_MODEL_ac2950d08fc145ba9eb9cf5824b1ee18" + } + }, + "549a30c85c47466eadedbd24da42e304": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1868,25 +1906,26 @@ "width": null } }, - "ab32c7daa1d9404fb921f39fbc4fc05c": { + "54d9456703324160aced03ee5fef2943": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", + "_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": "" } }, - "ee537ee5470f4d7b816a8c8f96948b4d": { + "554e567a83b348f88092c6ba01830930": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -1935,26 +1974,10 @@ "width": null } }, - "652e97509a914f3b914665c4889c6d11": { - "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": "" - } - }, - "ebc9801e164a44b3b6f8dc7f590e1c79": { + "5c211704f90946afbae2f66a7586ce70": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2003,10 +2026,10 @@ "width": null } }, - "0821b47ae70444dfa38b84719c4836a6": { + "5e2c207db5424f91829bf5c52040a9f2": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", @@ -2018,32 +2041,10 @@ "description_width": "" } }, - "c3358d32ac814ea6bc5714402c5bc62d": { + "603e99f45afb4910a99f7684ffd21b6a": { "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_ecd8e5e364d34ea8bfbba4fbd467384d", - "IPY_MODEL_0125df9fa8e14b3db0e2bce299529812", - "IPY_MODEL_e3169ca885e04536a709d5751173ce9a" - ], - "layout": "IPY_MODEL_70abdfd99be84f7b9b8d24fee9eec022" - } - }, - "ecd8e5e364d34ea8bfbba4fbd467384d": { - "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", - "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -2055,61 +2056,16 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_554e567a83b348f88092c6ba01830930", + "layout": "IPY_MODEL_b26354d0278f447d92c7e1ad4c211d64", "placeholder": "​", - "style": "IPY_MODEL_6e334cad2e94462cae6e722bd6f11a9e", + "style": "IPY_MODEL_3bd33a372aad4c438f64d73c97f14c6a", "value": "Downloading: 100%" } }, - "0125df9fa8e14b3db0e2bce299529812": { - "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_407e250e244b4985b1ce8c9d32a8af7d", - "max": 318, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_8127c4258e374ad986ce1f8b4c70f704", - "value": 318 - } - }, - "e3169ca885e04536a709d5751173ce9a": { - "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_358c3a67f8b54c4c899e095611fa116b", - "placeholder": "​", - "style": "IPY_MODEL_e1c9df12fa034c93a9b3530ea4a7c5aa", - "value": " 318/318 [00:00<00:00, 11.0kB/s]" - } - }, - "70abdfd99be84f7b9b8d24fee9eec022": { + "6242493d251a47609c0c44f1dbe82958": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2158,10 +2114,26 @@ "width": null } }, - "554e567a83b348f88092c6ba01830930": { + "652e97509a914f3b914665c4889c6d11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "67fcc38a1e5d4eb39381685447e397de": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2210,10 +2182,50 @@ "width": null } }, + "6a45ce374e2e47ba9457d02e02522748": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + }, + "6a4dee55cbae4959bd7fe3c4d92242b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d7071582bfbe4ec4b2c3c9843e5481ae", + "max": 1921, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0d80273cabbc42ba9a408fb1144151c9", + "value": 1921 + } + }, "6e334cad2e94462cae6e722bd6f11a9e": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", @@ -2225,10 +2237,10 @@ "description_width": "" } }, - "407e250e244b4985b1ce8c9d32a8af7d": { + "6ede83f870a24e71b5182fcc458cdc42": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2277,26 +2289,10 @@ "width": null } }, - "8127c4258e374ad986ce1f8b4c70f704": { - "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": "" - } - }, - "358c3a67f8b54c4c899e095611fa116b": { + "6efb7939bb954dc8ba116680139eb257": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2345,47 +2341,62 @@ "width": null } }, - "e1c9df12fa034c93a9b3530ea4a7c5aa": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", + "70abdfd99be84f7b9b8d24fee9eec022": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", + "_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": "StyleView", - "description_width": "" + "_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 } }, - "404f7ce06a01470fbb0b747981d00e84": { + "70efa83bf3ea45b4bd8cc41f57613328": { "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_38b3054ad59549e4b4f2de4697139a87", - "IPY_MODEL_7d90af87c9574f5ca21fca058c39bf02", - "IPY_MODEL_fee75343289f42fb8d6dfb4bf26fe368" - ], - "layout": "IPY_MODEL_f21c0c6379d74898ac6aadcb6fc14a8a" - } - }, - "38b3054ad59549e4b4f2de4697139a87": { - "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", - "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -2397,61 +2408,53 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_0adb304bf90f4079a4031caea1cfb924", + "layout": "IPY_MODEL_6242493d251a47609c0c44f1dbe82958", "placeholder": "​", - "style": "IPY_MODEL_40021e0b59fe4e1e9bac351dbec57c6c", + "style": "IPY_MODEL_f439c1de68ac4c799d81fdb29d053d10", "value": "Downloading: 100%" } }, - "7d90af87c9574f5ca21fca058c39bf02": { + "74bf69aa6eaa4a8594b2ea9a0fb20957": { "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", + "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_ed169fd606274f2ebbb3e8f32ab42431", - "max": 1920, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_304e9682570b4abeb1719001c04449d6", - "value": 1920 + "layout": "IPY_MODEL_ebc9801e164a44b3b6f8dc7f590e1c79", + "placeholder": "​", + "style": "IPY_MODEL_0821b47ae70444dfa38b84719c4836a6", + "value": " 17.7M/17.7M [00:00<00:00, 54.3MB/s]" } }, - "fee75343289f42fb8d6dfb4bf26fe368": { + "764aa53d75324d73ab06936c52fd8fc8": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_16c0017f65b649f5ac5bebf1c955a1fd", - "placeholder": "​", - "style": "IPY_MODEL_5e2c207db5424f91829bf5c52040a9f2", - "value": " 1.92k/1.92k [00:00<00:00, 48.3kB/s]" + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "f21c0c6379d74898ac6aadcb6fc14a8a": { + "765485a1d3f941d28b79782dcffbf401": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2500,10 +2503,25 @@ "width": null } }, - "0adb304bf90f4079a4031caea1cfb924": { + "77a361d1ff214e8799891bbeb28a0789": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "79184c8c2a6f4b7493bb7f6983f18a09": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2513,13 +2531,13 @@ "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, - "align_items": null, + "align_items": "center", "align_self": null, "border": null, "bottom": null, - "display": null, + "display": "flex", "flex": null, - "flex_flow": null, + "flex_flow": "column", "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, @@ -2549,28 +2567,161 @@ "right": null, "top": null, "visibility": null, - "width": null + "width": "50%" } }, - "40021e0b59fe4e1e9bac351dbec57c6c": { + "7d90af87c9574f5ca21fca058c39bf02": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ed169fd606274f2ebbb3e8f32ab42431", + "max": 1920, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_304e9682570b4abeb1719001c04449d6", + "value": 1920 + } + }, + "8011d68253ac4080a637659ef3383dc4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e928540e99564d808cb2d12c92daa498", + "IPY_MODEL_fc9a3c4ae0a947ec91a227360a80f602", + "IPY_MODEL_f91dcd9f30c743d69f9d4b7e8d1beba5" + ], + "layout": "IPY_MODEL_6ede83f870a24e71b5182fcc458cdc42" + } + }, + "8127c4258e374ad986ce1f8b4c70f704": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", + "bar_color": null, "description_width": "" } }, - "ed169fd606274f2ebbb3e8f32ab42431": { + "859b12a6d95b4c6f987791ca848122b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ea95ffd922c0455d957120f034e541f8", + "placeholder": "​", + "style": "IPY_MODEL_13525aa369a9410a83343952ab511f3c", + "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } + }, + "8dba487876124827919079519406ecb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_67fcc38a1e5d4eb39381685447e397de", + "placeholder": "​", + "style": "IPY_MODEL_0b4bf8076fdf4d19843a3246c8bd61ac", + "value": " 1.92k/1.92k [00:00<00:00, 63.2kB/s]" + } + }, + "94756148d2e94a93ae233baba20af683": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "PasswordModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "PasswordModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Token:", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_b2be65e192384c948fb8987d4cfca505", + "placeholder": "​", + "style": "IPY_MODEL_333b42ca7aa44788b1c22724eb11bcc3", + "value": "" + } + }, + "99898e6ee64a46bd832af112e79b58b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_765485a1d3f941d28b79782dcffbf401", + "placeholder": "​", + "style": "IPY_MODEL_3499ef4dd9f243d9bef00b396e78ed69", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks.
" + } + }, + "a02030ba8f324d93a7ed6cc793d70a3b": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2619,26 +2770,46 @@ "width": null } }, - "304e9682570b4abeb1719001c04449d6": { + "a899f4bc6ed842d397723cca582669e6": { "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_341615c971b04033b7293d82fc40f35c", + "placeholder": "​", + "style": "IPY_MODEL_17856a72e4e948039a66c51e8244cb50", + "value": " 5.53M/5.53M [00:00<00:00, 21.7MB/s]" + } + }, + "ab32c7daa1d9404fb921f39fbc4fc05c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", - "bar_color": null, "description_width": "" } }, - "16c0017f65b649f5ac5bebf1c955a1fd": { + "aba21021d3bb4565a58ffa40049810db": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2687,92 +2858,10 @@ "width": null } }, - "5e2c207db5424f91829bf5c52040a9f2": { - "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": "" - } - }, - "8011d68253ac4080a637659ef3383dc4": { - "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_e928540e99564d808cb2d12c92daa498", - "IPY_MODEL_fc9a3c4ae0a947ec91a227360a80f602", - "IPY_MODEL_f91dcd9f30c743d69f9d4b7e8d1beba5" - ], - "layout": "IPY_MODEL_6ede83f870a24e71b5182fcc458cdc42" - } - }, - "e928540e99564d808cb2d12c92daa498": { - "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_c9974003727a401797953ef2885db5a2", - "placeholder": "​", - "style": "IPY_MODEL_77a361d1ff214e8799891bbeb28a0789", - "value": "Downloading: 100%" - } - }, - "fc9a3c4ae0a947ec91a227360a80f602": { - "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_27f6f437c5264368bc2c679942ad1e53", - "max": 83316686, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e7728d9c55e44274966f8f6dbc445c54", - "value": 83316686 - } - }, - "f91dcd9f30c743d69f9d4b7e8d1beba5": { + "ac0bcfa1ef6e4e78a7769c4cb2e8762f": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -2784,16 +2873,16 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_2b2d7912186a49dd9891ae12c77482c7", + "layout": "IPY_MODEL_549a30c85c47466eadedbd24da42e304", "placeholder": "​", - "style": "IPY_MODEL_1600b9cd09c446e581b7912e35c9f56e", - "value": " 83.3M/83.3M [00:01<00:00, 60.9MB/s]" + "style": "IPY_MODEL_bedc7d916b9745f097094c5c51a81f06", + "value": " 500/500 [00:00<00:00, 5.05kB/s]" } }, - "6ede83f870a24e71b5182fcc458cdc42": { + "ac2950d08fc145ba9eb9cf5824b1ee18": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2842,10 +2931,10 @@ "width": null } }, - "c9974003727a401797953ef2885db5a2": { + "b26354d0278f447d92c7e1ad4c211d64": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2894,25 +2983,10 @@ "width": null } }, - "77a361d1ff214e8799891bbeb28a0789": { - "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": "" - } - }, - "27f6f437c5264368bc2c679942ad1e53": { + "b2be65e192384c948fb8987d4cfca505": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -2961,26 +3035,32 @@ "width": null } }, - "e7728d9c55e44274966f8f6dbc445c54": { + "ba18cded436e486da34882d821d8f1eb": { "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", + "model_name": "ButtonModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", + "_model_name": "ButtonModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_0e382d66f09f4958a40baa7ab83c4ccb", + "style": "IPY_MODEL_6a45ce374e2e47ba9457d02e02522748", + "tooltip": "" } }, - "2b2d7912186a49dd9891ae12c77482c7": { + "bacfb50c001047c4824a05c9f2ee2e40": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3029,92 +3109,49 @@ "width": null } }, - "1600b9cd09c446e581b7912e35c9f56e": { - "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": "" - } - }, - "28004251b0e44a6c9dfa7ce1b30dcb18": { - "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_e98cf7a63c814ffd94f69928f0700ebf", - "IPY_MODEL_6a4dee55cbae4959bd7fe3c4d92242b1", - "IPY_MODEL_8dba487876124827919079519406ecb8" - ], - "layout": "IPY_MODEL_5c211704f90946afbae2f66a7586ce70" - } - }, - "e98cf7a63c814ffd94f69928f0700ebf": { + "bcf766d2a2c641f0aa2af596c7da1b18": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "success", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_aba21021d3bb4565a58ffa40049810db", - "placeholder": "​", - "style": "IPY_MODEL_f7812fa7fbf744c1b261b985d085e28e", - "value": "Downloading: 100%" + "layout": "IPY_MODEL_ee537ee5470f4d7b816a8c8f96948b4d", + "max": 17719103, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_652e97509a914f3b914665c4889c6d11", + "value": 17719103 } }, - "6a4dee55cbae4959bd7fe3c4d92242b1": { + "bedc7d916b9745f097094c5c51a81f06": { "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", + "_model_name": "DescriptionStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d7071582bfbe4ec4b2c3c9843e5481ae", - "max": 1921, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_0d80273cabbc42ba9a408fb1144151c9", - "value": 1921 + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" } }, - "8dba487876124827919079519406ecb8": { + "bf299285318b4a04a88569cc581ecd75": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -3126,120 +3163,38 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_67fcc38a1e5d4eb39381685447e397de", + "layout": "IPY_MODEL_bacfb50c001047c4824a05c9f2ee2e40", "placeholder": "​", - "style": "IPY_MODEL_0b4bf8076fdf4d19843a3246c8bd61ac", - "value": " 1.92k/1.92k [00:00<00:00, 63.2kB/s]" - } - }, - "5c211704f90946afbae2f66a7586ce70": { - "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 + "style": "IPY_MODEL_c53a1cf68fcd4388abf1f0379891089a", + "value": " 129k/129k [00:00<00:00, 155kB/s]" } }, - "aba21021d3bb4565a58ffa40049810db": { - "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 + "c3358d32ac814ea6bc5714402c5bc62d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ecd8e5e364d34ea8bfbba4fbd467384d", + "IPY_MODEL_0125df9fa8e14b3db0e2bce299529812", + "IPY_MODEL_e3169ca885e04536a709d5751173ce9a" + ], + "layout": "IPY_MODEL_70abdfd99be84f7b9b8d24fee9eec022" } }, - "f7812fa7fbf744c1b261b985d085e28e": { + "c53a1cf68fcd4388abf1f0379891089a": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", @@ -3251,10 +3206,33 @@ "description_width": "" } }, - "d7071582bfbe4ec4b2c3c9843e5481ae": { + "c8731777ce834e58a76a295076200cfc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_859b12a6d95b4c6f987791ca848122b9", + "IPY_MODEL_94756148d2e94a93ae233baba20af683", + "IPY_MODEL_ba18cded436e486da34882d821d8f1eb", + "IPY_MODEL_99898e6ee64a46bd832af112e79b58b7" + ], + "layout": "IPY_MODEL_79184c8c2a6f4b7493bb7f6983f18a09" + } + }, + "c8e0c9a60ef34d2caee9d55a3c21c3d4": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3303,26 +3281,10 @@ "width": null } }, - "0d80273cabbc42ba9a408fb1144151c9": { - "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": "" - } - }, - "67fcc38a1e5d4eb39381685447e397de": { + "c9974003727a401797953ef2885db5a2": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3371,25 +3333,10 @@ "width": null } }, - "0b4bf8076fdf4d19843a3246c8bd61ac": { + "d12f07e25bf5422facc38c3463700994": { "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": "" - } - }, - "d182e37b4a404158bee8446fc2728bd9": { - "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", - "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -3401,38 +3348,17 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_603e99f45afb4910a99f7684ffd21b6a", - "IPY_MODEL_d13ba6030aff42bca48c72ff071c44c0", - "IPY_MODEL_a899f4bc6ed842d397723cca582669e6" + "IPY_MODEL_eae11f84c2644ada8295b445c924baec", + "IPY_MODEL_bcf766d2a2c641f0aa2af596c7da1b18", + "IPY_MODEL_74bf69aa6eaa4a8594b2ea9a0fb20957" ], - "layout": "IPY_MODEL_a02030ba8f324d93a7ed6cc793d70a3b" - } - }, - "603e99f45afb4910a99f7684ffd21b6a": { - "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_b26354d0278f447d92c7e1ad4c211d64", - "placeholder": "​", - "style": "IPY_MODEL_3bd33a372aad4c438f64d73c97f14c6a", - "value": "Downloading: 100%" + "layout": "IPY_MODEL_2d7a0b901d7044d5b1f273a3e9bea560" } }, "d13ba6030aff42bca48c72ff071c44c0": { "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -3453,31 +3379,32 @@ "value": 5534328 } }, - "a899f4bc6ed842d397723cca582669e6": { + "d182e37b4a404158bee8446fc2728bd9": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_341615c971b04033b7293d82fc40f35c", - "placeholder": "​", - "style": "IPY_MODEL_17856a72e4e948039a66c51e8244cb50", - "value": " 5.53M/5.53M [00:00<00:00, 21.7MB/s]" + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_603e99f45afb4910a99f7684ffd21b6a", + "IPY_MODEL_d13ba6030aff42bca48c72ff071c44c0", + "IPY_MODEL_a899f4bc6ed842d397723cca582669e6" + ], + "layout": "IPY_MODEL_a02030ba8f324d93a7ed6cc793d70a3b" } }, - "a02030ba8f324d93a7ed6cc793d70a3b": { + "d33fba0d78fb41f983c55f5cd2a0a740": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3526,10 +3453,10 @@ "width": null } }, - "b26354d0278f447d92c7e1ad4c211d64": { + "d7071582bfbe4ec4b2c3c9843e5481ae": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3578,10 +3505,10 @@ "width": null } }, - "3bd33a372aad4c438f64d73c97f14c6a": { + "e1c9df12fa034c93a9b3530ea4a7c5aa": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", @@ -3593,78 +3520,31 @@ "description_width": "" } }, - "c8e0c9a60ef34d2caee9d55a3c21c3d4": { - "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 - } - }, - "764aa53d75324d73ab06936c52fd8fc8": { + "e3169ca885e04536a709d5751173ce9a": { "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_358c3a67f8b54c4c899e095611fa116b", + "placeholder": "​", + "style": "IPY_MODEL_e1c9df12fa034c93a9b3530ea4a7c5aa", + "value": " 318/318 [00:00<00:00, 11.0kB/s]" } }, - "341615c971b04033b7293d82fc40f35c": { + "e4c1e9affaba4045a3ec903091b6f454": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3713,47 +3593,26 @@ "width": null } }, - "17856a72e4e948039a66c51e8244cb50": { + "e7728d9c55e44274966f8f6dbc445c54": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", - "description_width": "" - } - }, - "41eb32a6fef141ff9cc3ce6e4d771822": { - "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_0d10fb0edc9144b1a1fc1f2c9e322410", - "IPY_MODEL_32accb0adfa24c62a75c15c8ec88df8c", - "IPY_MODEL_bf299285318b4a04a88569cc581ecd75" - ], - "layout": "IPY_MODEL_ac2950d08fc145ba9eb9cf5824b1ee18" + "bar_color": null, + "description_width": "" } }, - "0d10fb0edc9144b1a1fc1f2c9e322410": { + "e928540e99564d808cb2d12c92daa498": { "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -3765,40 +3624,16 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_d33fba0d78fb41f983c55f5cd2a0a740", + "layout": "IPY_MODEL_c9974003727a401797953ef2885db5a2", "placeholder": "​", - "style": "IPY_MODEL_fd47487fc8734594823f8afa00c4239d", + "style": "IPY_MODEL_77a361d1ff214e8799891bbeb28a0789", "value": "Downloading: 100%" } }, - "32accb0adfa24c62a75c15c8ec88df8c": { + "e98cf7a63c814ffd94f69928f0700ebf": { "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_23d4e25ec6c541818d5927b69576d278", - "max": 128619, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_54d9456703324160aced03ee5fef2943", - "value": 128619 - } - }, - "bf299285318b4a04a88569cc581ecd75": { - "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", - "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", @@ -3810,16 +3645,16 @@ "_view_name": "HTMLView", "description": "", "description_tooltip": null, - "layout": "IPY_MODEL_bacfb50c001047c4824a05c9f2ee2e40", + "layout": "IPY_MODEL_aba21021d3bb4565a58ffa40049810db", "placeholder": "​", - "style": "IPY_MODEL_c53a1cf68fcd4388abf1f0379891089a", - "value": " 129k/129k [00:00<00:00, 155kB/s]" + "style": "IPY_MODEL_f7812fa7fbf744c1b261b985d085e28e", + "value": "Downloading: 100%" } }, - "ac2950d08fc145ba9eb9cf5824b1ee18": { + "ea95ffd922c0455d957120f034e541f8": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3868,10 +3703,31 @@ "width": null } }, - "d33fba0d78fb41f983c55f5cd2a0a740": { + "eae11f84c2644ada8295b445c924baec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2cbf0faadd4842c8b22e10541ff9de4e", + "placeholder": "​", + "style": "IPY_MODEL_ab32c7daa1d9404fb921f39fbc4fc05c", + "value": "Downloading: 100%" + } + }, + "ebc9801e164a44b3b6f8dc7f590e1c79": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3920,25 +3776,31 @@ "width": null } }, - "fd47487fc8734594823f8afa00c4239d": { + "ecd8e5e364d34ea8bfbba4fbd467384d": { "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_554e567a83b348f88092c6ba01830930", + "placeholder": "​", + "style": "IPY_MODEL_6e334cad2e94462cae6e722bd6f11a9e", + "value": "Downloading: 100%" } }, - "23d4e25ec6c541818d5927b69576d278": { + "ed169fd606274f2ebbb3e8f32ab42431": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -3987,26 +3849,62 @@ "width": null } }, - "54d9456703324160aced03ee5fef2943": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", + "ee537ee5470f4d7b816a8c8f96948b4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", + "_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": "StyleView", - "bar_color": null, - "description_width": "" + "_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 } }, - "bacfb50c001047c4824a05c9f2ee2e40": { + "f21c0c6379d74898ac6aadcb6fc14a8a": { "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", "model_module_version": "1.2.0", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", @@ -4055,10 +3953,85 @@ "width": null } }, - "c53a1cf68fcd4388abf1f0379891089a": { + "f439c1de68ac4c799d81fdb29d053d10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f7812fa7fbf744c1b261b985d085e28e": { "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f91dcd9f30c743d69f9d4b7e8d1beba5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b2d7912186a49dd9891ae12c77482c7", + "placeholder": "​", + "style": "IPY_MODEL_1600b9cd09c446e581b7912e35c9f56e", + "value": " 83.3M/83.3M [00:01<00:00, 60.9MB/s]" + } + }, + "fc9a3c4ae0a947ec91a227360a80f602": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_27f6f437c5264368bc2c679942ad1e53", + "max": 83316686, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e7728d9c55e44274966f8f6dbc445c54", + "value": 83316686 + } + }, + "fd47487fc8734594823f8afa00c4239d": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", @@ -4069,15 +4042,31 @@ "_view_name": "StyleView", "description_width": "" } + }, + "fee75343289f42fb8d6dfb4bf26fe368": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_16c0017f65b649f5ac5bebf1c955a1fd", + "placeholder": "​", + "style": "IPY_MODEL_5e2c207db5424f91829bf5c52040a9f2", + "value": " 1.92k/1.92k [00:00<00:00, 48.3kB/s]" + } } } - }, - "colab": { - "provenance": [], - "include_colab_link": true - }, - "accelerator": "GPU" + } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From 2a9a892726e27a95af455650217d1aa4c7681b29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Feb 2023 13:55:58 +0100 Subject: [PATCH 052/112] doc: fix link to pyannote/segmentation --- tutorials/intro.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index f5decb153..f6b420437 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -418,6 +418,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": { "id": "5MclWK2GYnp_" @@ -430,7 +431,7 @@ "To load the speaker diarization pipeline, \n", "\n", "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization)\n", - "* accept the user conditions on [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/segmentation)\n", + "* accept the user conditions on [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation)\n", "* login using `notebook_login` below" ] }, From d4ff0bd23dcf9f8bf2ed907ca73fbdc2be19d4e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Feb 2023 21:17:08 +0100 Subject: [PATCH 053/112] feat: add option to make progress hook transient (#1264) --- pyannote/audio/pipelines/utils/hook.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/pyannote/audio/pipelines/utils/hook.py b/pyannote/audio/pipelines/utils/hook.py index 443ef9ac4..cb150ea4a 100644 --- a/pyannote/audio/pipelines/utils/hook.py +++ b/pyannote/audio/pipelines/utils/hook.py @@ -51,6 +51,11 @@ def logging_hook( class ProgressHook: """Hook to show progress of each internal step + Parameters + ---------- + transient: bool, optional + Clear the progress on exit. Defaults to False. + Example ------- pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization") @@ -58,6 +63,10 @@ class ProgressHook: output = pipeline(file, hook=hook) """ + def __init__(self, transient: bool = False): + super().__init__() + self.transient = transient + def __enter__(self): self.progress = Progress( @@ -65,6 +74,7 @@ def __enter__(self): BarColumn(), TaskProgressColumn(), TimeRemainingColumn(elapsed_when_finished=True), + transient=self.transient, ) self.progress.start() return self From 9da0ce8d604ef4203cd80eea82c9866a8980dbc0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 20 Feb 2023 07:53:04 +0100 Subject: [PATCH 054/112] feat: add support for "device" in Pipeline.from_pretrained (#1265) --- pyannote/audio/core/pipeline.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index f7c83a3e9..8ebd76c6a 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -28,6 +28,7 @@ from pathlib import Path from typing import Callable, Dict, List, Optional, Text, Union +import torch import yaml from huggingface_hub import hf_hub_download from huggingface_hub.utils import RepositoryNotFoundError @@ -169,6 +170,11 @@ def from_pretrained( pipeline.preprocessors = preprocessors + # send pipeline to specified device + if "device" in config: + device = torch.device(config["device"]) + pipeline.to(device) + return pipeline def __init__(self): From e3dc7d68cc60c7d4f89df005b58674aa936b0882 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 20 Feb 2023 07:54:04 +0100 Subject: [PATCH 055/112] fix: switch back to monitoring DER --- .../audio/tasks/segmentation/segmentation.py | 21 ------------------- 1 file changed, 21 deletions(-) diff --git a/pyannote/audio/tasks/segmentation/segmentation.py b/pyannote/audio/tasks/segmentation/segmentation.py index 976b5d376..715cfc646 100644 --- a/pyannote/audio/tasks/segmentation/segmentation.py +++ b/pyannote/audio/tasks/segmentation/segmentation.py @@ -731,27 +731,6 @@ def validation_step(self, batch, batch_idx: int): plt.close(fig) - @property - def val_monitor(self): - """Quantity (and direction) to monitor - - Useful for model checkpointing or early stopping. - - Returns - ------- - monitor : str - Name of quantity to monitor (validation loss) - mode : {'min', 'max} - Minimize - - See also - -------- - pytorch_lightning.callbacks.ModelCheckpoint - pytorch_lightning.callbacks.EarlyStopping - """ - - return f"{self.logging_prefix}ValLoss", "min" - def main(protocol: str, subset: str = "test", model: str = "pyannote/segmentation"): """Evaluate a segmentation model""" From b56add2e2033060dca28be71563dab5ff0fd3e64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 20 Feb 2023 07:58:58 +0100 Subject: [PATCH 056/112] BREAKING(cli): only save top checkpoint --- pyannote/audio/cli/train.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index 56e6a3c18..be9596e4a 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -26,6 +26,7 @@ import hydra from hydra.utils import instantiate +from lightning_lite.utilities.seed import seed_everything from omegaconf import DictConfig, OmegaConf # from pyannote.audio.core.callback import GraduallyUnfreeze @@ -37,7 +38,6 @@ RichProgressBar, ) from pytorch_lightning.loggers import TensorBoardLogger -from lightning_lite.utilities.seed import seed_everything from torch_audiomentations.utils.config import from_dict as get_augmentation from pyannote.audio.core.io import get_torchaudio_info @@ -112,7 +112,7 @@ def configure_optimizers(self): checkpoint = ModelCheckpoint( monitor=monitor, mode=direction, - save_top_k=None if monitor is None else 5, + save_top_k=None if monitor is None else 1, every_n_epochs=1, save_last=True, save_weights_only=False, From 39a261a0eb2eed89ba0f167aea35e8e27d8310c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Mar 2023 15:04:26 +0100 Subject: [PATCH 057/112] feat: add FAQ based on faqtory (#1283) --- .faq/FAQ.md | 20 +++++++++++++ .faq/suggest.md | 20 +++++++++++++ .github/workflows/new_issue.yml | 27 ++++++++++++++++++ FAQ.md | 41 +++++++++++++++++++++++---- README.md | 7 +---- faq.yml | 7 +++++ questions/README.md | 6 ++++ questions/bad_performance.question.md | 16 +++++++++++ questions/from_memory.question.md | 7 +++++ questions/offline.question.md | 15 ++++++++++ questions/pyannote.question.md | 10 +++++++ questions/streaming.question.md | 10 +++++++ 12 files changed, 174 insertions(+), 12 deletions(-) create mode 100644 .faq/FAQ.md create mode 100644 .faq/suggest.md create mode 100644 .github/workflows/new_issue.yml create mode 100644 faq.yml create mode 100644 questions/README.md create mode 100644 questions/bad_performance.question.md create mode 100644 questions/from_memory.question.md create mode 100644 questions/offline.question.md create mode 100644 questions/pyannote.question.md create mode 100644 questions/streaming.question.md diff --git a/.faq/FAQ.md b/.faq/FAQ.md new file mode 100644 index 000000000..24516eace --- /dev/null +++ b/.faq/FAQ.md @@ -0,0 +1,20 @@ + +# Frequently Asked Questions + +{%- for question in questions %} +- [{{ question.title }}](#{{ question.slug }}) +{%- endfor %} + + +{%- for question in questions %} + + +## {{ question.title }} + +{{ question.body }} + +{%- endfor %} + +
+ +Generated by [FAQtory](https://github.com/willmcgugan/faqtory) diff --git a/.faq/suggest.md b/.faq/suggest.md new file mode 100644 index 000000000..0a9233998 --- /dev/null +++ b/.faq/suggest.md @@ -0,0 +1,20 @@ +{%- if questions -%} +{% if questions|length == 1 %} +We found the following entry in the [FAQ]({{ faq_url }}) which you may find helpful: +{%- else %} +We found the following entries in the [FAQ]({{ faq_url }}) which you may find helpful: +{%- endif %} + +{% for question in questions %} +- [{{ question.title }}]({{ faq_url }}#{{ question.slug }}) +{%- endfor %} + +Feel free to close this issue if you found an answer in the FAQ. Otherwise, please give us a little time to review. + +{%- else -%} +Thank you for your issue. Give us a little time to review it. + +PS. You might want to check the [FAQ]({{ faq_url }}) if you haven't done so already. +{%- endif %} + +This is an automated reply, generated by [FAQtory](https://github.com/willmcgugan/faqtory) diff --git a/.github/workflows/new_issue.yml b/.github/workflows/new_issue.yml new file mode 100644 index 000000000..9b6665ec5 --- /dev/null +++ b/.github/workflows/new_issue.yml @@ -0,0 +1,27 @@ +name: issues +on: + issues: + types: [opened] +jobs: + add-comment: + runs-on: ubuntu-latest + permissions: + issues: write + steps: + - uses: actions/checkout@v3 + with: + ref: main + - name: Install FAQtory + run: pip install FAQtory + - name: Run Suggest + run: faqtory suggest "${{ github.event.issue.title }}" > suggest.md + - name: Read suggest.md + id: suggest + uses: juliangruber/read-file-action@v1 + with: + path: ./suggest.md + - name: Suggest FAQ + uses: peter-evans/create-or-update-comment@a35cf36e5301d70b76f316e867e7788a55a31dae + with: + issue-number: ${{ github.event.issue.number }} + body: ${{ steps.suggest.outputs.content }} diff --git a/FAQ.md b/FAQ.md index 3b50069a4..f192b2939 100644 --- a/FAQ.md +++ b/FAQ.md @@ -1,11 +1,17 @@ -# Frequently asked questions -## How does one capitalize and pronounce the name of this awesome library? +# Frequently Asked Questions +- [Can I apply pretrained pipelines on audio already loaded in memory?](#can-i-apply-pretrained-pipelines-on-audio-already-loaded-in-memory) +- [Can I use gated models (and pipelines) offline?](#can-i-use-gated-models-(and-pipelines)-offline) +- [Does pyannote support streaming speaker diarization?](#does-pyannote-support-streaming-speaker-diarization) +- [How can I improve performance?](#how-can-i-improve-performance) +- [How does one spell and pronounce pyannote.audio?](#how-does-one-spell-and-pronounce-pyannoteaudio) -📝 Written in lower case: `pyannote.audio` (or `pyannote` if you are lazy). Not `PyAnnote` nor `PyAnnotate` (*sic*). -📢 [Pronounced](https://www.howtopronounce.com/french/pianote) like the french verb *pianoter*. *pi* like in **pi**ano, not *py* like in **py**thon. -🎹 *pianoter* means *to play the piano* (hence the logo 🤯). + +## Can I apply pretrained pipelines on audio already loaded in memory? +Yes: read [this tutorial](tutorials/applying_a_pipeline.ipynb) until the end. + + ## Can I use gated models (and pipelines) offline? **Short answer**: yes, see [this tutorial](tutorials/applying_a_model.ipynb) for models and [that one](tutorials/applying_a_pipeline.ipynb) for pipelines. @@ -16,10 +22,33 @@ For instance, before gating `pyannote/speaker-diarization`, I had no idea that s That being said, this whole authentication process does not prevent you from using official `pyannote.audio` models offline (i.e. without going through the authentication process in every `docker run ...` or whatever you are using in production): see [this tutorial](tutorials/applying_a_model.ipynb) for models and [that one](tutorials/applying_a_pipeline.ipynb) for pipelines. -## **[Pretrained pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) do not produce good results on my data. What can I do?** + +## Does pyannote support streaming speaker diarization? + +**Short answer:** not out of the box, no. + +**Long answer:** [I](https://herve.niderb.fr) am looking for sponsors to add this feature. In the meantime, [`diart`](https://github.com/juanmc2005/StreamingSpeakerDiarization) is the closest you can get from a streaming `pyannote.audio`. You might also be interested in [this blog post](https://herve.niderb.fr/fastpages/2021/08/05/Streaming-voice-activity-detection-with-pyannote.html) about streaming voice activity detection based on `pyannote.audio`. + + +## How can I improve performance? + +**Long answer:** 1. Manually annotate dozens of conversations as precisely as possible. 2. Separate them into train (80%), development (10%) and test (10%) subsets. 3. Setup the data for use with [`pyannote.database`](https://github.com/pyannote/pyannote-database#speaker-diarization). 4. Follow [this recipe](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/adapting_pretrained_pipeline.ipynb). 5. Enjoy. + +**Also:** [I am available](https://herve.niderb.fr) for contracting to help you with that. + + +## How does one spell and pronounce pyannote.audio? + +📝 Written in lower case: `pyannote.audio` (or `pyannote` if you are lazy). Not `PyAnnote` nor `PyAnnotate` (sic). +📢 Pronounced like the french verb `pianoter`. `pi` like in `pi`ano, not `py` like in `py`thon. +🎹 `pianoter` means to play the piano (hence the logo 🤯). + +
+ +Generated by [FAQtory](https://github.com/willmcgugan/faqtory) diff --git a/README.md b/README.md index 7930683f0..c71361791 100644 --- a/README.md +++ b/README.md @@ -60,6 +60,7 @@ pip install pyannote.audio ## Documentation - [Changelog](CHANGELOG.md) +- [Frequently asked questions](FAQ.md) - Models - Available tasks explained - [Applying a pretrained model](tutorials/applying_a_model.ipynb) @@ -84,12 +85,6 @@ pip install pyannote.audio - [Speaker verification](tutorials/speaker_verification.ipynb) - Visualization and debugging -## Frequently asked questions - -* [How does one capitalize and pronounce the name of this awesome library?](FAQ.md) -* [Can I use gated models (and pipelines) offline?](FAQ.md) -* [Pretrained pipelines do not produce good results on my data. What can I do?](FAQ.md) - ## Benchmark Out of the box, `pyannote.audio` default speaker diarization [pipeline](https://hf.co/pyannote/speaker-diarization) is expected to be much better (and faster) in v2.x than in v1.1. Those numbers are diarization error rates (in %) diff --git a/faq.yml b/faq.yml new file mode 100644 index 000000000..f473198d5 --- /dev/null +++ b/faq.yml @@ -0,0 +1,7 @@ +# FAQtory settings + +faq_url: "https://github.com/pyannote/pyannote-audio/blob/develop/FAQ.md" # Replace this with the URL to your FAQ.md! + +questions_path: "./questions" # Where questions should be stored +output_path: "./FAQ.md" # Where FAQ.md should be generated +templates_path: ".faq" # Path to templates diff --git a/questions/README.md b/questions/README.md new file mode 100644 index 000000000..e733072f6 --- /dev/null +++ b/questions/README.md @@ -0,0 +1,6 @@ + +# Questions + +Your questions should go in this directory. + +Question files should be named with the extension ".question.md". diff --git a/questions/bad_performance.question.md b/questions/bad_performance.question.md new file mode 100644 index 000000000..a48e489e1 --- /dev/null +++ b/questions/bad_performance.question.md @@ -0,0 +1,16 @@ +--- +title: "How can I improve performance?" +alt_titles: + - "Pretrained pipelines do not produce good results on my data. What can I do?" + - "It does not work! Help me!" +--- + +**Long answer:** + +1. Manually annotate dozens of conversations as precisely as possible. +2. Separate them into train (80%), development (10%) and test (10%) subsets. +3. Setup the data for use with [`pyannote.database`](https://github.com/pyannote/pyannote-database#speaker-diarization). +4. Follow [this recipe](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/adapting_pretrained_pipeline.ipynb). +5. Enjoy. + +**Also:** [I am available](https://herve.niderb.fr) for contracting to help you with that. diff --git a/questions/from_memory.question.md b/questions/from_memory.question.md new file mode 100644 index 000000000..3556a22f7 --- /dev/null +++ b/questions/from_memory.question.md @@ -0,0 +1,7 @@ +--- +title: "Can I apply pretrained pipelines on audio already loaded in memory?" +alt_titles: + - "Can I apply models on an audio array?" +--- + +Yes: read [this tutorial](tutorials/applying_a_pipeline.ipynb) until the end. diff --git a/questions/offline.question.md b/questions/offline.question.md new file mode 100644 index 000000000..ad099ba09 --- /dev/null +++ b/questions/offline.question.md @@ -0,0 +1,15 @@ +--- +title: "Can I use gated models (and pipelines) offline?" +alt_titles: + - "Why does one need to authenticate to access the pretrained models?" + - "Can I use pyannote.audio pretrained pipelines without the Hugginface token?" + - "How can I solve the permission issue?" +--- + +**Short answer**: yes, see [this tutorial](tutorials/applying_a_model.ipynb) for models and [that one](tutorials/applying_a_pipeline.ipynb) for pipelines. + +**Long answer**: gating models and pipelines allows [me](https://herve.niderb.fr) to know a bit more about `pyannote.audio` user base and eventually help me write grant proposals to make `pyannote.audio` even better. So, please fill gating forms as precisely as possible. + +For instance, before gating `pyannote/speaker-diarization`, I had no idea that so many people were relying on it in production. Hint: sponsors are more than welcome! Maintaining open source libraries is time consuming. + +That being said, this whole authentication process does not prevent you from using official `pyannote.audio` models offline (i.e. without going through the authentication process in every `docker run ...` or whatever you are using in production): see [this tutorial](tutorials/applying_a_model.ipynb) for models and [that one](tutorials/applying_a_pipeline.ipynb) for pipelines. diff --git a/questions/pyannote.question.md b/questions/pyannote.question.md new file mode 100644 index 000000000..85e920ccc --- /dev/null +++ b/questions/pyannote.question.md @@ -0,0 +1,10 @@ +--- +title: "How does one spell and pronounce pyannote.audio?" +alt_titles: + - "Why the name of the library?" + - "Why the logo of the library?" +--- + +📝 Written in lower case: `pyannote.audio` (or `pyannote` if you are lazy). Not `PyAnnote` nor `PyAnnotate` (sic). +📢 Pronounced like the french verb `pianoter`. `pi` like in `pi`ano, not `py` like in `py`thon. +🎹 `pianoter` means to play the piano (hence the logo 🤯). diff --git a/questions/streaming.question.md b/questions/streaming.question.md new file mode 100644 index 000000000..5b6dc0cb7 --- /dev/null +++ b/questions/streaming.question.md @@ -0,0 +1,10 @@ +--- +title: "Does pyannote support streaming speaker diarization?" +alt_titles: + - "Is it possible to do realtime speaker diarization?" + - "Can it process online audio buffers?" +--- + +**Short answer:** not out of the box, no. + +**Long answer:** [I](https://herve.niderb.fr) am looking for sponsors to add this feature. In the meantime, [`diart`](https://github.com/juanmc2005/StreamingSpeakerDiarization) is the closest you can get from a streaming `pyannote.audio`. You might also be interested in [this blog post](https://herve.niderb.fr/fastpages/2021/08/05/Streaming-voice-activity-detection-with-pyannote.html) about streaming voice activity detection based on `pyannote.audio`. From 74939acbfa830521a434cb4068176196dd9612dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Mar 2023 15:10:02 +0100 Subject: [PATCH 058/112] fix: fix faqtory workflow --- .github/workflows/new_issue.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/new_issue.yml b/.github/workflows/new_issue.yml index 9b6665ec5..a67bcdcd5 100644 --- a/.github/workflows/new_issue.yml +++ b/.github/workflows/new_issue.yml @@ -10,7 +10,7 @@ jobs: steps: - uses: actions/checkout@v3 with: - ref: main + ref: develop - name: Install FAQtory run: pip install FAQtory - name: Run Suggest From 7121a73f08ec89d8293a8d95145e623675abbe21 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 13 Apr 2023 21:15:57 +0200 Subject: [PATCH 059/112] feat: add support for label scope and missing classes (#1296) - setup: switch to pyannote.database 5.0 - feat(task): add support for label scope in speaker diarization task (from pyannote.database 5.0) - feat(task): add support for missing classes in multi-label segmentation task (from pyannote.database 5.0) - improve(task): load metadata as tensors/arrays rather than pyannote.core instances - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` - BREAKING(task): remove support for variable chunk duration --- CHANGELOG.md | 9 + notebook/example.ipynb | 460 ++++++++++++-- pyannote/audio/cli/train_config/config.yaml | 2 +- ...ation.yaml => MultiLabelSegmentation.yaml} | 4 +- .../train_config/task/SpeakerDiarization.yaml | 8 + pyannote/audio/core/task.py | 5 +- pyannote/audio/pipelines/__init__.py | 2 +- ...egmentation.py => speaker_segmentation.py} | 0 pyannote/audio/tasks/__init__.py | 12 +- pyannote/audio/tasks/segmentation/mixins.py | 578 ++++++++++++------ .../audio/tasks/segmentation/multilabel.py | 182 +++++- .../overlapped_speech_detection.py | 68 ++- ...segmentation.py => speaker_diarization.py} | 263 ++++++-- .../segmentation/voice_activity_detection.py | 67 +- pyannote/audio/utils/protocol.py | 16 +- requirements.txt | 2 +- tests/tasks/test_reproducibility.py | 8 +- tests/test_train.py | 22 +- tutorials/adapting_pretrained_pipeline.ipynb | 477 +++++++-------- tutorials/training_a_model.ipynb | 4 +- 20 files changed, 1575 insertions(+), 614 deletions(-) rename pyannote/audio/cli/train_config/task/{SpeakerSegmentation.yaml => MultiLabelSegmentation.yaml} (61%) create mode 100644 pyannote/audio/cli/train_config/task/SpeakerDiarization.yaml rename pyannote/audio/pipelines/{segmentation.py => speaker_segmentation.py} (100%) rename pyannote/audio/tasks/segmentation/{segmentation.py => speaker_diarization.py} (74%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0169d74c8..d30e101a7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,14 @@ # Changelog +## Version 3.0 (xxxx-xx-xx) + + - setup: switch to pyannote.database 5.0 + - feat(task): add support for label scope in speaker diarization task (from pyannote.database 5.0) + - feat(task): add support for missing classes in multi-label segmentation task (from pyannote.database 5.0) + - improve(task): load metadata as tensors rather than pyannote.core instances + - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` + - BREAKING(task): remove support for variable chunk duration + ## Version 2.1.1 (2022-10-27) - BREAKING(pipeline): rewrite speaker diarization pipeline diff --git a/notebook/example.ipynb b/notebook/example.ipynb index 468f30b96..549656d19 100644 --- a/notebook/example.ipynb +++ b/notebook/example.ipynb @@ -2,18 +2,28 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "'Debug.SpeakerDiarization.Debug' found in /Users/hbredin/Development/pyannote/pyannote-audio/tests/data/database.yml does not define the 'scope' of speaker labels (file, database, or global). Setting it to 'file'.\n", + "'Debug.SpeakerDiarization.Bug1237' found in /Users/hbredin/Development/pyannote/pyannote-audio/tests/data/database.yml does not define the 'scope' of speaker labels (file, database, or global). Setting it to 'file'.\n" + ] + } + ], "source": [ - "from pyannote.database import get_protocol, FileFinder\n", - "protocol = get_protocol('Debug.SpeakerDiarization.Debug', \n", - " preprocessors={\"audio\": FileFinder()})" + "from pyannote.database import registry, FileFinder\n", + "registry.load_database('../tests/data/database.yml')\n", + "protocol = registry.get_protocol('Debug.SpeakerDiarization.Debug', \n", + " preprocessors={\"audio\": FileFinder()})" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -24,26 +34,133 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from pyannote.audio.utils.preview import listen\n", "listen(next(protocol.train()))" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Voice activity detection" + "## Voice activity detection" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Protocol Debug.SpeakerDiarization.Debug does not precompute the output of torchaudio.info(): adding a 'torchaudio.info' preprocessor for you to speed up dataloaders. See pyannote.database documentation on how to do that yourself.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "Missing logger folder: /Users/hbredin/Development/pyannote/pyannote-audio/notebook/lightning_logs\n", + "\n", + " | Name | Type | Params | In sizes | Out sizes \n", + "----------------------------------------------------------------------------------------------------------------------\n", + "0 | mfcc | MFCC | 0 | [32, 1, 32000] | [32, 1, 40, 161] \n", + "1 | lstm | LSTM | 18.9 K | [32, 161, 40] | [[32, 161, 64], [[2, 32, 32], [2, 32, 32]]]\n", + "2 | classifier | Linear | 65 | [32, 161, 64] | [32, 161, 1] \n", + "3 | activation | Sigmoid | 0 | [32, 161, 1] | [32, 161, 1] \n", + "4 | validation_metric | MetricCollection | 0 | ? | ? \n", + "----------------------------------------------------------------------------------------------------------------------\n", + "19.0 K Trainable params\n", + "0 Non-trainable params\n", + "19.0 K Total params\n", + "0.076 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "37e122a182e544648e65bed1f71ae722", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4e8a349a91e447a49ea0d93cccfd266c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "90c5c47fd1ce4ee98f9729258fab9692", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=1` reached.\n" + ] + } + ], "source": [ "from pyannote.audio.tasks import VoiceActivityDetection\n", "vad = VoiceActivityDetection(protocol, duration=2., batch_size=32, num_workers=4)\n", @@ -52,26 +169,6 @@ "_ = trainer.fit(model)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Speaker change detection" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.tasks import SpeakerChangeDetection\n", - "scd = SpeakerChangeDetection(protocol, duration=2., batch_size=32, num_workers=4)\n", - "model = SimpleSegmentationModel(task=scd)\n", - "trainer = pl.Trainer(max_epochs=1)\n", - "_ = trainer.fit(model)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -81,9 +178,82 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params | In sizes | Out sizes \n", + "----------------------------------------------------------------------------------------------------------------------\n", + "0 | mfcc | MFCC | 0 | [32, 1, 32000] | [32, 1, 40, 161] \n", + "1 | lstm | LSTM | 18.9 K | [32, 161, 40] | [[32, 161, 64], [[2, 32, 32], [2, 32, 32]]]\n", + "2 | classifier | Linear | 65 | [32, 161, 64] | [32, 161, 1] \n", + "3 | activation | Sigmoid | 0 | [32, 161, 1] | [32, 161, 1] \n", + "4 | validation_metric | MetricCollection | 0 | ? | ? \n", + "----------------------------------------------------------------------------------------------------------------------\n", + "19.0 K Trainable params\n", + "0 Non-trainable params\n", + "19.0 K Total params\n", + "0.076 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9a8333c0ebdf41a79482d81e94bf0e76", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "96c422e9449e40fa82a7f274cc6e5e16", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1f343adebc5a407ab7b33b5b88094edf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=1` reached.\n" + ] + } + ], "source": [ "from pyannote.audio.tasks import OverlappedSpeechDetection\n", "ovl = OverlappedSpeechDetection(protocol, duration=2., batch_size=32, num_workers=4)\n", @@ -93,45 +263,154 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Segmentation" + "## (Local) speaker diarization" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "574568dce865407e912423c55dfb002d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n" + ], + "text/plain": [ + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params | In sizes | Out sizes \n", + "----------------------------------------------------------------------------------------------------------------------\n", + "0 | mfcc | MFCC | 0 | [32, 1, 32000] | [32, 1, 40, 161] \n", + "1 | lstm | LSTM | 18.9 K | [32, 161, 40] | [[32, 161, 64], [[2, 32, 32], [2, 32, 32]]]\n", + "2 | classifier | Linear | 195 | [32, 161, 64] | [32, 161, 3] \n", + "3 | activation | Sigmoid | 0 | [32, 161, 3] | [32, 161, 3] \n", + "4 | validation_metric | MetricCollection | 0 | ? | ? \n", + "----------------------------------------------------------------------------------------------------------------------\n", + "19.1 K Trainable params\n", + "0 Non-trainable params\n", + "19.1 K Total params\n", + "0.077 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - 27.32% of all chunks contain no speech at all.\n", + " - 66.79% contain 1 speaker or less\n", + " - 91.25% contain 2 speakers or less\n", + " - 98.04% contain 3 speakers or less\n", + " - 100.00% contain 4 speakers or less\n", + "Setting `max_speakers_per_chunk` to 3. You can override this value (or avoid this estimation step) by passing `max_speakers_per_chunk=3` to the task constructor.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "423b6758f1c84f3b8ece70744862fb66", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e85cb23d204c4876a82a8202edc273c5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b8f5929201654acf83fbca919a5ac63b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=1` reached.\n" + ] + } + ], "source": [ - "from pyannote.audio.tasks import Segmentation\n", - "seg = Segmentation(protocol, duration=2., batch_size=32, num_workers=4)\n", + "from pyannote.audio.tasks import SpeakerDiarization\n", + "seg = SpeakerDiarization(protocol, duration=2., batch_size=32, num_workers=4)\n", "model = SimpleSegmentationModel(task=seg)\n", "trainer = pl.Trainer(max_epochs=1)\n", "_ = trainer.fit(model)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Speaker tracking" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.tasks import SpeakerTracking\n", - "spk = SpeakerTracking(protocol, duration=2., batch_size=32, num_workers=4)\n", - "model = SimpleSegmentationModel(task=spk)\n", - "trainer = pl.Trainer(max_epochs=1)\n", - "_ = trainer.fit(model)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -141,9 +420,68 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "Loading Debug.SpeakerDiarization.Debug training labels: 10file [00:00, 363.55file/s]\n", + "\n", + " | Name | Type | Params | In sizes | Out sizes \n", + "----------------------------------------------------------------------------------------------------------------------\n", + "0 | mfcc | MFCC | 0 | [32, 1, 32000] | [32, 1, 40, 161] \n", + "1 | lstm | LSTM | 18.9 K | [32, 161, 40] | [[32, 161, 64], [[2, 32, 32], [2, 32, 32]]]\n", + "2 | loss_func | ArcFaceLoss | 832 | ? | ? \n", + "3 | validation_metric | MetricCollection | 0 | ? | ? \n", + "----------------------------------------------------------------------------------------------------------------------\n", + "19.8 K Trainable params\n", + "0 Non-trainable params\n", + "19.8 K Total params\n", + "0.079 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b34c5cbe6c9c409fb5572b0be9598076", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "71077814aa154ba3b4892e8be13a98fe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=1` reached.\n" + ] + } + ], "source": [ "from pyannote.audio.tasks import SpeakerEmbedding\n", "emb = SpeakerEmbedding(protocol, duration=2., num_workers=4)\n", @@ -169,7 +507,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.13" } }, "nbformat": 4, diff --git a/pyannote/audio/cli/train_config/config.yaml b/pyannote/audio/cli/train_config/config.yaml index 380ed9213..d5b761cc9 100644 --- a/pyannote/audio/cli/train_config/config.yaml +++ b/pyannote/audio/cli/train_config/config.yaml @@ -2,7 +2,7 @@ registry: ??? protocol: ??? defaults: - - task: SpeakerSegmentation + - task: SpeakerDiarization - model: PyanNet - optimizer: Adam - scheduler: CosineAnnealingWarmRestarts diff --git a/pyannote/audio/cli/train_config/task/SpeakerSegmentation.yaml b/pyannote/audio/cli/train_config/task/MultiLabelSegmentation.yaml similarity index 61% rename from pyannote/audio/cli/train_config/task/SpeakerSegmentation.yaml rename to pyannote/audio/cli/train_config/task/MultiLabelSegmentation.yaml index fcfa06978..aceb8cb22 100644 --- a/pyannote/audio/cli/train_config/task/SpeakerSegmentation.yaml +++ b/pyannote/audio/cli/train_config/task/MultiLabelSegmentation.yaml @@ -1,6 +1,6 @@ # @package _group_ -_target_: pyannote.audio.tasks.Segmentation -duration: 5.0 +_target_: pyannote.audio.tasks.MultiLabelSegmentation +duration: 3.0 warm_up: 0.0 balance: null weight: null diff --git a/pyannote/audio/cli/train_config/task/SpeakerDiarization.yaml b/pyannote/audio/cli/train_config/task/SpeakerDiarization.yaml new file mode 100644 index 000000000..d9ec04a57 --- /dev/null +++ b/pyannote/audio/cli/train_config/task/SpeakerDiarization.yaml @@ -0,0 +1,8 @@ +# @package _group_ +_target_: pyannote.audio.tasks.SpeakerDiarization +duration: 5.0 +max_speakers_per_chunk: 3 +max_speakers_per_frame: 2 +batch_size: 32 +num_workers: 10 +pin_memory: False diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index 5b523176b..c7833dc77 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -215,7 +215,10 @@ def __init__( super().__init__() # dataset - self.protocol, self.has_validation = check_protocol(protocol) + self.protocol, checks = check_protocol(protocol) + self.has_validation = checks["has_validation"] + self.has_scope = checks["has_scope"] + self.has_classes = checks["has_classes"] # batching self.duration = duration diff --git a/pyannote/audio/pipelines/__init__.py b/pyannote/audio/pipelines/__init__.py index 21ff08ab1..d20f9bfb9 100644 --- a/pyannote/audio/pipelines/__init__.py +++ b/pyannote/audio/pipelines/__init__.py @@ -23,8 +23,8 @@ from .multilabel import MultiLabelSegmentation from .overlapped_speech_detection import OverlappedSpeechDetection from .resegmentation import Resegmentation -from .segmentation import SpeakerSegmentation from .speaker_diarization import SpeakerDiarization +from .speaker_segmentation import SpeakerSegmentation from .voice_activity_detection import VoiceActivityDetection __all__ = [ diff --git a/pyannote/audio/pipelines/segmentation.py b/pyannote/audio/pipelines/speaker_segmentation.py similarity index 100% rename from pyannote/audio/pipelines/segmentation.py rename to pyannote/audio/pipelines/speaker_segmentation.py diff --git a/pyannote/audio/tasks/__init__.py b/pyannote/audio/tasks/__init__.py index eeaf19d10..6cbba258f 100644 --- a/pyannote/audio/tasks/__init__.py +++ b/pyannote/audio/tasks/__init__.py @@ -20,21 +20,25 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from .segmentation.multilabel import MultiLabelSegmentation # isort:skip +from .segmentation.speaker_diarization import SpeakerDiarization # isort:skip from .segmentation.voice_activity_detection import VoiceActivityDetection # isort:skip from .segmentation.overlapped_speech_detection import ( # isort:skip OverlappedSpeechDetection, ) - -from .segmentation.multilabel import MultiLabelSegmentation # isort:skip -from .segmentation.segmentation import Segmentation # isort:skip from .embedding.arcface import SupervisedRepresentationLearningWithArcFace # isort:skip +# Segmentation has been renamed to SpeakerDiarization but we keep Segmentation here for backward compatibility +Segmentation = SpeakerDiarization + +# SpeakerEmbedding is more human-friendly SpeakerEmbedding = SupervisedRepresentationLearningWithArcFace __all__ = [ - "Segmentation", + "SpeakerDiarization", "VoiceActivityDetection", "OverlappedSpeechDetection", "MultiLabelSegmentation", "SpeakerEmbedding", + "Segmentation", ] diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index b9056d052..1cdb9840d 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -24,115 +24,382 @@ import math import random import warnings -from typing import Dict, Optional, Sequence, Text, Union +from collections import defaultdict +from typing import Dict, Optional, Sequence, Union import matplotlib.pyplot as plt import numpy as np import torch -import torch.nn.functional -from pyannote.core import Segment, SlidingWindowFeature +from pyannote.database.protocol import SegmentationProtocol, SpeakerDiarizationProtocol +from pyannote.database.protocol.protocol import Scope, Subset from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger from torch.utils.data._utils.collate import default_collate +from torchaudio.backend.common import AudioMetaData from torchmetrics import Metric from torchmetrics.classification import BinaryAUROC, MulticlassAUROC, MultilabelAUROC -from pyannote.audio.core.io import AudioFile from pyannote.audio.core.task import Problem -from pyannote.audio.utils.powerset import Powerset from pyannote.audio.utils.random import create_rng_for_worker +Subsets = list(Subset.__args__) +Scopes = list(Scope.__args__) + class SegmentationTaskMixin: """Methods common to most segmentation tasks""" + def get_file(self, file_id): + + file = dict() + + file["audio"] = str(self.audios[file_id], encoding="utf-8") + + _audio_info = self.audio_infos[file_id] + _encoding = self.audio_encodings[file_id] + + sample_rate = _audio_info["sample_rate"] + num_frames = _audio_info["num_frames"] + num_channels = _audio_info["num_channels"] + bits_per_sample = _audio_info["bits_per_sample"] + encoding = str(_encoding, encoding="utf-8") + file["torchaudio.info"] = AudioMetaData( + sample_rate=sample_rate, + num_frames=num_frames, + num_channels=num_channels, + bits_per_sample=bits_per_sample, + encoding=encoding, + ) + + return file + def setup(self, stage: Optional[str] = None): + """Setup method + + Parameters + ---------- + stage : {'fit', 'validate', 'test'}, optional + Setup stage. Defaults to 'fit'. + """ + + # duration of training chunks + # TODO: handle variable duration case + duration = getattr(self, "duration", 0.0) - # ================================================================== - # PREPARE TRAINING DATA - # ================================================================== + # list of possible values for each metadata key + metadata_unique_values = defaultdict(list) - self._train = [] - self._train_metadata = dict() + metadata_unique_values["subset"] = Subsets - for f in self.protocol.train(): + if isinstance(self.protocol, SpeakerDiarizationProtocol): + metadata_unique_values["scope"] = Scopes - file = dict() + elif isinstance(self.protocol, SegmentationProtocol): + classes = getattr(self, "classes", list()) - for key, value in f.items(): + # make sure classes attribute exists (and set to None if it did not exist) + self.classes = getattr(self, "classes", None) + if self.classes is None: + classes = list() + # metadata_unique_values["classes"] = list(classes) - # keep track of unique labels in self._train_metadata["annotation"] - if key == "annotation": - for label in value.labels(): - self._train_metadata.setdefault("annotation", set()).add(label) + audios = list() # list of path to audio files + audio_infos = list() + audio_encodings = list() + metadata = list() # list of metadata - # pass "audio" entry as it is - elif key == "audio": - pass + annotated_duration = list() # total duration of annotated regions (per file) + annotated_regions = list() # annotated regions + annotations = list() # actual annotations + annotated_classes = list() # list of annotated classes (per file) + unique_labels = list() - # remove segments shorter than chunks from "annotated" entry - elif key == "annotated": - value = [ - segment for segment in value if segment.duration > self.duration - ] - file["_annotated_duration"] = sum( - segment.duration for segment in value + if self.has_validation: + files_iter = itertools.chain( + self.protocol.train(), self.protocol.development() + ) + else: + files_iter = self.protocol.train() + + for file_id, file in enumerate(files_iter): + + # gather metadata and update metadata_unique_values so that each metadatum + # (e.g. source database or label) is represented by an integer. + metadatum = dict() + + # keep track of source database and subset (train, development, or test) + if file["database"] not in metadata_unique_values["database"]: + metadata_unique_values["database"].append(file["database"]) + metadatum["database"] = metadata_unique_values["database"].index( + file["database"] + ) + metadatum["subset"] = Subsets.index(file["subset"]) + + # keep track of speaker label scope (file, database, or global) for speaker diarization protocols + if isinstance(self.protocol, SpeakerDiarizationProtocol): + metadatum["scope"] = Scopes.index(file["scope"]) + + # keep track of list of classes for regular segmentation protocols + # Different files may be annotated using a different set of classes + # (e.g. one database for speech/music/noise, and another one for male/female/child) + if isinstance(self.protocol, SegmentationProtocol): + + if "classes" in file: + local_classes = file["classes"] + else: + local_classes = file["annotation"].labels() + + # if task was not initialized with a fixed list of classes, + # we build it as the union of all classes found in files + if self.classes is None: + for klass in local_classes: + if klass not in classes: + classes.append(klass) + annotated_classes.append( + [classes.index(klass) for klass in local_classes] + ) + + # if task was initialized with a fixed list of classes, + # we make sure that all files use a subset of these classes + # if they don't, we issue a warning and ignore the extra classes + else: + extra_classes = set(local_classes) - set(self.classes) + if extra_classes: + warnings.warn( + f"Ignoring extra classes ({', '.join(extra_classes)}) found for file {file['uri']} ({file['database']}). " + ) + annotated_classes.append( + [ + self.classes.index(klass) + for klass in set(local_classes) & set(self.classes) + ] ) - # keey track of unique text-like entries (incl. "uri" and "database") - # and pass them as they are - elif isinstance(value, Text): - self._train_metadata.setdefault(key, set()).add(value) + remaining_metadata_keys = set(file) - set( + [ + "uri", + "database", + "subset", + "audio", + "torchaudio.info", + "scope", + "classes", + "annotation", + "annotated", + ] + ) + + # keep track of any other (integer or string) metadata provided by the protocol + # (e.g. a "domain" key for domain-adversarial training) + for key in remaining_metadata_keys: + + value = file[key] + + if isinstance(value, str): + if value not in metadata_unique_values[key]: + metadata_unique_values[key].append(value) + metadatum[key] = metadata_unique_values[key].index(value) - # pass score-like entries as they are - elif isinstance(value, SlidingWindowFeature): - pass + elif isinstance(value, int): + metadatum[key] = value else: - msg = ( - f"Protocol '{self.protocol.name}' defines a '{key}' entry of type {type(value)} " - f"which we do not know how to handle." + warnings.warn( + f"Ignoring '{key}' metadata because of its type ({type(value)}). Only str and int are supported for now.", + category=UserWarning, ) - warnings.warn(msg) - file[key] = value + metadata.append(metadatum) - self._train.append(file) + database_unique_labels = list() - self._train_metadata = { - key: sorted(values) for key, values in self._train_metadata.items() - } + # reset list of file-scoped labels + file_unique_labels = list() + + # path to audio file + audios.append(str(file["audio"])) + + # audio info + audio_info = file["torchaudio.info"] + audio_infos.append( + ( + audio_info.sample_rate, # sample rate + audio_info.num_frames, # number of frames + audio_info.num_channels, # number of channels + audio_info.bits_per_sample, # bits per sample + ) + ) + audio_encodings.append(audio_info.encoding) # encoding + + # annotated regions and duration + _annotated_duration = 0.0 + for segment in file["annotated"]: + + # skip annotated regions that are shorter than training chunk duration + if segment.duration < duration: + continue + + # append annotated region + annotated_region = ( + file_id, + segment.duration, + segment.start, + segment.end, + ) + annotated_regions.append(annotated_region) + + # increment annotated duration + _annotated_duration += segment.duration + + # append annotated duration + annotated_duration.append(_annotated_duration) + + # annotations + for segment, _, label in file["annotation"].itertracks(yield_label=True): + + # "scope" is provided by speaker diarization protocols to indicate + # whether speaker labels are local to the file ('file'), consistent across + # all files in a database ('database'), or globally consistent ('global') + + if "scope" in file: + + # 0 = 'file' + # 1 = 'database' + # 2 = 'global' + scope = Scopes.index(file["scope"]) + + # update list of file-scope labels + if label not in file_unique_labels: + file_unique_labels.append(label) + # and convert label to its (file-scope) index + file_label_idx = file_unique_labels.index(label) + + database_label_idx = global_label_idx = -1 + + if scope > 0: # 'database' or 'global' + + # update list of database-scope labels + if label not in database_unique_labels: + database_unique_labels.append(label) + + # and convert label to its (database-scope) index + database_label_idx = database_unique_labels.index(label) + + if scope > 1: # 'global' - # ================================================================== - # PREPARE VALIDATION DATA - # ================================================================== + # update list of global-scope labels + if label not in unique_labels: + unique_labels.append(label) + # and convert label to its (global-scope) index + global_label_idx = unique_labels.index(label) + + # basic segmentation protocols do not provide "scope" information + # as classes are global by definition + + else: + try: + file_label_idx = ( + database_label_idx + ) = global_label_idx = classes.index(label) + except ValueError: + # skip labels that are not in the list of classes + continue + + annotations.append( + ( + file_id, # index of file + segment.start, # start time + segment.end, # end time + file_label_idx, # file-scope label index + database_label_idx, # database-scope label index + global_label_idx, # global-scope index + ) + ) + + # since not all metadata keys are present in all files, fallback to -1 when a key is missing + metadata = [ + tuple(metadatum.get(key, -1) for key in metadata_unique_values) + for metadatum in metadata + ] + dtype = [(key, "i") for key in metadata_unique_values] + self.metadata = np.array(metadata, dtype=dtype) + + # NOTE: read with str(self.audios[file_id], encoding='utf-8') + self.audios = np.array(audios, dtype=np.string_) + + # turn list of files metadata into a single numpy array + # TODO: improve using https://github.com/pytorch/pytorch/issues/13246#issuecomment-617140519 + + dtype = [ + ("sample_rate", "i"), + ("num_frames", "i"), + ("num_channels", "i"), + ("bits_per_sample", "i"), + ] + self.audio_infos = np.array(audio_infos, dtype=dtype) + self.audio_encodings = np.array(audio_encodings, dtype=np.string_) + + self.annotated_duration = np.array(annotated_duration) + + # turn list of annotated regions into a single numpy array + dtype = [("file_id", "i"), ("duration", "f"), ("start", "f"), ("end", "f")] + self.annotated_regions = np.array(annotated_regions, dtype=dtype) + + # convert annotated_classes (which is a list of list of classes, one list of classes per file) + # into a single (num_files x num_classes) numpy array: + # * True indicates that this particular class was annotated for this particular file (though it may not be active in this file) + # * False indicates that this particular class was not even annotated (i.e. its absence does not imply that it is not active in this file) + if isinstance(self.protocol, SegmentationProtocol) and self.classes is None: + self.classes = classes + self.annotated_classes = np.zeros( + (len(annotated_classes), len(self.classes)), dtype=np.bool_ + ) + for file_id, classes in enumerate(annotated_classes): + self.annotated_classes[file_id, classes] = True + + # turn list of annotations into a single numpy array + dtype = [ + ("file_id", "i"), + ("start", "f"), + ("end", "f"), + ("file_label_idx", "i"), + ("database_label_idx", "i"), + ("global_label_idx", "i"), + ] + self.annotations = np.array(annotations, dtype=dtype) + + self.metadata_unique_values = metadata_unique_values if not self.has_validation: return - self._validation = [] + validation_chunks = list() - for f in self.protocol.development(): + # obtain indexes of files in the validation subset + validation_file_ids = np.where( + self.metadata["subset"] == Subsets.index("development") + )[0] - for segment in f["annotated"]: + # iterate over files in the validation subset + for file_id in validation_file_ids: - if segment.duration < self.duration: - continue + # get annotated regions in file + annotated_regions = self.annotated_regions[ + self.annotated_regions["file_id"] == file_id + ] - num_chunks = round(segment.duration // self.duration) + # iterate over annotated regions + for annotated_region in annotated_regions: - for c in range(num_chunks): - start_time = segment.start + c * self.duration - chunk = Segment(start_time, start_time + self.duration) - self._validation.append((f, chunk)) + # number of chunks in annotated region + num_chunks = round(annotated_region["duration"] // duration) - random.shuffle(self._validation) + # iterate over chunks + for c in range(num_chunks): + start_time = annotated_region["start"] + c * duration + validation_chunks.append((file_id, start_time, duration)) - def setup_loss_func(self): - if self.specifications.powerset: - self.model.powerset = Powerset( - len(self.specifications.classes), - self.specifications.powerset_max_classes, - ) + dtype = [("file_id", "i"), ("start", "f"), ("duration", "f")] + self.validation_chunks = np.array(validation_chunks, dtype=dtype) def default_metric( self, @@ -151,67 +418,16 @@ def default_metric( f"The {self.specifications.problem} problem type hasn't been given a default segmentation metric yet." ) - def adapt_y(self, one_hot_y: np.ndarray) -> np.ndarray: - raise NotImplementedError( - f"{self.__class__.__name__} must implement the `adapt_y` method." - ) - - def prepare_chunk( - self, - file: AudioFile, - chunk: Segment, - duration: float = None, - ) -> dict: - """Extract audio chunk and corresponding frame-wise labels - - Parameters - ---------- - file : AudioFile - Audio file. - chunk : Segment - Audio chunk. - duration : float, optional - Fix chunk duration to avoid rounding errors. Defaults to self.duration - - Returns - ------- - sample : dict - Dictionary with the following keys: - X : np.ndarray - Audio chunk as (num_samples, num_channels) array. - y : SlidingWindowFeature - Frame-wise labels as (num_frames, num_labels) array. - - """ - - sample = dict() - - # read (and resample if needed) audio chunk - duration = duration or self.duration - sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) - - # use model introspection to predict how many frames it will output - num_samples = sample["X"].shape[1] - num_frames, _ = self.model.introspection(num_samples) - resolution = duration / num_frames - - # discretize annotation, using model resolution - sample["y"] = file["annotation"].discretize( - support=chunk, resolution=resolution, duration=duration - ) - - return sample - - def train__iter__helper(self, rng: random.Random, **domain_filter): + def train__iter__helper(self, rng: random.Random, **filters): """Iterate over training samples with optional domain filtering Parameters ---------- rng : random.Random Random number generator - domain_filter : dict, optional - When provided (as {domain_key: domain_value} dict), filter training files so that - only files such as file[domain_key] == domain_value are used for generating chunks. + filters : dict, optional + When provided (as {key: value} dict), filter training files so that + only files such as file[key] == value are used for generating chunks. Yields ------ @@ -219,37 +435,48 @@ def train__iter__helper(self, rng: random.Random, **domain_filter): Training chunks. """ - train = self._train + # indices of training files that matches domain filters + training = self.metadata["subset"] == Subsets.index("train") + for key, value in filters.items(): + training &= self.metadata[key] == value + file_ids = np.where(training)[0] + + # turn annotated duration into a probability distribution + annotated_duration = self.annotated_duration[file_ids] + prob_annotated_duration = annotated_duration / np.sum(annotated_duration) - try: - domain_key, domain_value = domain_filter.popitem() - except KeyError: - domain_key = None + duration = self.duration - if domain_key is not None: - train = [f for f in train if f[domain_key] == domain_value] + num_chunks_per_file = getattr(self, "num_chunks_per_file", 1) while True: # select one file at random (with probability proportional to its annotated duration) - file, *_ = rng.choices( - train, - weights=[f["_annotated_duration"] for f in train], - k=1, - ) + file_id = np.random.choice(file_ids, p=prob_annotated_duration) - # select one annotated region at random (with probability proportional to its duration) - segment, *_ = rng.choices( - file["annotated"], - weights=[s.duration for s in file["annotated"]], - k=1, - ) + # generate `num_chunks_per_file` chunks from this file + for _ in range(num_chunks_per_file): - # select one chunk at random (with uniform distribution) - start_time = rng.uniform(segment.start, segment.end - self.duration) - chunk = Segment(start_time, start_time + self.duration) + # find indices of annotated regions in this file + annotated_region_indices = np.where( + self.annotated_regions["file_id"] == file_id + )[0] - yield self.prepare_chunk(file, chunk, duration=self.duration) + # turn annotated regions duration into a probability distribution + prob_annotated_regions_duration = self.annotated_regions["duration"][ + annotated_region_indices + ] / np.sum(self.annotated_regions["duration"][annotated_region_indices]) + + # selected one annotated region at random (with probability proportional to its duration) + annotated_region_index = np.random.choice( + annotated_region_indices, p=prob_annotated_regions_duration + ) + + # select one chunk at random in this annotated region + _, _, start, end = self.annotated_regions[annotated_region_index] + start_time = rng.uniform(start, end - duration) + + yield self.prepare_chunk(file_id, start_time, duration) def train__iter__(self): """Iterate over training samples @@ -274,16 +501,20 @@ def train__iter__(self): chunks = self.train__iter__helper(rng) else: - chunks_by_domain = { - domain: self.train__iter__helper(rng, **{balance: domain}) - for domain in self._train_metadata[balance] - } + # create a subchunk generator for each combination of "balance" keys + subchunks = dict() + for product in itertools.product( + [self.metadata_unique_values[key] for key in balance] + ): + filters = {key: value for key, value in zip(balance, product)} + subchunks[product] = self.train__iter__helper(rng, **filters) while True: + # select one subchunk generator at random (with uniform probability) + # so that it is balanced on average if balance is not None: - domain = rng.choice(self._train_metadata[balance]) - chunks = chunks_by_domain[domain] + chunks = subchunks[rng.choice(subchunks)] # generate random chunk yield next(chunks) @@ -292,30 +523,10 @@ def collate_X(self, batch) -> torch.Tensor: return default_collate([b["X"] for b in batch]) def collate_y(self, batch) -> torch.Tensor: + return default_collate([b["y"].data for b in batch]) - # gather common set of labels - # b["y"] is a SlidingWindowFeature instance - labels = sorted(set(itertools.chain(*(b["y"].labels for b in batch)))) - num_labels = len(labels) - - batch_size = len(batch) - num_frames = len(batch[0]["y"]) - - if num_labels == 0: - return torch.from_numpy( - np.zeros((batch_size, num_frames, 1), dtype=np.int64) - ) - - Y = np.zeros((batch_size, num_frames, num_labels), dtype=np.int64) - for i, b in enumerate(batch): - for local_idx, label in enumerate(b["y"].labels): - global_idx = labels.index(label) - Y[i, :, global_idx] = b["y"].data[:, local_idx] - - return torch.from_numpy(Y) - - def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor: - return collated_y + def collate_meta(self, batch) -> torch.Tensor: + return default_collate([b["meta"] for b in batch]) def collate_fn(self, batch, stage="train"): """Collate function used for most segmentation tasks @@ -343,6 +554,9 @@ def collate_fn(self, batch, stage="train"): # collate y collated_y = self.collate_y(batch) + # collate metadata + collated_meta = self.collate_meta(batch) + # apply augmentation (only in "train" stage) self.augmentation.train(mode=(stage == "train")) augmented = self.augmentation( @@ -351,19 +565,28 @@ def collate_fn(self, batch, stage="train"): targets=collated_y.unsqueeze(1), ) - return {"X": augmented.samples, "y": self.adapt_y(augmented.targets.squeeze(1))} + return { + "X": augmented.samples, + "y": augmented.targets.squeeze(1), + "meta": collated_meta, + } def train__len__(self): # Number of training samples in one epoch - duration = sum(file["_annotated_duration"] for file in self._train) + + duration = np.sum(self.annotated_duration) return max(self.batch_size, math.ceil(duration / self.duration)) def val__getitem__(self, idx): - f, chunk = self._validation[idx] - return self.prepare_chunk(f, chunk, duration=self.duration) + validation_chunk = self.validation_chunks[idx] + return self.prepare_chunk( + validation_chunk["file_id"], + validation_chunk["start"], + duration=validation_chunk["duration"], + ) def val__len__(self): - return len(self._validation) + return len(self.validation_chunks) def validation_step(self, batch, batch_idx: int): """Compute validation area under the ROC curve @@ -384,12 +607,10 @@ def validation_step(self, batch, batch_idx: int): _, num_frames, _ = y_pred.shape # y_pred = (batch_size, num_frames, num_classes) - # compute warmup frames boundaries and weight - warm_up_left = round(self.warm_up[0] / self.duration * num_frames) - warm_up_right = round(self.warm_up[1] / self.duration * num_frames) - # - remove warm-up frames # - downsample remaining frames + warm_up_left = round(self.warm_up[0] / self.duration * num_frames) + warm_up_right = round(self.warm_up[1] / self.duration * num_frames) preds = y_pred[:, warm_up_left : num_frames - warm_up_right : 10] target = y[:, warm_up_left : num_frames - warm_up_right : 10] @@ -397,6 +618,7 @@ def validation_step(self, batch, batch_idx: int): # pyannote.audio is more explicit so we have to reshape target and preds for # torchmetrics to be happy... more details can be found here: # https://torchmetrics.readthedocs.io/en/latest/references/modules.html#input-types + if self.specifications.problem == Problem.BINARY_CLASSIFICATION: # target: shape (batch_size, num_frames), type binary # preds: shape (batch_size, num_frames, 1), type float diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 20632b619..603d04ac6 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -20,12 +20,14 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -import warnings -from typing import Dict, Optional, Sequence, Text, Tuple, Union, List +from typing import Dict, List, Optional, Sequence, Text, Tuple, Union import numpy as np import torch +import torch.nn.functional as F +from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature from pyannote.database import Protocol +from pyannote.database.protocol import SegmentationProtocol from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric @@ -93,6 +95,12 @@ def __init__( augmentation: BaseWaveformTransform = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): + + if not isinstance(protocol, SegmentationProtocol): + raise ValueError( + f"MultiLabelSegmentation task expects a SegmentationProtocol but you gave {type(protocol)}. " + ) + super().__init__( protocol, duration=duration, @@ -116,42 +124,160 @@ def setup(self, stage: Optional[str] = None): super().setup(stage=stage) - classes_from_training_set = sorted(self._train_metadata["annotation"]) - if self.classes is None: - classes = classes_from_training_set - else: - if set(classes_from_training_set) != set(self.classes): - warnings.warn( - f"Mismatch between classes passed to the task ({self.classes}) " - f"and those of the training set ({classes_from_training_set})." - ) - classes = self.classes - self.specifications = Specifications( - classes=classes, + classes=self.classes, problem=Problem.MULTI_LABEL_CLASSIFICATION, resolution=Resolution.FRAME, duration=self.duration, warm_up=self.warm_up, ) - def collate_y(self, batch) -> torch.Tensor: + def prepare_chunk(self, file_id: int, start_time: float, duration: float): + """Prepare chunk for multi-label segmentation + + Parameters + ---------- + file_id : int + File index + start_time : float + Chunk start time + duration : float + Chunk duration. + + Returns + ------- + sample : dict + Dictionary containing the chunk data with the following keys: + - `X`: waveform + - `y`: target (see Notes below) + - `meta`: + - `database`: database index + - `file`: file index + + Notes + ----- + y is a trinary matrix with shape (num_frames, num_classes): + - 0: class is inactive + - 1: class is active + - -1: we have no idea + + """ + + file = self.get_file(file_id) + + chunk = Segment(start_time, start_time + duration) + + sample = dict() + sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) + + # TODO: this should be cached + # use model introspection to predict how many frames it will output + num_samples = sample["X"].shape[1] + num_frames, _ = self.model.introspection(num_samples) + resolution = duration / num_frames + frames = SlidingWindow(start=0.0, duration=resolution, step=resolution) + + # gather all annotations of current file + annotations = self.annotations[self.annotations["file_id"] == file_id] + + # gather all annotations with non-empty intersection with current chunk + chunk_annotations = annotations[ + (annotations["start"] < chunk.end) & (annotations["end"] > chunk.start) + ] + + # discretize chunk annotations at model output resolution + start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start + start_idx = np.floor(start / resolution).astype(np.int) + end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start + end_idx = np.ceil(end / resolution).astype(np.int) + + # frame-level targets (-1 for un-annotated classes) + y = -np.ones((num_frames, len(self.classes)), dtype=np.int8) + y[:, self.annotated_classes[file_id]] = 0 + for start, end, label in zip( + start_idx, end_idx, chunk_annotations["global_label_idx"] + ): + y[start:end, label] = 1 + + sample["y"] = SlidingWindowFeature(y, frames, labels=self.classes) + + metadata = self.metadata[file_id] + sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} + sample["meta"]["file"] = file_id + + return sample + + def training_step(self, batch, batch_idx: int): + + X = batch["X"] + y_pred = self.model(X) + y_true = batch["y"] + assert y_pred.shape == y_true.shape + + # TODO: add support for frame weights + # TODO: add support for class weights + + # mask (frame, class) index for which label is missing + mask: torch.Tensor = y_true != -1 + y_pred = y_pred[mask] + y_true = y_true[mask] + loss = F.binary_cross_entropy(y_pred, y_true.type(torch.float)) + + self.model.log( + f"{self.logging_prefix}TrainLoss", + loss, + on_step=False, + on_epoch=True, + prog_bar=True, + logger=True, + ) + return {"loss": loss} + + def validation_step(self, batch, batch_idx: int): + + X = batch["X"] + y_pred = self.model(X) + y_true = batch["y"] + assert y_pred.shape == y_true.shape + + # TODO: add support for frame weights + # TODO: add support for class weights - labels = self.specifications.classes + # TODO: compute metrics for each class separately - batch_size, num_frames, num_labels = ( - len(batch), - len(batch[0]["y"]), - len(labels), + # mask (frame, class) index for which label is missing + mask: torch.Tensor = y_true != -1 + y_pred = y_pred[mask] + y_true = y_true[mask] + loss = F.binary_cross_entropy(y_pred, y_true.type(torch.float)) + + self.model.log( + f"{self.logging_prefix}ValLoss", + loss, + on_step=False, + on_epoch=True, + prog_bar=True, + logger=True, ) - Y = np.zeros((batch_size, num_frames, num_labels), dtype=np.int64) + return {"loss": loss} + + @property + def val_monitor(self): + """Quantity (and direction) to monitor + + Useful for model checkpointing or early stopping. - for i, b in enumerate(batch): - for local_idx, label in enumerate(b["y"].labels): - global_idx = labels.index(label) - Y[i, :, global_idx] = b["y"].data[:, local_idx] + Returns + ------- + monitor : str + Name of quantity to monitor. + mode : {'min', 'max} + Minimize - return torch.from_numpy(Y) + See also + -------- + pytorch_lightning.callbacks.ModelCheckpoint + pytorch_lightning.callbacks.EarlyStopping + """ - # TODO: add option to give more weights to smaller classes - # TODO: add option to balance training samples between classes + return f"{self.logging_prefix}ValLoss", "min" diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index 8b29ffbf4..f0bebbb13 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -23,7 +23,8 @@ from typing import Dict, Sequence, Text, Tuple, Union -import torch +import numpy as np +from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature from pyannote.database import Protocol from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric @@ -131,20 +132,67 @@ def __init__( self.balance = balance self.weight = weight - def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor: - """Get overlapped speech detection targets + def prepare_chunk(self, file_id: int, start_time: float, duration: float): + """Prepare chunk for overlapped speech detection Parameters ---------- - collated_y : (batch_size, num_frames, num_speakers) tensor - One-hot-encoding of current chunk speaker activity: - * collated_y[b, f, s] = 1 if sth speaker is active at fth frame - * collated_y[b, f, s] = 0 otherwise. + file_id : int + File index + start_time : float + Chunk start time + duration : float + Chunk duration. Returns ------- - y : (batch_size, num_frames, ) np.ndarray - y[b, f] = 1 if there is two or more active speakers at fth frame, 0 otherwise. + sample : dict + Dictionary containing the chunk data with the following keys: + - `X`: waveform + - `y`: target as a SlidingWindowFeature instance + - `meta`: + - `database`: database index + - `file`: file index """ - return 1 * (torch.sum(collated_y, dim=2, keepdim=False) > 1) + file = self.get_file(file_id) + + chunk = Segment(start_time, start_time + duration) + + sample = dict() + sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) + + # use model introspection to predict how many frames it will output + # TODO: this should be cached + num_samples = sample["X"].shape[1] + num_frames, _ = self.model.introspection(num_samples) + resolution = duration / num_frames + frames = SlidingWindow(start=0.0, duration=resolution, step=resolution) + + # gather all annotations of current file + annotations = self.annotations[self.annotations["file_id"] == file_id] + + # gather all annotations with non-empty intersection with current chunk + chunk_annotations = annotations[ + (annotations["start"] < chunk.end) & (annotations["end"] > chunk.start) + ] + + # discretize chunk annotations at model output resolution + start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start + start_idx = np.floor(start / resolution).astype(np.int) + end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start + end_idx = np.ceil(end / resolution).astype(np.int) + + # frame-level targets + y = np.zeros((num_frames, 1), dtype=np.uint8) + for start, end in zip(start_idx, end_idx): + y[start:end, 0] += 1 + y = 1 * (y > 1) + + sample["y"] = SlidingWindowFeature(y, frames, labels=["speech"]) + + metadata = self.metadata[file_id] + sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} + sample["meta"]["file"] = file_id + + return sample diff --git a/pyannote/audio/tasks/segmentation/segmentation.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py similarity index 74% rename from pyannote/audio/tasks/segmentation/segmentation.py rename to pyannote/audio/tasks/segmentation/speaker_diarization.py index 715cfc646..0ab5d6ae9 100644 --- a/pyannote/audio/tasks/segmentation/segmentation.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -29,9 +29,11 @@ import torch import torch.nn.functional from matplotlib import pyplot as plt -from pyannote.core import SlidingWindow -from pyannote.database import Protocol +from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature +from pyannote.database.protocol import SpeakerDiarizationProtocol +from pyannote.database.protocol.protocol import Scope, Subset from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger +from rich.progress import track from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric from typing_extensions import Literal @@ -51,14 +53,18 @@ ) from pyannote.audio.utils.loss import binary_cross_entropy, mse_loss, nll_loss from pyannote.audio.utils.permutation import permutate +from pyannote.audio.utils.powerset import Powerset +Subsets = list(Subset.__args__) +Scopes = list(Scope.__args__) -class Segmentation(SegmentationTaskMixin, Task): - """Speaker segmentation + +class SpeakerDiarization(SegmentationTaskMixin, Task): + """Speaker diarization Parameters ---------- - protocol : Protocol + protocol : SpeakerDiarizationProtocol pyannote.database protocol duration : float, optional Chunks duration. Defaults to 2s. @@ -83,8 +89,8 @@ class Segmentation(SegmentationTaskMixin, Task): Defaults to 0. (i.e. no warm-up). balance: str, optional When provided, training samples are sampled uniformly with respect to that key. - For instance, setting `balance` to "uri" will make sure that each file will be - equally represented in the training samples. + For instance, setting `balance` to "database" will make sure that each database + will be equally represented in the training samples. weight: str, optional When provided, use this key as frame-wise weight in loss function. batch_size : int, optional @@ -121,7 +127,7 @@ class Segmentation(SegmentationTaskMixin, Task): def __init__( self, - protocol: Protocol, + protocol: SpeakerDiarizationProtocol, duration: float = 2.0, max_speakers_per_chunk: int = None, max_speakers_per_frame: int = None, @@ -150,6 +156,11 @@ def __init__( metric=metric, ) + if not isinstance(protocol, SpeakerDiarizationProtocol): + raise ValueError( + "SpeakerDiarization task requires a SpeakerDiarizationProtocol." + ) + # deprecation warnings if max_speakers_per_chunk is None and max_num_speakers is not None: max_speakers_per_chunk = max_num_speakers @@ -181,38 +192,76 @@ def setup(self, stage: Optional[str] = None): super().setup(stage=stage) + # estimate maximum number of speakers per chunk when not provided if self.max_speakers_per_chunk is None: - # TODO: optimize this - - # slide a window (with 1s step) over the whole training set - # and keep track of the number of speakers in each location - num_speakers = [] - for file in self._train: - start = file["annotated"][0].start - end = file["annotated"][-1].end - window = SlidingWindow( - start=start, - end=end, - duration=self.duration, - step=1.0, - ) - for chunk in window: - num_speakers.append(len(file["annotation"].crop(chunk).labels())) + training = self.metadata["subset"] == Subsets.index("train") + + num_unique_speakers = [] + progress_description = f"Estimating maximum number of speakers per {self.duration:g}s chunk in the training set" + for file_id in track( + np.where(training)[0], description=progress_description + ): + + annotations = self.annotations[ + np.where(self.annotations["file_id"] == file_id)[0] + ] + annotated_regions = self.annotated_regions[ + np.where(self.annotated_regions["file_id"] == file_id)[0] + ] + for region in annotated_regions: + # find annotations within current region + region_start = region["start"] + region_end = region["end"] + region_annotations = annotations[ + np.where( + (annotations["start"] >= region_start) + * (annotations["end"] <= region_end) + )[0] + ] + + for window_start in np.arange( + region_start, region_end - self.duration, 0.25 * self.duration + ): + window_end = window_start + self.duration + window_annotations = region_annotations[ + np.where( + (region_annotations["start"] <= window_end) + * (region_annotations["end"] >= window_start) + )[0] + ] + num_unique_speakers.append( + len(np.unique(window_annotations["file_label_idx"])) + ) # because there might a few outliers, estimate the upper bound for the - # number of speakers as the 99th percentile + # number of speakers as the 97th percentile - num_speakers, counts = zip(*list(Counter(num_speakers).items())) + num_speakers, counts = zip(*list(Counter(num_unique_speakers).items())) num_speakers, counts = np.array(num_speakers), np.array(counts) sorting_indices = np.argsort(num_speakers) num_speakers = num_speakers[sorting_indices] counts = counts[sorting_indices] + ratios = np.cumsum(counts) / np.sum(counts) + + for k, ratio in zip(num_speakers, ratios): + if k == 0: + print(f" - {ratio:7.2%} of all chunks contain no speech at all.") + elif k == 1: + print(f" - {ratio:7.2%} contain 1 speaker or less") + else: + print(f" - {ratio:7.2%} contain {k} speakers or less") + self.max_speakers_per_chunk = max( 2, - num_speakers[np.where(np.cumsum(counts) / np.sum(counts) > 0.99)[0][0]], + num_speakers[np.where(ratios > 0.97)[0][0]], + ) + + print( + f"Setting `max_speakers_per_chunk` to {self.max_speakers_per_chunk}. " + f"You can override this value (or avoid this estimation step) by passing `max_speakers_per_chunk={self.max_speakers_per_chunk}` to the task constructor." ) if ( @@ -238,42 +287,143 @@ def setup(self, stage: Optional[str] = None): permutation_invariant=True, ) - def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor: - """Get speaker diarization targets + def setup_loss_func(self): + if self.specifications.powerset: + self.model.powerset = Powerset( + len(self.specifications.classes), + self.specifications.powerset_max_classes, + ) + + def prepare_chunk(self, file_id: int, start_time: float, duration: float): + """Prepare chunk Parameters ---------- - collated_y : (batch_size, num_frames, num_speakers) tensor - One-hot-encoding of current chunk speaker activity: - * one_hot_y[b, f, s] = 1 if sth speaker is active at fth frame - * one_hot_y[b, f, s] = 0 otherwise. + file_id : int + File index + start_time : float + Chunk start time + duration : float + Chunk duration. Returns ------- - y : (batch_size, num_frames, max_speakers_per_chunk) tensor - Same as collated_y, except we only keep ``max_speakers_per_chunk`` most - talkative speakers (per sample). + sample : dict + Dictionary containing the chunk data with the following keys: + - `X`: waveform + - `y`: target as a SlidingWindowFeature instance where y.labels is + in meta.scope space. + - `meta`: + - `scope`: target scope (0: file, 1: database, 2: global) + - `database`: database index + - `file`: file index """ - batch_size, num_frames, num_speakers = collated_y.shape + file = self.get_file(file_id) - # maximum number of active speakers in a chunk - max_speakers_per_chunk = max( - 1, torch.max(torch.sum(torch.sum(collated_y, dim=1) > 0.0, dim=1)) - ) + # get label scope + label_scope = Scopes[self.metadata[file_id]["scope"]] + label_scope_key = f"{label_scope}_label_idx" - # sort speakers in descending talkativeness order - indices = torch.argsort(torch.sum(collated_y, dim=1), dim=1, descending=True) + # + chunk = Segment(start_time, start_time + duration) - # keep max_speakers_per_chunk most talkative speakers, for each chunk - y = torch.zeros( - (batch_size, num_frames, max_speakers_per_chunk), dtype=collated_y.dtype - ) - for b, index in enumerate(indices): - for k, i in zip(range(max_speakers_per_chunk), index): - y[b, :, k] = collated_y[b, :, i.item()] + sample = dict() + sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) + + # use model introspection to predict how many frames it will output + # TODO: this should be cached + num_samples = sample["X"].shape[1] + num_frames, _ = self.model.introspection(num_samples) + resolution = duration / num_frames + frames = SlidingWindow(start=0.0, duration=resolution, step=resolution) + + # gather all annotations of current file + annotations = self.annotations[self.annotations["file_id"] == file_id] + + # gather all annotations with non-empty intersection with current chunk + chunk_annotations = annotations[ + (annotations["start"] < chunk.end) & (annotations["end"] > chunk.start) + ] - return y + # discretize chunk annotations at model output resolution + start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start + start_idx = np.floor(start / resolution).astype(np.int) + end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start + end_idx = np.ceil(end / resolution).astype(np.int) + + # get list and number of labels for current scope + labels = list(np.unique(chunk_annotations[label_scope_key])) + num_labels = len(labels) + + if num_labels > self.max_speakers_per_chunk: + pass + + # initial frame-level targets + y = np.zeros((num_frames, num_labels), dtype=np.uint8) + + # map labels to indices + mapping = {label: idx for idx, label in enumerate(labels)} + + for start, end, label in zip( + start_idx, end_idx, chunk_annotations[label_scope_key] + ): + mapped_label = mapping[label] + y[start:end, mapped_label] = 1 + + sample["y"] = SlidingWindowFeature(y, frames, labels=labels) + + metadata = self.metadata[file_id] + sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} + sample["meta"]["file"] = file_id + + return sample + + def collate_y(self, batch) -> torch.Tensor: + """ + + Parameters + ---------- + batch : list + List of samples to collate. + "y" field is expected to be a SlidingWindowFeature. + + Returns + ------- + y : torch.Tensor + Collated target tensor of shape (num_frames, self.max_speakers_per_chunk) + If one chunk has more than `self.max_speakers_per_chunk` speakers, we keep + the max_speakers_per_chunk most talkative ones. If it has less, we pad with + zeros (artificial inactive speakers). + """ + + collated_y = [] + for b in batch: + y = b["y"].data + num_speakers = len(b["y"].labels) + if num_speakers > self.max_speakers_per_chunk: + # sort speakers in descending talkativeness order + indices = np.argsort(-np.sum(y, axis=0), axis=0) + # keep only the most talkative speakers + y = y[:, indices[: self.max_speakers_per_chunk]] + + # TODO: we should also sort the speaker labels in the same way + + elif num_speakers < self.max_speakers_per_chunk: + # create inactive speakers by zero padding + y = np.pad( + y, + ((0, 0), (0, self.max_speakers_per_chunk - num_speakers)), + mode="constant", + ) + + else: + # we have exactly the right number of speakers + pass + + collated_y.append(y) + + return torch.from_numpy(np.stack(collated_y)) def segmentation_loss( self, @@ -509,15 +659,6 @@ def default_metric( OptimalFalseAlarmRate(), ] - def train__iter__(self): - for chunk in super().train__iter__(): - # TODO: document why this filtering is needed - if self.specifications.powerset: - if len(chunk["y"].labels) <= self.max_speakers_per_chunk: - yield chunk - else: - yield chunk - # TODO: no need to compute gradient in this method def validation_step(self, batch, batch_idx: int): """Compute validation loss and metric @@ -667,7 +808,7 @@ def validation_step(self, batch, batch_idx: int): # visualize first 9 validation samples of first batch in Tensorboard/MLflow if self.specifications.powerset: - y = permutated_target_powerset.float().cpu().numpy() + y = permutated_target.float().cpu().numpy() y_pred = multilabel.cpu().numpy() else: y = target.float().cpu().numpy() diff --git a/pyannote/audio/tasks/segmentation/voice_activity_detection.py b/pyannote/audio/tasks/segmentation/voice_activity_detection.py index b674911c6..69f47d04b 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -22,7 +22,8 @@ from typing import Dict, Sequence, Text, Tuple, Union -import torch +import numpy as np +from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature from pyannote.database import Protocol from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric @@ -113,20 +114,66 @@ def __init__( ], ) - def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor: - """Get voice activity detection targets + def prepare_chunk(self, file_id: int, start_time: float, duration: float): + """Prepare chunk for voice activity detection Parameters ---------- - collated_y : (batch_size, num_frames, num_speakers) tensor - One-hot-encoding of current chunk speaker activity: - * one_hot_y[b, f, s] = 1 if sth speaker is active at fth frame - * one_hot_y[b, f, s] = 0 otherwise. + file_id : int + File index + start_time : float + Chunk start time + duration : float + Chunk duration. Returns ------- - y : (batch_size, num_frames, ) tensor - y[b, f] = 1 if at least one speaker is active at fth frame, 0 otherwise. + sample : dict + Dictionary containing the chunk data with the following keys: + - `X`: waveform + - `y`: target as a SlidingWindowFeature instance + - `meta`: + - `database`: database index + - `file`: file index """ - return 1 * (torch.sum(collated_y, dim=2, keepdims=False) > 0) + file = self.get_file(file_id) + + chunk = Segment(start_time, start_time + duration) + + sample = dict() + sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) + + # use model introspection to predict how many frames it will output + # TODO: this should be cached + num_samples = sample["X"].shape[1] + num_frames, _ = self.model.introspection(num_samples) + resolution = duration / num_frames + frames = SlidingWindow(start=0.0, duration=resolution, step=resolution) + + # gather all annotations of current file + annotations = self.annotations[self.annotations["file_id"] == file_id] + + # gather all annotations with non-empty intersection with current chunk + chunk_annotations = annotations[ + (annotations["start"] < chunk.end) & (annotations["end"] > chunk.start) + ] + + # discretize chunk annotations at model output resolution + start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start + start_idx = np.floor(start / resolution).astype(np.int) + end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start + end_idx = np.ceil(end / resolution).astype(np.int) + + # frame-level targets + y = np.zeros((num_frames, 1), dtype=np.uint8) + for start, end in zip(start_idx, end_idx): + y[start:end, 0] = 1 + + sample["y"] = SlidingWindowFeature(y, frames, labels=["speech"]) + + metadata = self.metadata[file_id] + sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} + sample["meta"]["file"] = file_id + + return sample diff --git a/pyannote/audio/utils/protocol.py b/pyannote/audio/utils/protocol.py index c98c4fdb5..a9646c5a1 100644 --- a/pyannote/audio/utils/protocol.py +++ b/pyannote/audio/utils/protocol.py @@ -40,7 +40,10 @@ def check_protocol(protocol: Protocol) -> Protocol: Returns ------- fixed_protocol : Protocol - has_validation : bool + checks: dict + has_validation : bool + has_scope : bool + has_classes : bool Raises ------ @@ -108,6 +111,9 @@ def check_protocol(protocol: Protocol) -> Protocol: ) print(msg) + has_scope = "scope" in file + has_classes = "classes" in file + # does protocol define a validation set? if isinstance(protocol, SpeakerVerificationProtocol): validation_method = "development_trial" @@ -121,4 +127,10 @@ def check_protocol(protocol: Protocol) -> Protocol: else: has_validation = True - return protocol, has_validation + checks = { + "has_validation": has_validation, + "has_scope": has_scope, + "has_classes": has_classes, + } + + return protocol, checks diff --git a/requirements.txt b/requirements.txt index b2d000a27..14c07fb7f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,7 +6,7 @@ huggingface_hub >= 0.8.1 networkx >= 2.6,<3.0 omegaconf >=2.1,<3.0 pyannote.core >=4.4,<5.0 -pyannote.database >=4.1.1,<5.0 +pyannote.database >=5.0,<6.0 pyannote.metrics >=3.2,<4.0 pyannote.pipeline >=2.3,<3.0 pytorch_lightning >=1.8.0,<1.9 diff --git a/tests/tasks/test_reproducibility.py b/tests/tasks/test_reproducibility.py index 912548827..5eab714bc 100644 --- a/tests/tasks/test_reproducibility.py +++ b/tests/tasks/test_reproducibility.py @@ -1,9 +1,9 @@ -from lightning_lite.utilities.seed import seed_everything import torch +from lightning_lite.utilities.seed import seed_everything +from pyannote.database import FileFinder, get_protocol from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel from pyannote.audio.tasks import MultiLabelSegmentation, VoiceActivityDetection -from pyannote.database import FileFinder, get_protocol def setup_tasks(task): @@ -30,13 +30,15 @@ def get_next5(dl): def test_seeding_ensures_data_loaders(): "Setting a global seed for the dataloaders ensures that we get data back in the same order" - seed_everything(1) for task in [VoiceActivityDetection, MultiLabelSegmentation]: + + seed_everything(1) protocol, vad = setup_tasks(task) dl = create_dl(SimpleSegmentationModel, vad) last5a = get_next5(dl) + seed_everything(1) protocol, vad = setup_tasks(task) dl = create_dl(SimpleSegmentationModel, vad) last5b = get_next5(dl) diff --git a/tests/test_train.py b/tests/test_train.py index e75a79eae..79e7f071a 100644 --- a/tests/test_train.py +++ b/tests/test_train.py @@ -1,13 +1,13 @@ import pytest +from pyannote.database import FileFinder, get_protocol from pytorch_lightning import Trainer from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel from pyannote.audio.tasks import ( OverlappedSpeechDetection, - Segmentation, + SpeakerDiarization, VoiceActivityDetection, ) -from pyannote.database import FileFinder, get_protocol @pytest.fixture() @@ -18,7 +18,7 @@ def protocol(): def test_train_segmentation(protocol): - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) trainer = Trainer(fast_dev_run=True) trainer.fit(model) @@ -51,12 +51,12 @@ def test_finetune_with_task_that_does_not_need_setup_for_specs(protocol): def test_finetune_with_task_that_needs_setup_for_specs(protocol): - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) trainer = Trainer(fast_dev_run=True) trainer.fit(model) - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model.task = segmentation trainer = Trainer(fast_dev_run=True) trainer.fit(model) @@ -64,7 +64,7 @@ def test_finetune_with_task_that_needs_setup_for_specs(protocol): def test_transfer_with_task_that_does_not_need_setup_for_specs(protocol): - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) trainer = Trainer(fast_dev_run=True) trainer.fit(model) @@ -82,7 +82,7 @@ def test_transfer_with_task_that_needs_setup_for_specs(protocol): trainer = Trainer(fast_dev_run=True) trainer.fit(model) - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model.task = segmentation trainer = Trainer(fast_dev_run=True) trainer.fit(model) @@ -90,12 +90,12 @@ def test_transfer_with_task_that_needs_setup_for_specs(protocol): def test_finetune_freeze_with_task_that_needs_setup_for_specs(protocol): - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) trainer = Trainer(fast_dev_run=True) trainer.fit(model) - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model.task = segmentation model.freeze_up_to("mfcc") trainer = Trainer(fast_dev_run=True) @@ -118,7 +118,7 @@ def test_finetune_freeze_with_task_that_does_not_need_setup_for_specs(protocol): def test_transfer_freeze_with_task_that_does_not_need_setup_for_specs(protocol): - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) trainer = Trainer(fast_dev_run=True) trainer.fit(model) @@ -137,7 +137,7 @@ def test_transfer_freeze_with_task_that_needs_setup_for_specs(protocol): trainer = Trainer(fast_dev_run=True) trainer.fit(model) - segmentation = Segmentation(protocol) + segmentation = SpeakerDiarization(protocol) model.task = segmentation model.freeze_up_to("mfcc") trainer = Trainer(fast_dev_run=True) diff --git a/tutorials/adapting_pretrained_pipeline.ipynb b/tutorials/adapting_pretrained_pipeline.ipynb index 325d939a9..7bfe73b8d 100644 --- a/tutorials/adapting_pretrained_pipeline.ipynb +++ b/tutorials/adapting_pretrained_pipeline.ipynb @@ -1,29 +1,10 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [], - "toc_visible": true, - "authorship_tag": "ABX9TyMc87txSanOjHXPQP0Zpu9J", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - }, - "accelerator": "GPU", - "gpuClass": "standard" - }, "cells": [ { "cell_type": "markdown", "metadata": { - "id": "view-in-github", - "colab_type": "text" + "colab_type": "text", + "id": "view-in-github" }, "source": [ "\"Open" @@ -31,6 +12,9 @@ }, { "cell_type": "markdown", + "metadata": { + "id": "npzkG4poB2BH" + }, "source": [ "# Adapting pyannote.audio 2.1 pretrained speaker diarization pipeline to your own data\n", "\n", @@ -41,31 +25,28 @@ "Version 2.1 introduces a major overhaul of the default speaker diarization pipeline, made of three main stages: speaker segmentation applied to a short sliding window, neural speaker embedding of each (local) speakers, and (global) agglomerative clustering.\n", "\n", "Despite its decent out-of-the-box performance, the default pipeline may suffer from the domain mismatch problem (common to most machine learning models) and not perform well on your own data. This tutorial will guide you through two recipes to adapt it to your own data and (hopefully) get better performance. Depending on the number and duration of labeled conversations, you may either focus on optimizing hyper-parameters or additionally fine-tune the internal speaker segmentation model." - ], - "metadata": { - "id": "npzkG4poB2BH" - } + ] }, { "cell_type": "markdown", + "metadata": { + "id": "pnaQ4JSLF8Ms" + }, "source": [ "⚠ Make sure that you switch to a GPU runtime (Runtime > Change runtime type). \n", "If you don't, everything will be extremely slow." - ], - "metadata": { - "id": "pnaQ4JSLF8Ms" - } + ] }, { "cell_type": "markdown", + "metadata": { + "id": "CZjbjOBBDrdm" + }, "source": [ "## Installation\n", "\n", "Let's start by installing `pyannote.audio` 2.1.1 (and `rich` for pretty progress bars)." - ], - "metadata": { - "id": "CZjbjOBBDrdm" - } + ] }, { "cell_type": "code", @@ -81,47 +62,45 @@ }, { "cell_type": "markdown", + "metadata": { + "id": "ndQ10VIf2W1c" + }, "source": [ "⚠ Restart the runtime (Runtime > Restart runtime). \n", "If you don't, `pyannote.database` will throw an error below." - ], - "metadata": { - "id": "ndQ10VIf2W1c" - } + ] }, { "cell_type": "markdown", + "metadata": { + "id": "lz-b8j6RD7H6" + }, "source": [ "## Data preparation\n", "\n", "First things first: we need data... Annotated data! Ideally, lots of annotated data! \n", "\n", "For the purpose of this tutorial, we will rely on the AMI-SDM (single distance microphone) corpus. \n" - ], - "metadata": { - "id": "lz-b8j6RD7H6" - } + ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "uSQVKFDC0cOe" + }, + "outputs": [], "source": [ "# download AMI-SDM mini corpus\n", "%cd /content/\n", "!git clone https://github.com/pyannote/AMI-diarization-setup\n", "%cd /content/AMI-diarization-setup/pyannote/\n", "!bash download_ami_sdm_mini.sh" - ], - "metadata": { - "id": "uSQVKFDC0cOe" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", - "source": [ - "!PYANNOTE_DATABASE_CONFIG=\"/content/AMI-diarization-setup/pyannote/database.yml\" pyannote-database info AMI-SDM.SpeakerDiarization.mini" - ], + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -129,11 +108,10 @@ "id": "wTKkOeMr2QUL", "outputId": "d9cc39fd-4cc2-44fe-a922-533370221d31" }, - "execution_count": 9, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\u001b[92m\u001b[1m\u001b[4mtrain\u001b[0m\n", " 28 files\n", @@ -152,35 +130,41 @@ " 12 speakers\n" ] } + ], + "source": [ + "!PYANNOTE_DATABASE_CONFIG=\"/content/AMI-diarization-setup/pyannote/database.yml\" pyannote-database info AMI-SDM.SpeakerDiarization.mini" ] }, { "cell_type": "markdown", + "metadata": { + "id": "09LrQFIfp0zC" + }, "source": [ "Note that we use a \"mini\" version of AMI-SDM so that the tutorial can be run in half an hour but the full version is also available for you to get better results. \n", "\n", "If you want to try it, replace `download_ami_sdm_mini.sh` by `download_ami_sdm.sh` and `AMI-SDM.SpeakerDiarization.mini` by `AMI-SDM.SpeakerDiarization.only_words` and you are good to go! " - ], - "metadata": { - "id": "09LrQFIfp0zC" - } + ] }, { "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "l6V8Exw41XBp" + }, + "outputs": [], "source": [ "import os\n", "os.environ[\"PYANNOTE_DATABASE_CONFIG\"] = \"/content/AMI-diarization-setup/pyannote/database.yml\"\n", "from pyannote.database import get_protocol, FileFinder\n", "dataset = get_protocol(\"AMI-SDM.SpeakerDiarization.mini\", {\"audio\": FileFinder()})" - ], - "metadata": { - "id": "l6V8Exw41XBp" - }, - "execution_count": 10, - "outputs": [] + ] }, { "cell_type": "markdown", + "metadata": { + "id": "HivpZEgZEVAu" + }, "source": [ "## Pretrained pipeline\n", "\n", @@ -192,51 +176,35 @@ "* visit [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization) and accept the terms\n", "* visit [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation) (used internally by the speaker diarization pipeline)and accept the terms\n", "* log in using `notebook_login`" - ], - "metadata": { - "id": "HivpZEgZEVAu" - } + ] }, { "cell_type": "code", - "source": [ - "from huggingface_hub import notebook_login\n", - "notebook_login()" - ], + "execution_count": null, "metadata": { "id": "FbXEQUGXscTQ" }, - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "from huggingface_hub import notebook_login\n", + "notebook_login()" + ] }, { "cell_type": "code", - "source": [ - "from pyannote.audio import Pipeline\n", - "pretrained_pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization\", use_auth_token=True) " - ], + "execution_count": 11, "metadata": { "id": "l7eN_Y792Cxt" }, - "execution_count": 11, - "outputs": [] + "outputs": [], + "source": [ + "from pyannote.audio import Pipeline\n", + "pretrained_pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization\", use_auth_token=True) " + ] }, { "cell_type": "code", - "source": [ - "# this takes approximately 2min to run on Google Colab GPU\n", - "from pyannote.metrics.diarization import DiarizationErrorRate\n", - "metric = DiarizationErrorRate()\n", - "\n", - "for file in dataset.test():\n", - " # apply pretrained pipeline\n", - " file[\"pretrained pipeline\"] = pretrained_pipeline(file)\n", - "\n", - " # evaluate its performance\n", - " metric(file[\"annotation\"], file[\"pretrained pipeline\"], uem=file[\"annotated\"])\n", - "\n", - "print(f\"The pretrained pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")" - ], + "execution_count": 32, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -244,22 +212,33 @@ "id": "lDIIp7iaICUC", "outputId": "b4880a85-692b-470d-f133-d95128bdecd9" }, - "execution_count": 32, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "The pretrained pipeline reaches a Diarization Error Rate (DER) of 32.5% on AMI-SDM.SpeakerDiarization.mini test set.\n" ] } + ], + "source": [ + "# this takes approximately 2min to run on Google Colab GPU\n", + "from pyannote.metrics.diarization import DiarizationErrorRate\n", + "metric = DiarizationErrorRate()\n", + "\n", + "for file in dataset.test():\n", + " # apply pretrained pipeline\n", + " file[\"pretrained pipeline\"] = pretrained_pipeline(file)\n", + "\n", + " # evaluate its performance\n", + " metric(file[\"annotation\"], file[\"pretrained pipeline\"], uem=file[\"annotated\"])\n", + "\n", + "print(f\"The pretrained pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")" ] }, { "cell_type": "code", - "source": [ - "file[\"annotation\"]" - ], + "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -268,26 +247,26 @@ "id": "r4UydYQkKsxW", "outputId": "7069d8e5-7dc7-4701-bcd5-1663998cfd1d" }, - "execution_count": 13, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, + "execution_count": 13, "metadata": {}, - "execution_count": 13 + "output_type": "execute_result" } + ], + "source": [ + "file[\"annotation\"]" ] }, { "cell_type": "code", - "source": [ - "file[\"pretrained pipeline\"]" - ], + "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -296,86 +275,94 @@ "id": "s4C7xMQlKwVX", "outputId": "930c571f-069b-44ad-f87e-ce8d471176a6" }, - "execution_count": 14, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, + "execution_count": 14, "metadata": {}, - "execution_count": 14 + "output_type": "execute_result" } + ], + "source": [ + "file[\"pretrained pipeline\"]" ] }, { "cell_type": "markdown", + "metadata": { + "id": "qrYuCLLUKALA" + }, "source": [ "## Fine-tuning the segmentation model\n", "\n", "When a sufficiently large training set of labeled conversations is available, fine-tuning the internal speaker segmentation model may lead to significant performance boost. \n", "\n", "Starting from the pretrained model..." - ], - "metadata": { - "id": "qrYuCLLUKALA" - } + ] }, { "cell_type": "code", - "source": [ - "from pyannote.audio import Model\n", - "model = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)" - ], + "execution_count": 15, "metadata": { "id": "jeUDgr4f55v6" }, - "execution_count": 15, - "outputs": [] + "outputs": [], + "source": [ + "from pyannote.audio import Model\n", + "model = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)" + ] }, { "cell_type": "markdown", - "source": [ - "... we prepare it for fine-tuning on the training dataset:" - ], "metadata": { "id": "SAyCf7ontua_" - } + }, + "source": [ + "... we prepare it for fine-tuning on the training dataset:" + ] }, { "cell_type": "code", - "source": [ - "from pyannote.audio.tasks import Segmentation\n", - "task = Segmentation(dataset, \n", - " duration=model.specifications.duration, \n", - " max_num_speakers=len(model.specifications.classes), \n", - " batch_size=32,\n", - " num_workers=2, \n", - " loss=\"bce\", \n", - " vad_loss=\"bce\")\n", - "model.task = task\n", - "model.setup(stage=\"fit\")" - ], + "execution_count": null, "metadata": { "id": "Kk_a7ABQ6PPH" }, - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "from pyannote.audio.tasks import SpeakerDiarization\n", + "task = SpeakerDiarization(\n", + " dataset, \n", + " duration=model.specifications.duration, \n", + " max_num_speakers=len(model.specifications.classes), \n", + " batch_size=32,\n", + " num_workers=2, \n", + " loss=\"bce\", \n", + " vad_loss=\"bce\")\n", + "model.task = task\n", + "model.setup(stage=\"fit\")" + ] }, { "cell_type": "markdown", - "source": [ - "The actual training is done with [`lightning`](https://github.com/Lightning-AI/lightning):" - ], "metadata": { "id": "TgobhVTKt9sH" - } + }, + "source": [ + "The actual training is done with [`lightning`](https://github.com/Lightning-AI/lightning):" + ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "f_bVYrNo6TmI" + }, + "outputs": [], "source": [ "# this takes approximately 15min to run on Google Colab GPU\n", "from types import MethodType\n", @@ -423,15 +410,15 @@ " max_epochs=20,\n", " gradient_clip_val=0.5)\n", "trainer.fit(model)" - ], - "metadata": { - "id": "f_bVYrNo6TmI" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", + "execution_count": 20, + "metadata": { + "id": "830LvZfdd3Rn" + }, + "outputs": [], "source": [ "# save path to the best checkpoint for later use\n", "finetuned_model = checkpoint.best_model_path\n", @@ -439,30 +426,22 @@ "# uncomment to download the checkpoint\n", "#from google.colab import files\n", "#files.download(finetuned_model)" - ], - "metadata": { - "id": "830LvZfdd3Rn" - }, - "execution_count": 20, - "outputs": [] + ] }, { "cell_type": "markdown", + "metadata": { + "id": "2NVGAIMd-uPI" + }, "source": [ "## Optimizing the pipeline hyper-parameters\n", "\n", "The pretrained `pyannote/speaker-diarization` pipeline relies on its own set of hyper-parameters adapted to the internal `pyannote/segmentation` pretrained model:" - ], - "metadata": { - "id": "2NVGAIMd-uPI" - } + ] }, { "cell_type": "code", - "source": [ - "pretrained_hyperparameters = pretrained_pipeline.parameters(instantiated=True)\n", - "pretrained_hyperparameters" - ], + "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -470,10 +449,8 @@ "id": "8OUIBHP7-xk_", "outputId": "20b3af76-d2d3-4bf9-eb58-2589f8e86939" }, - "execution_count": 23, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "{'segmentation': {'min_duration_off': 0.5817029604921046,\n", @@ -483,13 +460,21 @@ " 'threshold': 0.7153814381597874}}" ] }, + "execution_count": 23, "metadata": {}, - "execution_count": 23 + "output_type": "execute_result" } + ], + "source": [ + "pretrained_hyperparameters = pretrained_pipeline.parameters(instantiated=True)\n", + "pretrained_hyperparameters" ] }, { "cell_type": "markdown", + "metadata": { + "id": "y1rRE4NqJmb5" + }, "source": [ "There is no reason the above hyper-parameters are optimal for the newly finetuned speaker segmentation model. Let's optimize them:\n", "\n", @@ -500,13 +485,15 @@ "* `clustering.min_cluster_size` controls what to do with small speaker clusters. Clusters smaller than that are assigned to the most similar large cluster. `15` is a good default value.\n", "\n", "We start by optimizing `segmentation.threshold` by assuming that the subsequent clustering step is perfect (cf. `OracleClustering`)." - ], - "metadata": { - "id": "y1rRE4NqJmb5" - } + ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FSWW7bIphgAI" + }, + "outputs": [], "source": [ "# this takes approximately 5min to run on Google Colab GPU\n", "from pyannote.audio.pipelines import SpeakerDiarization\n", @@ -527,35 +514,35 @@ "for i, iteration in enumerate(iterations):\n", " print(f\"Best segmentation threshold so far: {iteration['params']['segmentation']['threshold']}\")\n", " if i > 20: break # 50 iterations should give slightly better results" - ], - "metadata": { - "id": "FSWW7bIphgAI" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "markdown", - "source": [ - "Then, we use the optimized value of `segmentation.threshold` and optimize `clustering.threshold`." - ], "metadata": { "id": "pAUx-1Pw3Uc9" - } + }, + "source": [ + "Then, we use the optimized value of `segmentation.threshold` and optimize `clustering.threshold`." + ] }, { "cell_type": "code", - "source": [ - "best_segmentation_threshold = optimizer.best_params[\"segmentation\"][\"threshold\"]" - ], + "execution_count": 26, "metadata": { "id": "CSzOWLL5Q29-" }, - "execution_count": 26, - "outputs": [] + "outputs": [], + "source": [ + "best_segmentation_threshold = optimizer.best_params[\"segmentation\"][\"threshold\"]" + ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "M_pQkyQ5RCjl" + }, + "outputs": [], "source": [ "# this takes approximately 5min to run on Google Colab GPU\n", "pipeline = SpeakerDiarization(\n", @@ -582,35 +569,47 @@ "for i, iteration in enumerate(iterations):\n", " print(f\"Best clustering threshold so far: {iteration['params']['clustering']['threshold']}\")\n", " if i > 20: break # 50 iterations should give slightly better results" - ], - "metadata": { - "id": "M_pQkyQ5RCjl" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "markdown", - "source": [ - "Finally, we use the optimized values of `segmentation.threshold` and `clustering.threshold` to evaluate the performance of the finetuned pipeline:" - ], "metadata": { "id": "BDA2XT-wAzDO" - } + }, + "source": [ + "Finally, we use the optimized values of `segmentation.threshold` and `clustering.threshold` to evaluate the performance of the finetuned pipeline:" + ] }, { "cell_type": "code", - "source": [ - "best_clustering_threshold = optimizer.best_params['clustering']['threshold']" - ], + "execution_count": 28, "metadata": { "id": "GBJv2j1U_5mj" }, - "execution_count": 28, - "outputs": [] + "outputs": [], + "source": [ + "best_clustering_threshold = optimizer.best_params['clustering']['threshold']" + ] }, { "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ir1VUqNEimcN", + "outputId": "d8edfb16-8f97-4d84-d4d2-3066d8b7c791" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The finetuned pipeline reaches a Diarization Error Rate (DER) of 26.6% on AMI-SDM.SpeakerDiarization.mini test set.\n" + ] + } + ], "source": [ "# this takes approximately 2min to run on Google Colab GPU\n", "finetuned_pipeline = SpeakerDiarization(\n", @@ -642,30 +641,11 @@ " metric(file[\"annotation\"], file[\"finetuned pipeline\"], uem=file[\"annotated\"])\n", "\n", "print(f\"The finetuned pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ir1VUqNEimcN", - "outputId": "d8edfb16-8f97-4d84-d4d2-3066d8b7c791" - }, - "execution_count": 35, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The finetuned pipeline reaches a Diarization Error Rate (DER) of 26.6% on AMI-SDM.SpeakerDiarization.mini test set.\n" - ] - } ] }, { "cell_type": "code", - "source": [ - "file[\"finetuned pipeline\"]" - ], + "execution_count": 37, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -674,26 +654,26 @@ "id": "LFvNtdZTBDZh", "outputId": "f72da25d-7df7-4d8f-97b1-b5ca0f2febe7" }, - "execution_count": 37, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, + "execution_count": 37, "metadata": {}, - "execution_count": 37 + "output_type": "execute_result" } + ], + "source": [ + "file[\"finetuned pipeline\"]" ] }, { "cell_type": "code", - "source": [ - "file[\"annotation\"]" - ], + "execution_count": 38, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -702,23 +682,28 @@ "id": "odzLUrqaBHgV", "outputId": "1864ccc7-076e-41bf-ba63-13df32d57fda" }, - "execution_count": 38, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, + "execution_count": 38, "metadata": {}, - "execution_count": 38 + "output_type": "execute_result" } + ], + "source": [ + "file[\"annotation\"]" ] }, { "cell_type": "markdown", + "metadata": { + "id": "muYEOZ36VJo5" + }, "source": [ "## Conclusion\n", "\n", @@ -735,10 +720,26 @@ "For technical questions and bug reports, please check [pyannote.audio](https://github.com/pyannote/pyannote-audio) Github repository so that my (or anyone's) public answer benefits other people as well. \n", "\n", "For scientific consulting enquiries, please contact [me](herve@niderb.fr)." - ], - "metadata": { - "id": "muYEOZ36VJo5" - } + ] } - ] -} \ No newline at end of file + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "authorship_tag": "ABX9TyMc87txSanOjHXPQP0Zpu9J", + "include_colab_link": true, + "provenance": [], + "toc_visible": true + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/tutorials/training_a_model.ipynb b/tutorials/training_a_model.ipynb index f062bd95d..f3e019f8b 100644 --- a/tutorials/training_a_model.ipynb +++ b/tutorials/training_a_model.ipynb @@ -378,8 +378,8 @@ "metadata": {}, "outputs": [], "source": [ - "from pyannote.audio.tasks import Segmentation\n", - "seg_task = Segmentation(ami, duration=5.0, max_num_speakers=4)" + "from pyannote.audio.tasks import SpeakerDiarization\n", + "seg_task = SpeakerDiarization(ami, duration=5.0, max_num_speakers=4)" ] }, { From 9faa8fc8a89527403dbb80f235cc18b8d034d921 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 17 Apr 2023 15:32:37 +0200 Subject: [PATCH 060/112] setup: update most dependencies (#1323) - setup: switch to torch 2.0+ and lightning 2.0+ - setup: switch to torchaudio 2.0+ and soundfile 0.12+ - setup: switch to pyannote.core 5.0+ and pyannote.database 5.0+ - setup: switch to speechbrain 0.5.14+ - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` - BREAKING(task): remove support for variable chunk duration - BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (in favor of `SpeakerDiarization` pipeline) - BREAKING(pipeline): remove support `FINCHClustering` and `HiddenMarkovModelClustering` - BREAKING: drop support for Python 3.7 --- .github/workflows/test.yml | 46 +-- CHANGELOG.md | 8 +- README.md | 22 +- doc/source/index.rst | 3 + pyannote/audio/cli/train.py | 2 +- .../cli/train_config/trainer/default.yaml | 11 +- pyannote/audio/core/model.py | 5 +- pyannote/audio/core/task.py | 17 +- pyannote/audio/pipelines/__init__.py | 2 - pyannote/audio/pipelines/clustering.py | 335 +-------------- .../audio/pipelines/speaker_diarization.py | 29 +- .../audio/pipelines/speaker_segmentation.py | 382 ------------------ .../audio/pipelines/speaker_verification.py | 7 +- .../tasks/segmentation/speaker_diarization.py | 3 +- pyannote/audio/utils/metric.py | 6 +- pyannote/audio/utils/powerset.py | 6 +- requirements.txt | 36 +- setup.py | 3 +- tests/tasks/test_reproducibility.py | 2 +- tutorials/intro.ipynb | 9 +- 20 files changed, 75 insertions(+), 859 deletions(-) delete mode 100644 pyannote/audio/pipelines/speaker_segmentation.py diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 52aad4944..dbe2b54d8 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -2,9 +2,9 @@ name: Tests on: push: - branches: [ develop ] + branches: [develop] pull_request: - branches: [ develop ] + branches: [develop] jobs: build: @@ -13,28 +13,28 @@ jobs: strategy: matrix: os: [ubuntu-latest] - python-version: [3.7, 3.8, 3.9] + python-version: [3.8, 3.9, "3.10"] steps: - - uses: actions/checkout@v2 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - name: Install libsndfile - if: matrix.os == 'ubuntu-latest' - run: | - sudo apt-get install libsndfile1 - - name: Install pyannote.audio - run: | + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + - name: Install libsndfile + if: matrix.os == 'ubuntu-latest' + run: | + sudo apt-get install libsndfile1 + - name: Install pyannote.audio + run: | pip install -e .[dev,testing] - - name: Test with pytest - run: | + - name: Test with pytest + run: | export PYANNOTE_DATABASE_CONFIG=$GITHUB_WORKSPACE/tests/data/database.yml pytest --cov-report=xml - - name: Upload coverage to Codecov - uses: codecov/codecov-action@v1 - with: - file: ./coverage.xml - env_vars: PYTHON - name: codecov-pyannote-audio - fail_ci_if_error: false + - name: Upload coverage to Codecov + uses: codecov/codecov-action@v1 + with: + file: ./coverage.xml + env_vars: PYTHON + name: codecov-pyannote-audio + fail_ci_if_error: false diff --git a/CHANGELOG.md b/CHANGELOG.md index d30e101a7..5390032d8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,12 +2,18 @@ ## Version 3.0 (xxxx-xx-xx) - - setup: switch to pyannote.database 5.0 - feat(task): add support for label scope in speaker diarization task (from pyannote.database 5.0) - feat(task): add support for missing classes in multi-label segmentation task (from pyannote.database 5.0) - improve(task): load metadata as tensors rather than pyannote.core instances + - setup: switch to torch 2.0+ and lightning 2.0+ + - setup: switch to torchaudio 2.0+ and soundfile 0.12+ + - setup: switch to pyannote.core 5.0+ and pyannote.database 5.0+ + - setup: switch to speechbrain 0.5.14+ - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` - BREAKING(task): remove support for variable chunk duration + - BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (in favor of `SpeakerDiarization` pipeline) + - BREAKING(pipeline): remove support `FINCHClustering` and `HiddenMarkovModelClustering` + - BREAKING: drop support for Python 3.7 ## Version 2.1.1 (2022-10-27) diff --git a/README.md b/README.md index c71361791..c3f9a8dcc 100644 --- a/README.md +++ b/README.md @@ -30,31 +30,21 @@ for turn, _, speaker in diarization.itertracks(yield_label=True): # ... ``` -## What's new in `pyannote.audio` 2.x? +## Highlights -For version 2.x of `pyannote.audio`, [I](https://herve.niderb.fr) decided to rewrite almost everything from scratch. -Highlights of this release are: - -- :exploding_head: much better performance (see [Benchmark](#benchmark)) -- :snake: Python-first API - :hugs: pretrained [pipelines](https://hf.co/models?other=pyannote-audio-pipeline) (and [models](https://hf.co/models?other=pyannote-audio-model)) on [:hugs: model hub](https://huggingface.co/pyannote) +- :exploding_head: state-of-the-art performance (see [Benchmark](#benchmark)) +- :snake: Python-first API - :zap: multi-GPU training with [pytorch-lightning](https://pytorchlightning.ai/) - :control_knobs: data augmentation with [torch-audiomentations](https://github.com/asteroid-team/torch-audiomentations) -- :boom: [Prodigy](https://prodi.gy/) recipes for model-assisted audio annotation ## Installation -Only Python 3.8+ is officially supported (though it might work with Python 3.7) +Only Python 3.8+ is supported. ```bash -conda create -n pyannote python=3.8 -conda activate pyannote - -# pytorch 1.11 is required for speechbrain compatibility -# (see https://pytorch.org/get-started/previous-versions/#v1110) -conda install pytorch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 -c pytorch - -pip install pyannote.audio +# install from develop branch +pip install -qq https://github.com/pyannote/pyannote-audio/archive/refs/heads/develop.zip ``` ## Documentation diff --git a/doc/source/index.rst b/doc/source/index.rst index 69fabbf08..fae1d7803 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -9,6 +9,9 @@ Installation :: + $ conda create -n pyannote python=3.10 + $ conda activate pyannote + $ conda install pytorch torchvision torchaudio -c pytorch $ pip install pyannote.audio diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index be9596e4a..d8155c1bd 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -26,7 +26,7 @@ import hydra from hydra.utils import instantiate -from lightning_lite.utilities.seed import seed_everything +from lightning.pytorch import seed_everything from omegaconf import DictConfig, OmegaConf # from pyannote.audio.core.callback import GraduallyUnfreeze diff --git a/pyannote/audio/cli/train_config/trainer/default.yaml b/pyannote/audio/cli/train_config/trainer/default.yaml index fee078690..ac3a60ff4 100644 --- a/pyannote/audio/cli/train_config/trainer/default.yaml +++ b/pyannote/audio/cli/train_config/trainer/default.yaml @@ -2,9 +2,7 @@ _target_: pytorch_lightning.Trainer accelerator: auto accumulate_grad_batches: 1 -auto_scale_batch_size: False -auto_lr_find: False -benchmark: False +benchmark: null # TODO: automatically set to True when using fixed duration chunks deterministic: False check_val_every_n_epoch: 1 devices: auto @@ -13,7 +11,7 @@ enable_checkpointing: True enable_model_summary: True enable_progress_bar: True fast_dev_run: False -gradient_clip_val: 0 +gradient_clip_val: null gradient_clip_algorithm: norm limit_predict_batches: 1.0 limit_test_batches: 1.0 @@ -25,16 +23,13 @@ max_steps: -1 max_time: null min_epochs: 1 min_steps: null -move_metrics_to_cpu: False -multiple_trainloader_mode: max_size_cycle num_nodes: 1 num_sanity_val_steps: 2 overfit_batches: 0.0 precision: 32 profiler: null reload_dataloaders_every_n_epochs: 0 -replace_sampler_ddp: True +use_distributed_sampler: True # TODO: check what this does exactly strategy: null sync_batchnorm: False -track_grad_norm: -1 val_check_interval: 1.0 diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 000b469b6..ec0a4a259 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -35,8 +35,8 @@ import torch.optim from huggingface_hub import hf_hub_download from huggingface_hub.utils import RepositoryNotFoundError +from lightning_fabric.utilities.cloud_io import _load as pl_load from pyannote.core import SlidingWindow -from lightning_lite.utilities.cloud_io import _load as pl_load from pytorch_lightning.utilities.model_summary import ModelSummary from semver import VersionInfo from torch.utils.data import DataLoader @@ -523,9 +523,6 @@ def val_dataloader(self) -> DataLoader: def validation_step(self, batch, batch_idx): return self.task.validation_step(batch, batch_idx) - def validation_epoch_end(self, outputs): - return self.task.validation_epoch_end(outputs) - def configure_optimizers(self): return torch.optim.Adam(self.parameters(), lr=1e-3) diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index c7833dc77..df38a49d2 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -23,31 +23,23 @@ from __future__ import annotations -from functools import partial - -import scipy.special - -try: - from functools import cached_property -except ImportError: - from backports.cached_property import cached_property - import multiprocessing import sys import warnings from dataclasses import dataclass from enum import Enum +from functools import cached_property, partial from numbers import Number -from typing import Dict, List, Optional, Sequence, Text, Tuple, Union +from typing import Dict, List, Literal, Optional, Sequence, Text, Tuple, Union import pytorch_lightning as pl +import scipy.special import torch from pyannote.database import Protocol from torch.utils.data import DataLoader, Dataset, IterableDataset from torch_audiomentations import Identity from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric, MetricCollection -from typing_extensions import Literal from pyannote.audio.utils.loss import binary_cross_entropy, nll_loss from pyannote.audio.utils.protocol import check_protocol @@ -447,9 +439,6 @@ def val_dataloader(self) -> Optional[DataLoader]: def validation_step(self, batch, batch_idx: int): return self.common_step(batch, batch_idx, "val") - def validation_epoch_end(self, outputs): - pass - def default_metric(self) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: """Default validation metric""" msg = f"Missing '{self.__class__.__name__}.default_metric' method." diff --git a/pyannote/audio/pipelines/__init__.py b/pyannote/audio/pipelines/__init__.py index d20f9bfb9..0c7d2f25c 100644 --- a/pyannote/audio/pipelines/__init__.py +++ b/pyannote/audio/pipelines/__init__.py @@ -24,13 +24,11 @@ from .overlapped_speech_detection import OverlappedSpeechDetection from .resegmentation import Resegmentation from .speaker_diarization import SpeakerDiarization -from .speaker_segmentation import SpeakerSegmentation from .voice_activity_detection import VoiceActivityDetection __all__ = [ "VoiceActivityDetection", "OverlappedSpeechDetection", - "SpeakerSegmentation", "SpeakerDiarization", "Resegmentation", "MultiLabelSegmentation", diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index 6258bbd98..f282ea39c 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -29,33 +29,17 @@ import numpy as np from einops import rearrange -from hmmlearn.hmm import GaussianHMM from pyannote.core import SlidingWindow, SlidingWindowFeature from pyannote.pipeline import Pipeline -from pyannote.pipeline.parameter import ( - Categorical, - Integer, - LogUniform, - ParamDict, - Uniform, -) +from pyannote.pipeline.parameter import Categorical, Integer, Uniform from scipy.cluster.hierarchy import fcluster, linkage from scipy.optimize import linear_sum_assignment -from scipy.spatial.distance import cdist, pdist +from scipy.spatial.distance import cdist -from pyannote.audio import Inference from pyannote.audio.core.io import AudioFile from pyannote.audio.pipelines.utils import oracle_segmentation from pyannote.audio.utils.permutation import permutate -try: - from finch import FINCH - - FINCH_IS_AVAILABLE = True - -except ImportError: - FINCH_IS_AVAILABLE = False - class BaseClustering(Pipeline): def __init__( @@ -286,105 +270,6 @@ def __call__( return hard_clusters, soft_clusters -class FINCHClustering(BaseClustering): - """FINCH clustering - - Parameters - ---------- - metric : {"cosine", "euclidean", ...}, optional - Distance metric to use. Defaults to "cosine". - """ - - def __init__( - self, - metric: str = "cosine", - max_num_embeddings: int = np.inf, - constrained_assignment: bool = False, - ): - - if not FINCH_IS_AVAILABLE: - raise ImportError( - "'finch-clust' must be installed to use FINCH clustering. " - "Visit https://pypi.org/project/finch-clust/ for installation instructions." - ) - - super().__init__( - metric=metric, - max_num_embeddings=max_num_embeddings, - constrained_assignment=constrained_assignment, - ) - - self.threshold = Uniform(0.0, 2.0) # assume unit-normalized embeddings - self.method = Categorical(["average", "complete", "single"]) - - def cluster( - self, - embeddings: np.ndarray, - min_clusters: int, - max_clusters: int, - num_clusters: int = None, - ): - """ - - Parameters - ---------- - embeddings : (num_embeddings, dimension) array - Embeddings - min_clusters : int - Minimum number of clusters - max_clusters : int - Maximum number of clusters - num_clusters : int, optional - Actual number of clusters. Default behavior is to estimate it based - on values provided for `min_clusters`, `max_clusters`, and `threshold`. - - Returns - ------- - clusters : (num_embeddings, ) array - 0-indexed cluster indices. - """ - - num_embeddings, _ = embeddings.shape - if num_embeddings == 1: - return np.zeros((1,), dtype=np.uint8) - - # apply FINCH clustering and keep (supposedly pure) penultimate partition - clusters, _, _ = FINCH( - embeddings, - initial_rank=None, - req_clust=None, - distance=self.metric, - ensure_early_exit=True, - verbose=False, - ) - - _, num_partitions = clusters.shape - if num_partitions < 2: - clusters = clusters[:, 0] - else: - clusters = clusters[:, -2] - num_clusters = np.max(clusters) + 1 - - # compute centroids - centroids = np.vstack( - [np.mean(embeddings[clusters == k], axis=0) for k in range(num_clusters)] - ) - - # perform agglomerative clustering on centroids - dendrogram = linkage(centroids, metric=self.metric, method=self.method) - klusters = fcluster(dendrogram, self.threshold, criterion="distance") - 1 - - # update clusters - clusters = -clusters - for i, k in enumerate(klusters): - clusters[clusters == -i] = k - - # TODO: handle min/max/num_clusters - # TODO: handle min_cluster_size - - return clusters - - class AgglomerativeClustering(BaseClustering): """Agglomerative clustering @@ -650,222 +535,6 @@ def __call__( return hard_clusters, soft_clusters -class HiddenMarkovModelClustering(BaseClustering): - """Hidden Markov Model with Gaussian states""" - - def __init__( - self, - metric: str = "cosine", - constrained_assignment: bool = False, - ): - - if metric not in ["euclidean", "cosine"]: - raise ValueError("`metric` must be one of {'cosine', 'euclidean'}") - - super().__init__( - metric=metric, - constrained_assignment=constrained_assignment, - ) - - self.single_cluster_detection = ParamDict( - quantile=LogUniform(1e-3, 1e-1), - threshold=Uniform(0.0, 2.0), - ) - - self.covariance_type = Categorical(["spherical", "diag", "full", "tied"]) - self.threshold = Uniform(0.0, 2.0) - - def filter_embeddings( - self, embeddings: np.ndarray, segmentations: SlidingWindowFeature - ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: - """ - - Parameters - ---------- - embeddings : (num_chunks, num_speakers, dimension) array - Sequence of embeddings. - segmentations : (num_chunks, num_frames, num_speakers) array - Binary segmentations. - - Returns - ------- - train_embeddings : (num_steps, dimension) array - chunk_idx : (num_steps, ) array - speaker_idx : (num_steps, ) array - - """ - - num_chunks, _, _ = embeddings.shape - - # focus on center of each chunk - duration = segmentations.sliding_window.duration - step = segmentations.sliding_window.step - - ratio = 0.5 * (duration - step) / duration - center_segmentations = Inference.trim(segmentations, warm_up=(ratio, ratio)) - # shape: num_chunks, num_center_frames, num_speakers - - # number of frames during which speakers are active - # in the center of the chunk - num_active_frames: np.ndarray = np.sum(center_segmentations.data, axis=1) - # shape: (num_chunks, num_speakers) - - priors = num_active_frames / ( - np.sum(num_active_frames, axis=1, keepdims=True) + 1e-8 - ) - # shape: (num_chunks, local_num_speakers) - - speaker_idx = np.argmax(priors, axis=1) - # (num_chunks, ) - - # TODO: generate alternative sequences that only differs from train_embeddings - # in regions where there is overlap. - - train_embeddings = embeddings[range(num_chunks), speaker_idx] - # (num_chunks, dimension) - - # remove chunks with one of the following property: - # * there is no active speaker in the center of the chunk - # * embedding extraction has failed for the most active speaker in the center of the chunk - center_is_non_speech = np.max(num_active_frames, axis=1) == 0.0 - embedding_is_invalid = np.any(np.isnan(train_embeddings), axis=1) - chunk_idx = np.where(~(embedding_is_invalid | center_is_non_speech))[0] - # (num_chunks, ) - - return (train_embeddings[chunk_idx], chunk_idx, speaker_idx[chunk_idx]) - - def fit_hmm(self, n_components, train_embeddings): - - hmm = GaussianHMM( - n_components=n_components, - covariance_type=self.covariance_type, - n_iter=100, - random_state=42, - implementation="log", - verbose=False, - ) - hmm.fit(train_embeddings) - - return hmm - - def cluster( - self, - embeddings: np.ndarray, - min_clusters: int, - max_clusters: int, - num_clusters: int = None, - ): - - num_embeddings = len(embeddings) - - # FIXME - if max_clusters == num_embeddings: - max_clusters = min(max_clusters, 20) - - if self.metric == "cosine": - # unit-normalize embeddings to somehow make them "euclidean" - with np.errstate(divide="ignore", invalid="ignore"): - euclidean_embeddings = embeddings / np.linalg.norm( - embeddings, axis=-1, keepdims=True - ) - elif self.metric == "euclidean": - euclidean_embeddings = embeddings - - # when the number of clusters is provided, fit a HMM with - # that many states and return the decoded sequence of states - if num_clusters is not None: - hmm = self.fit_hmm(num_clusters, euclidean_embeddings) - - try: - train_clusters = hmm.predict(euclidean_embeddings) - except ValueError: - # ValueError: startprob_ must sum to 1 (got nan) - # TODO: display a warning that something went wrong - train_clusters = np.zeros((num_embeddings,), dtype=np.int8) - - return train_clusters - - # heuristic for detecting cases where there is just one large cluster - # (and a few meaningless outliers) - if min_clusters == 1: - - # Example with quantile = 1% and threshold = 0.4: - # if 99% (100% - 1%) of pairwise distance are smaller than 0.4, - # then we assume that the others are outliers and return one cluster - if ( - np.quantile( - pdist(euclidean_embeddings, metric="euclidean"), - 1.0 - self.single_cluster_detection["quantile"], - ) - < self.single_cluster_detection["threshold"] - ): - - return np.zeros((num_embeddings,), dtype=np.int8) - - # otherwise, we make sure to return at least 2 clusters - min_clusters = max(2, min_clusters) - max_clusters = max(2, max_clusters) - - # fit a HMM with increasing number of states and stop adding - # when the distance between the two closest states - # - either no longer increases - # - or no longer goes above a threshold - # the selected number of states is the last one for which the - # criterion goes above {threshold}. - - # THIS IS A TERRIBLE CRITERION THAT NEEDS TO BE FIXED - - history = [-np.inf] - patience = min(3, max_clusters - min_clusters) - num_clusters = min_clusters - - for n_components in range(min_clusters, max_clusters + 1): - - hmm = self.fit_hmm(n_components, euclidean_embeddings) - try: - train_clusters = hmm.predict(euclidean_embeddings) - except ValueError: # ValueError: startprob_ must sum to 1 (got nan) - # stop adding states as there too many and not enough - # training data to train it in a reliable manner. - break - - # stop early if too few states were found - if len(np.unique(train_clusters)) < n_components: - break - - # compute distance between the two closest centroids - centroids = np.vstack( - [ - np.mean(embeddings[train_clusters == k], axis=0) - for k in range(n_components) - ] - ) - centroids_pdist = pdist(centroids, metric=self.metric) - current_criterion = np.min(centroids_pdist) - - increasing = current_criterion > max(history) - big_enough = current_criterion > self.threshold - - if increasing or big_enough: - num_clusters = n_components - - elif n_components == num_clusters + patience: - break - - history.append(current_criterion) - - hmm = self.fit_hmm(num_clusters, euclidean_embeddings) - try: - train_clusters = hmm.predict(euclidean_embeddings) - except ValueError: - # ValueError: startprob_ must sum to 1 (got nan) - train_clusters = np.zeros((num_embeddings,), dtype=np.int8) - - return train_clusters - - class Clustering(Enum): AgglomerativeClustering = AgglomerativeClustering - FINCHClustering = FINCHClustering - HiddenMarkovModelClustering = HiddenMarkovModelClustering OracleClustering = OracleClustering diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 1e279b82a..246e9df7f 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -77,7 +77,7 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): Defaults (False) to use the whole speech. clustering : str, optional Clustering algorithm. See pyannote.audio.pipelines.clustering.Clustering - for available options. Defaults to "HiddenMarkovModelClustering". + for available options. Defaults to "AgglomerativeClustering". segmentation_batch_size : int, optional Batch size used for speaker segmentation. Defaults to 32. embedding_batch_size : int, optional @@ -112,7 +112,7 @@ def __init__( segmentation_step: float = 0.1, embedding: PipelineModel = "speechbrain/spkrec-ecapa-voxceleb@5c0be3875fda05e81f3c004ed8c7c06be308de1e", embedding_exclude_overlap: bool = False, - clustering: str = "HiddenMarkovModelClustering", + clustering: str = "AgglomerativeClustering", embedding_batch_size: int = 32, segmentation_batch_size: int = 32, der_variant: dict = None, @@ -177,31 +177,6 @@ def __init__( self.clustering = Klustering.value(metric=metric) def default_parameters(self): - - if ( - self.segmentation_model == "pyannote/segmentation@2022.07" - and self.segmentation_duration == 5.0 - and self.segmentation_step == 0.1 - and self.embedding - == "speechbrain/spkrec-ecapa-voxceleb@5c0be3875fda05e81f3c004ed8c7c06be308de1e" - and self.embedding_exclude_overlap == True - and self.clustering == "HiddenMarkovModelClustering" - ): - return { - "segmentation": { - "threshold": 0.58, - "min_duration_off": 0.0, - }, - "clustering": { - "single_cluster_detection": { - "quantile": 0.05, - "threshold": 1.15, - }, - "covariance_type": "diag", - "threshold": 0.35, - }, - } - raise NotImplementedError() def classes(self): diff --git a/pyannote/audio/pipelines/speaker_segmentation.py b/pyannote/audio/pipelines/speaker_segmentation.py deleted file mode 100644 index 3eeb6070a..000000000 --- a/pyannote/audio/pipelines/speaker_segmentation.py +++ /dev/null @@ -1,382 +0,0 @@ -# MIT License -# -# Copyright (c) 2018-2022 CNRS -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -"""Speaker segmentation pipeline""" - -import math -from functools import partial -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.inference import Inference -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_model, -) -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): - """Speaker segmentation - - Parameters - ---------- - segmentation : Model, str, or dict, optional - Pretrained segmentation model. Defaults to "pyannote/segmentation". - See pyannote.audio.pipelines.utils.get_model for supported format. - skip_conversion : bool, optional - 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 - ---------------- - onset : float - Onset speaker activation threshold - offset : float - Offset speaker activation threshold - stitch_threshold : float - Initial stitching threshold. - min_duration_on : float - Remove speaker turn shorter than that many seconds. - min_duration_off : float - Fill same-speaker gaps shorter than that many seconds. - - """ - - def __init__( - self, - segmentation: PipelineModel = "pyannote/segmentation", - skip_conversion: bool = False, - skip_stitching: bool = False, - use_auth_token: Union[Text, None] = None, - ): - super().__init__() - - self.segmentation = segmentation - self.skip_stitching = skip_stitching - self.skip_conversion = skip_conversion - - model: Model = get_model(segmentation, use_auth_token=use_auth_token) - self._segmentation = Inference(model) - self._frames = self._segmentation.model.introspection.frames - - self._audio = model.audio - - # number of speakers in output of segmentation model - self._num_speakers = len(model.specifications.classes) - - #  hyper-parameters used for hysteresis thresholding - self.onset = Uniform(0.0, 1.0) - self.offset = Uniform(0.0, 1.0) - - if not self.skip_stitching: - self.stitch_threshold = Uniform(0.0, 1.0) - - if not (self.skip_stitching or self.skip_conversion): - self.min_duration_on = Uniform(0.0, 1.0) - self.min_duration_off = Uniform(0.0, 1.0) - - self.warm_up = 0.05 - - def default_parameters(self): - # parameters optimized on DIHARD 3 development set - - if self.segmentation == "pyannote/segmentation": - - parameters = { - "onset": 0.84, - "offset": 0.46, - } - - if not self.skip_stitching: - parameters["stitch_threshold"] = 0.39 - - if not (self.skip_stitching or self.skip_conversion): - parameters.update( - { - "min_duration_on": 0.0, - "min_duration_off": 0.0, - } - ) - - return parameters - - raise NotImplementedError() - - CACHED_SEGMENTATION = "cache/segmentation/inference" - - @staticmethod - def get_stitching_graph( - segmentations: SlidingWindowFeature, onset: float = 0.5 - ) -> nx.Graph: - """Build stitching graph - - Parameters - ---------- - segmentations : (num_chunks, num_frames, local_num_speakers)-shaped SlidingWindowFeature - Raw output of segmentation model. - onset : float, optional - Onset speaker activation threshold. Defaults to 0.5 - - Returns - ------- - stitching_graph : nx.Graph - Nodes are (chunk_idx, speaker_idx) tuples. - An edge between two nodes indicate that those are likely to be the same speaker - (the lower the value of "cost" attribute, the more likely). - """ - - chunks = segmentations.sliding_window - num_chunks, num_frames, _ = segmentations.data.shape - max_lookahead = math.floor(chunks.duration / chunks.step - 1) - lookahead = 2 * (max_lookahead,) - - stitching_graph = nx.Graph() - - for C, (chunk, segmentation) in enumerate(segmentations): - for c in range( - max(0, C - lookahead[0]), min(num_chunks, C + lookahead[1] + 1) - ): - - if c == C: - continue - - # extract common temporal support - shift = round((C - c) * num_frames * chunks.step / chunks.duration) - - if shift < 0: - shift = -shift - this_segmentations = segmentation[shift:] - that_segmentations = segmentations[c, : num_frames - shift] - else: - this_segmentations = segmentation[: num_frames - shift] - that_segmentations = segmentations[c, shift:] - - # find the optimal one-to-one mapping - _, (permutation,), (cost,) = permutate( - this_segmentations[np.newaxis], - that_segmentations, - cost_func=mae_cost_func, - return_cost=True, - ) - - for this, that in enumerate(permutation): - - this_is_active = np.any(this_segmentations[:, this] > onset) - that_is_active = np.any(that_segmentations[:, that] > onset) - - if this_is_active: - stitching_graph.add_node((C, this)) - - if that_is_active: - stitching_graph.add_node((c, that)) - - if this_is_active and that_is_active: - stitching_graph.add_edge( - (C, this), (c, that), cost=cost[this, that] - ) - - return stitching_graph - - @staticmethod - def stitchable_components( - stitching_graph: nx.Graph, stitch_threshold: float, factor: float = 0.5 - ): - """Find stitchable connected components - - A component is 'stitchable' if it contains at most one node per chunk - - Parameters - ---------- - stitching_graph : nx.Graph - Stitching graph. - stitch_threshold : float - - Yields - ------ - component : list of (chunk_idx, speaker_idx) tuple - - """ - - f = stitching_graph.copy() - while f: - f.remove_edges_from( - [ - (n1, n2) - for n1, n2, cost in f.edges(data="cost") - if cost > stitch_threshold - ] - ) - for component in list(nx.connected_components(f)): - if len(set(c for c, _ in component)) == len(component): - yield component - f.remove_nodes_from(component) - stitch_threshold *= factor - - def apply( - self, file: AudioFile, hook: Optional[Callable] = None - ) -> SlidingWindowFeature: - """Apply speaker segmentation - - Parameters - ---------- - file : AudioFile - Processed file. - hook : callable, optional - Callback called after each major steps of the pipeline as follows: - hook(step_name, # human-readable name of current step - step_artefact, # artifact generated by current step - file=file) # file being processed - Time-consuming steps call `hook` multiple times with the same `step_name` - and additional `completed` and `total` keyword arguments usable to track - progress of current step. - - Returns - ------- - segmentation : Annotation - Speaker segmentation - """ - - hook = self.setup_hook(file, hook=hook) - - # apply segmentation model (only if needed) - # output shape is (num_chunks, num_frames, local_num_speakers) - if self.training: - if self.CACHED_SEGMENTATION in file: - segmentations = file[self.CACHED_SEGMENTATION] - else: - segmentations = self._segmentation( - file, hook=partial(hook, "segmentation", None) - ) - file[self.CACHED_SEGMENTATION] = segmentations - else: - segmentations: SlidingWindowFeature = self._segmentation( - file, hook=partial(hook, "segmentation", None) - ) - - hook("segmentation", segmentations) - - if self.skip_stitching: - return binarize( - segmentations, onset=self.onset, offset=self.offset, initial_state=False - ) - - # estimate frame-level number of instantaneous speakers - count = self.speaker_count( - segmentations, - onset=self.onset, - offset=self.offset, - warm_up=(self.warm_up, self.warm_up), - frames=self._frames, - ) - hook("speaker_counting", count) - - # trim warm-up regions - segmentations = Inference.trim( - segmentations, warm_up=(self.warm_up, self.warm_up) - ) - - # build stitching graph - stitching_graph = self.get_stitching_graph(segmentations, onset=self.onset) - - # find (constraint-compliant) connected components - components = list( - self.stitchable_components( - stitching_graph, stitch_threshold=self.stitch_threshold - ) - ) - - num_stitches = len(components) - num_chunks, num_frames, _ = segmentations.data.shape - - stitched_segmentations = np.NAN * np.zeros( - (num_chunks, num_frames, num_stitches) - ) - - for k, component in enumerate(components): - for c, s in component: - stitched_segmentations[c, :, k] = segmentations.data[c, :, s] - - stitched_segmentations = SlidingWindowFeature( - stitched_segmentations, segmentations.sliding_window - ) - - hook("stitching", stitched_segmentations) - - # build discrete diarization - discrete_diarization = self.to_diarization(stitched_segmentations, count) - - # remove inactive speakers - discrete_diarization.data = discrete_diarization.data[ - :, np.nonzero(np.sum(discrete_diarization.data, axis=0))[0] - ] - - if self.skip_conversion: - return discrete_diarization - - hook("aggregation", discrete_diarization) - - # convert to continuous diarization - diarization = self.to_annotation( - discrete_diarization, - min_duration_on=self.min_duration_on, - min_duration_off=self.min_duration_off, - ) - - diarization.uri = file["uri"] - - return diarization.rename_labels( - { - label: expected_label - for label, expected_label in zip(diarization.labels(), self.classes()) - } - ) - - def get_metric(self): - - if self.skip_stitching: - return DiscreteDiarizationErrorRate() - - if self.skip_conversion: - raise NotImplementedError( - "Cannot optimize segmentation pipeline when `skip_conversion` is True." - ) - - return SlidingDiarizationErrorRate(window=2.0 * self._segmentation.duration) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index af32582a3..7c73833a8 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -21,12 +21,7 @@ # SOFTWARE. import warnings - -try: - from functools import cached_property -except ImportError: - from backports.cached_property import cached_property - +from functools import cached_property from typing import Text, Union import numpy as np diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index 0ab5d6ae9..0c7a1fc0e 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -23,7 +23,7 @@ import math import warnings from collections import Counter -from typing import Dict, Optional, Sequence, Text, Tuple, Union +from typing import Dict, Literal, Optional, Sequence, Text, Tuple, Union import numpy as np import torch @@ -36,7 +36,6 @@ from rich.progress import track from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric -from typing_extensions import Literal from pyannote.audio.core.task import Problem, Resolution, Specifications, Task from pyannote.audio.tasks.segmentation.mixins import SegmentationTaskMixin diff --git a/pyannote/audio/utils/metric.py b/pyannote/audio/utils/metric.py index 71699da06..d03152046 100644 --- a/pyannote/audio/utils/metric.py +++ b/pyannote/audio/utils/metric.py @@ -20,11 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -try: - from functools import singledispatchmethod -except ImportError: - from singledispatchmethod import singledispatchmethod - +from functools import singledispatchmethod from typing import Dict, List, Optional import numpy as np diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index f206b65bf..215cb7946 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -24,11 +24,7 @@ # Hervé BREDIN - https://herve.niderb.fr # Alexis PLAQUET -try: - from functools import cached_property -except ImportError: - from backports.cached_property import cached_property - +from functools import cached_property from itertools import combinations import scipy.special diff --git a/requirements.txt b/requirements.txt index 14c07fb7f..22e63c5c4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,23 +1,19 @@ -asteroid-filterbanks >=0.4,<0.5 -backports.cached_property -einops >=0.3,<0.4.0 -hmmlearn >=0.2.7,<0.3 -huggingface_hub >= 0.8.1 -networkx >= 2.6,<3.0 +asteroid-filterbanks >=0.4 +einops >=0.6.0 +huggingface_hub >= 0.13.0 +lightning >= 2.0.1 omegaconf >=2.1,<3.0 -pyannote.core >=4.4,<5.0 -pyannote.database >=5.0,<6.0 -pyannote.metrics >=3.2,<4.0 -pyannote.pipeline >=2.3,<3.0 -pytorch_lightning >=1.8.0,<1.9 -pytorch_metric_learning >=1.0.0,<2.0 +pyannote.core >= 5.0.0 +pyannote.database >= 5.0.0 +pyannote.metrics >= 3.2 +pyannote.pipeline >= 2.3 # 2.4 +pytorch_metric_learning >= 2.1.0 rich >= 12.0.0 -semver >=2.10.2,<3.0 -singledispatchmethod -soundfile >=0.10.2,<0.12 -speechbrain >=0.5.12,<0.6 -torch >=1.9 +semver >= 3.0.0 +soundfile >= 0.12.1 +speechbrain >= 0.5.14 +tensorboardX >= 2.6 +torch >= 2.0.0 torch_audiomentations >= 0.11.0 -torchaudio >=0.10,<1.0 -torchmetrics >=0.11,<1.0 -typing_extensions +torchaudio >= 2.0.0 +torchmetrics >= 0.11.0 diff --git a/setup.py b/setup.py index 3fa457d60..4eaa0b055 100644 --- a/setup.py +++ b/setup.py @@ -56,8 +56,9 @@ "Intended Audience :: Science/Research", "License :: OSI Approved :: MIT License", "Natural Language :: English", - "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", "Topic :: Scientific/Engineering", ], ) diff --git a/tests/tasks/test_reproducibility.py b/tests/tasks/test_reproducibility.py index 5eab714bc..a7307e0cf 100644 --- a/tests/tasks/test_reproducibility.py +++ b/tests/tasks/test_reproducibility.py @@ -1,5 +1,5 @@ import torch -from lightning_lite.utilities.seed import seed_everything +from lightning.pytorch import seed_everything from pyannote.database import FileFinder, get_protocol from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index f6b420437..8d8bf2ffa 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -50,14 +50,7 @@ }, "outputs": [], "source": [ - "# for speechbrain\n", - "!pip install -qq torch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 torchtext==0.12.0\n", - "!pip install -qq speechbrain==0.5.12\n", - "\n", - "# pyannote.audio\n", - "!pip install -qq pyannote.audio\n", - "\n", - "# for visualization purposes\n", + "!pip install -qq https://github.com/pyannote/pyannote-audio/archive/refs/heads/develop.zip\n", "!pip install -qq ipython==7.34.0" ] }, From 00fe29fe0de7248dd8a33d47e1cec2aeebfd895f Mon Sep 17 00:00:00 2001 From: "Balazs G. Horvath" Date: Mon, 17 Apr 2023 15:35:07 +0200 Subject: [PATCH 061/112] feat(pipeline): add support for @revision of speechbrain models --- pyannote/audio/pipelines/speaker_verification.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 7c73833a8..1a672d614 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -237,7 +237,12 @@ def __init__( ) super().__init__() - self.embedding = embedding + if "@" in embedding: + self.embedding = embedding.split("@")[0] + self.revision = embedding.split("@")[1] + else: + self.embedding = embedding + self.revision = None self.device = device or torch.device("cpu") self.use_auth_token = use_auth_token @@ -246,6 +251,7 @@ def __init__( savedir=f"{CACHE_DIR}/speechbrain", run_opts={"device": self.device}, use_auth_token=self.use_auth_token, + revision=self.revision, ) def to(self, device: torch.device): @@ -254,6 +260,7 @@ def to(self, device: torch.device): savedir=f"{CACHE_DIR}/speechbrain", run_opts={"device": device}, use_auth_token=self.use_auth_token, + revision=self.revision, ) self.device = device return self From bbe13955c4e66e04e263a98ba55e95e6809f0b82 Mon Sep 17 00:00:00 2001 From: Will Proctor Date: Mon, 17 Apr 2023 09:39:22 -0400 Subject: [PATCH 062/112] fix: fix corner case in Inference on Windows --- pyannote/audio/core/inference.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index cf92e2ee5..9243babc1 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -98,7 +98,7 @@ def __init__( model if isinstance(model, Model) else Model.from_pretrained( - Path(model), + model, map_location=device, strict=False, use_auth_token=use_auth_token, From 1dc2abcc98a07aba3314925f1ba654a596fd9c13 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 19 Apr 2023 09:17:30 +0200 Subject: [PATCH 063/112] fix: fix tutorial Fixes #1331 Note: Segmentation will be renamed SpeakerDiarization in next release. --- tutorials/adapting_pretrained_pipeline.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tutorials/adapting_pretrained_pipeline.ipynb b/tutorials/adapting_pretrained_pipeline.ipynb index 7bfe73b8d..06d318809 100644 --- a/tutorials/adapting_pretrained_pipeline.ipynb +++ b/tutorials/adapting_pretrained_pipeline.ipynb @@ -334,8 +334,8 @@ }, "outputs": [], "source": [ - "from pyannote.audio.tasks import SpeakerDiarization\n", - "task = SpeakerDiarization(\n", + "from pyannote.audio.tasks import Segmentation\n", + "task = Segmentation(\n", " dataset, \n", " duration=model.specifications.duration, \n", " max_num_speakers=len(model.specifications.classes), \n", From 6ef2b888d765a6a03b012a7700979dcf684eb967 Mon Sep 17 00:00:00 2001 From: Paul Butler Date: Wed, 19 Apr 2023 03:31:58 -0400 Subject: [PATCH 064/112] chore: replace deprecated np.int with int (#1330) --- pyannote/audio/tasks/segmentation/multilabel.py | 4 ++-- .../audio/tasks/segmentation/overlapped_speech_detection.py | 4 ++-- pyannote/audio/tasks/segmentation/speaker_diarization.py | 4 ++-- pyannote/audio/tasks/segmentation/voice_activity_detection.py | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 603d04ac6..148903df8 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -187,9 +187,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / resolution).astype(np.int) + start_idx = np.floor(start / resolution).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / resolution).astype(np.int) + end_idx = np.ceil(end / resolution).astype(int) # frame-level targets (-1 for un-annotated classes) y = -np.ones((num_frames, len(self.classes)), dtype=np.int8) diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index f0bebbb13..658c350a7 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -179,9 +179,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / resolution).astype(np.int) + start_idx = np.floor(start / resolution).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / resolution).astype(np.int) + end_idx = np.ceil(end / resolution).astype(int) # frame-level targets y = np.zeros((num_frames, 1), dtype=np.uint8) diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index 0c7a1fc0e..f8828e3e4 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -347,9 +347,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / resolution).astype(np.int) + start_idx = np.floor(start / resolution).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / resolution).astype(np.int) + end_idx = np.ceil(end / resolution).astype(int) # get list and number of labels for current scope labels = list(np.unique(chunk_annotations[label_scope_key])) diff --git a/pyannote/audio/tasks/segmentation/voice_activity_detection.py b/pyannote/audio/tasks/segmentation/voice_activity_detection.py index 69f47d04b..559ff24eb 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -161,9 +161,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / resolution).astype(np.int) + start_idx = np.floor(start / resolution).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / resolution).astype(np.int) + end_idx = np.ceil(end / resolution).astype(int) # frame-level targets y = np.zeros((num_frames, 1), dtype=np.uint8) From cbe97e28433312933fdf1b3f056e102d4017a85e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 19 Apr 2023 17:27:46 +0200 Subject: [PATCH 065/112] fix: skip batches resulting in NaN loss (#1332) --- pyannote/audio/core/task.py | 5 +++++ pyannote/audio/tasks/embedding/mixins.py | 5 +++++ pyannote/audio/tasks/segmentation/multilabel.py | 4 ++++ pyannote/audio/tasks/segmentation/speaker_diarization.py | 6 +++++- 4 files changed, 19 insertions(+), 1 deletion(-) diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index df38a49d2..95cca1dee 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -396,6 +396,11 @@ def common_step(self, batch, batch_idx: int, stage: Literal["train", "val"]): # compute loss loss = self.default_loss(self.specifications, y, y_pred, weight=weight) + + # skip batch if something went wrong for some reason + if torch.isnan(loss): + return None + self.model.log( f"{self.logging_prefix}{stage.capitalize()}Loss", loss, diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index 2178bb2a7..00aa7e608 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -245,6 +245,10 @@ def training_step(self, batch, batch_idx: int): X, y = batch["X"], batch["y"] loss = self.model.loss_func(self.model(X), y) + # skip batch if something went wrong for some reason + if torch.isnan(loss): + return None + self.model.log( f"{self.logging_prefix}TrainLoss", loss, @@ -253,6 +257,7 @@ def training_step(self, batch, batch_idx: int): prog_bar=True, logger=True, ) + return {"loss": loss} def val__getitem__(self, idx): diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 148903df8..19270e26f 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -223,6 +223,10 @@ def training_step(self, batch, batch_idx: int): y_true = y_true[mask] loss = F.binary_cross_entropy(y_pred, y_true.type(torch.float)) + # skip batch if something went wrong for some reason + if torch.isnan(loss): + return None + self.model.log( f"{self.logging_prefix}TrainLoss", loss, diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index f8828e3e4..21f4416cc 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -547,7 +547,7 @@ def training_step(self, batch, batch_idx: int): # corner case if not keep.any(): - return {"loss": 0.0} + return None # forward pass prediction = self.model(waveform) @@ -626,6 +626,10 @@ def training_step(self, batch, batch_idx: int): loss = seg_loss + vad_loss + # skip batch if something went wrong for some reason + if torch.isnan(loss): + return None + self.model.log( f"{self.logging_prefix}TrainLoss", loss, From 2623cf19807db19c7234880ee173739293e28254 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 21 Apr 2023 15:14:56 +0200 Subject: [PATCH 066/112] BREAKING(io): update Audio behavior for multi-channel audio - BREAKING(io): channels are now 0-indexed (used to be 1-indexed) - BREAKING(io): multi-channel audio is no longer downmixed to mono by default. You should update how `pyannote.audio.core.io.Audio` is instantiated: * replace `Audio()` by `Audio(mono="downmix")`; * replace `Audio(mono=True)` by `Audio(mono="downmix")`; * replace `Audio(mono=False)` by `Audio()`. --- CHANGELOG.md | 40 ++++++++++++++----- notebook/augmentation.ipynb | 2 +- pyannote/audio/core/io.py | 24 +++++++---- pyannote/audio/core/model.py | 4 +- pyannote/audio/interactive/common/utils.py | 2 +- pyannote/audio/interactive/diff/recipe.py | 2 +- pyannote/audio/interactive/pipeline/recipe.py | 2 +- pyannote/audio/interactive/review/recipe.py | 2 +- pyannote/audio/pipelines/utils/oracle.py | 2 +- pyannote/audio/utils/preview.py | 6 +-- pyannote/audio/utils/protocol.py | 2 +- tests/io_test.py | 20 +++++----- tutorials/intro.ipynb | 4 +- tutorials/speaker_verification.ipynb | 3 +- 14 files changed, 72 insertions(+), 43 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5390032d8..bf2603978 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,18 +2,40 @@ ## Version 3.0 (xxxx-xx-xx) - - feat(task): add support for label scope in speaker diarization task (from pyannote.database 5.0) - - feat(task): add support for missing classes in multi-label segmentation task (from pyannote.database 5.0) - - improve(task): load metadata as tensors rather than pyannote.core instances - - setup: switch to torch 2.0+ and lightning 2.0+ - - setup: switch to torchaudio 2.0+ and soundfile 0.12+ - - setup: switch to pyannote.core 5.0+ and pyannote.database 5.0+ - - setup: switch to speechbrain 0.5.14+ +### Breaking changes + - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` - BREAKING(task): remove support for variable chunk duration - - BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (in favor of `SpeakerDiarization` pipeline) + - BREAKING(pipeline): pipeline defaults to CPU (use `pipeline.to(device)`) + - BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (use `SpeakerDiarization` pipeline) - BREAKING(pipeline): remove support `FINCHClustering` and `HiddenMarkovModelClustering` - - BREAKING: drop support for Python 3.7 + - BREAKING(setup): drop support for Python 3.7 + - BREAKING(io): channels are now 0-indexed (used to be 1-indexed) + - BREAKING(io): multi-channel audio is no longer downmixed to mono by default. + You should update how `pyannote.audio.core.io.Audio` is instantiated: + * replace `Audio()` by `Audio(mono="downmix")`; + * replace `Audio(mono=True)` by `Audio(mono="downmix")`; + * replace `Audio(mono=False)` by `Audio()`. + +### Features and improvements + + - feat(pipeline): send pipeline to device with `pipeline.to(device)` + - feat(task): add [powerset](https://arxiv.org/PLACEHOLDER) support to `SpeakerDiarization` task + - feat(pipeline): add progress hook to pipelines + - feat(task): add support for label scope in speaker diarization task + - feat(task): add support for missing classes in multi-label segmentation task + - improve(task): load metadata as tensors rather than pyannote.core instances + +### Fixes and improvements + + - fix(pipeline): fix support for IOBase audio + - fix(pipeline): fix corner case with no speaker + +### Dependencies + + - setup: switch to torch 2.0+, torchaudio 2.0+, soundfile 0.12+, lightning 2.0+, torchmetrics 0.11+ + - setup: switch to pyannote.core 5.0+ and pyannote.database 5.0+ + - setup: switch to speechbrain 0.5.14+ ## Version 2.1.1 (2022-10-27) diff --git a/notebook/augmentation.ipynb b/notebook/augmentation.ipynb index 7af1250e4..656eae4a7 100644 --- a/notebook/augmentation.ipynb +++ b/notebook/augmentation.ipynb @@ -12,7 +12,7 @@ " preprocessors={\"audio\": FileFinder()})\n", "\n", "from pyannote.audio.core.io import Audio\n", - "audio = Audio(sample_rate=16000, mono=True)\n", + "audio = Audio(sample_rate=16000, mono=\"downmix\")\n", "file = next(protocol.test())\n", "\n", "from pyannote.core import Segment\n", diff --git a/pyannote/audio/core/io.py b/pyannote/audio/core/io.py index 34358c08f..b2e8842b1 100644 --- a/pyannote/audio/core/io.py +++ b/pyannote/audio/core/io.py @@ -28,6 +28,7 @@ """ import math +import random import warnings from io import IOBase from pathlib import Path @@ -79,12 +80,14 @@ class Audio: ---------- sample_rate: int, optional Target sampling rate. Defaults to using native sampling rate. - mono : int, optional - Convert multi-channel to mono. Defaults to True. + mono : {'random', 'downmix'}, optional + In case of multi-channel audio, convert to single-channel audio + using one of the following strategies: select one channel at + 'random' or 'downmix' by averaging all channels. Usage ----- - >>> audio = Audio(sample_rate=16000, mono=True) + >>> audio = Audio(sample_rate=16000, mono='downmix') >>> waveform, sample_rate = audio({"audio": "/path/to/audio.wav"}) >>> assert sample_rate == 16000 >>> sample_rate = 44100 @@ -181,7 +184,7 @@ def validate_file(file: AudioFile) -> Mapping: return file - def __init__(self, sample_rate=None, mono=True): + def __init__(self, sample_rate=None, mono=None): super().__init__() self.sample_rate = sample_rate @@ -206,8 +209,13 @@ def downmix_and_resample(self, waveform: Tensor, sample_rate: int) -> Tensor: """ # downmix to mono - if self.mono and waveform.shape[0] > 1: - waveform = waveform.mean(dim=0, keepdim=True) + num_channels = waveform.shape[0] + if num_channels > 1: + if self.mono == "random": + channel = random.randint(0, num_channels - 1) + waveform = waveform[channel : channel + 1] + elif self.mono == "downmix": + waveform = waveform.mean(dim=0, keepdim=True) # resample if (self.sample_rate is not None) and (self.sample_rate != sample_rate): @@ -284,7 +292,7 @@ def __call__(self, file: AudioFile) -> Tuple[Tensor, int]: channel = file.get("channel", None) if channel is not None: - waveform = waveform[channel - 1 : channel] + waveform = waveform[channel : channel + 1] return self.downmix_and_resample(waveform, sample_rate) @@ -413,7 +421,7 @@ def crop( file["sample_rate"] = sample_rate if channel is not None: - data = data[channel - 1 : channel, :] + data = data[channel : channel + 1, :] # pad with zeros if mode == "pad": diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index ec0a4a259..2054dc99b 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -272,9 +272,7 @@ def __init__( self.save_hyperparameters("sample_rate", "num_channels") self.task = task - self.audio = Audio( - sample_rate=self.hparams.sample_rate, mono=self.hparams.num_channels == 1 - ) + self.audio = Audio(sample_rate=self.hparams.sample_rate, mono="downmix") @property def example_input_array(self) -> torch.Tensor: diff --git a/pyannote/audio/interactive/common/utils.py b/pyannote/audio/interactive/common/utils.py index a51137dd3..32114ae3b 100644 --- a/pyannote/audio/interactive/common/utils.py +++ b/pyannote/audio/interactive/common/utils.py @@ -122,7 +122,7 @@ def source_to_files(source: Path) -> List[Dict]: def get_chunks(source: Path, chunk_duration: Optional[float] = None): files = source_to_files(source) - audio = Audio() + audio = Audio(mono="downmix") for file in files: diff --git a/pyannote/audio/interactive/diff/recipe.py b/pyannote/audio/interactive/diff/recipe.py index 5f33cef9d..8bd059123 100644 --- a/pyannote/audio/interactive/diff/recipe.py +++ b/pyannote/audio/interactive/diff/recipe.py @@ -60,7 +60,7 @@ def diff_stream( files_errors[filename] = errors audio_for_prodigy = AudioForProdigy() - audio_for_pipeline = Audio(mono=True) + audio_for_pipeline = Audio(mono="downmix") chunks = get_chunks(source, chunk_duration=chunk) chunks = list(chunks) chunks = sorted( diff --git a/pyannote/audio/interactive/pipeline/recipe.py b/pyannote/audio/interactive/pipeline/recipe.py index df9cc06b7..50925f708 100644 --- a/pyannote/audio/interactive/pipeline/recipe.py +++ b/pyannote/audio/interactive/pipeline/recipe.py @@ -80,7 +80,7 @@ def stream( context = getattr(pipeline, "context", 2.5) audio_for_prodigy = AudioForProdigy() - audio_for_pipeline = Audio(mono=True) + audio_for_pipeline = Audio(mono="downmix") chunks = get_chunks(source, chunk_duration=chunk) if randomize: diff --git a/pyannote/audio/interactive/review/recipe.py b/pyannote/audio/interactive/review/recipe.py index 258b51f62..9e2780f2e 100644 --- a/pyannote/audio/interactive/review/recipe.py +++ b/pyannote/audio/interactive/review/recipe.py @@ -31,7 +31,7 @@ def review_stream( files = source_to_files(source) audio_for_prodigy = AudioForProdigy() - audio_for_pipeline = Audio(mono=True) + audio_for_pipeline = Audio(mono="downmix") chunks = get_chunks(source, chunk_duration=chunk) chunks = list(chunks) diff --git a/pyannote/audio/pipelines/utils/oracle.py b/pyannote/audio/pipelines/utils/oracle.py index 77250c5da..486b09274 100644 --- a/pyannote/audio/pipelines/utils/oracle.py +++ b/pyannote/audio/pipelines/utils/oracle.py @@ -62,7 +62,7 @@ def oracle_segmentation( """ if "duration" not in file: - duration = Audio().get_duration(file) + duration = Audio(mono="downmix").get_duration(file) else: duration: float = file["duration"] reference: Annotation = file["annotation"] diff --git a/pyannote/audio/utils/preview.py b/pyannote/audio/utils/preview.py index 1b44448c6..ac085b10f 100644 --- a/pyannote/audio/utils/preview.py +++ b/pyannote/audio/utils/preview.py @@ -83,9 +83,9 @@ def listen(audio_file: AudioFile, segment: Segment = None) -> None: return if segment is None: - waveform, sr = Audio()(audio_file) + waveform, sr = Audio(mono="downmix")(audio_file) else: - waveform, sr = Audio().crop(audio_file, segment) + waveform, sr = Audio(mono="downmix").crop(audio_file, segment) return IPythonAudio(waveform.flatten(), rate=sr) @@ -159,7 +159,7 @@ def preview( temp_dir = tempfile.mkdtemp(prefix="pyannote-audio-preview") video_path = f"{temp_dir}/{uri}.{video_ext}" - audio = Audio(sample_rate=16000, mono=True) + audio = Audio(sample_rate=16000, mono="downmix") if segment is None: duration = audio.get_duration(audio_file) diff --git a/pyannote/audio/utils/protocol.py b/pyannote/audio/utils/protocol.py index a9646c5a1..0cfe4ccf2 100644 --- a/pyannote/audio/utils/protocol.py +++ b/pyannote/audio/utils/protocol.py @@ -26,7 +26,7 @@ from pyannote.audio.core.io import Audio, get_torchaudio_info -get_duration = Audio().get_duration +get_duration = Audio(mono="downmix").get_duration def check_protocol(protocol: Protocol) -> Protocol: diff --git a/tests/io_test.py b/tests/io_test.py index a07ce7403..4a582b798 100644 --- a/tests/io_test.py +++ b/tests/io_test.py @@ -1,9 +1,9 @@ import torch import torchaudio +from pyannote.core import Segment from torch import Tensor from pyannote.audio.core.io import Audio -from pyannote.core import Segment def test_audio_resample(): @@ -11,7 +11,7 @@ def test_audio_resample(): test_file = "tests/data/dev00.wav" info = torchaudio.info(test_file) old_sr = info.sample_rate - loader = Audio(old_sr // 2) + loader = Audio(sample_rate=old_sr // 2, mono="downmix") wav, sr = loader(test_file) assert isinstance(wav, Tensor) assert sr == old_sr // 2 @@ -19,7 +19,7 @@ def test_audio_resample(): def test_basic_load_with_defaults(): test_file = "tests/data/dev00.wav" - loader = Audio() + loader = Audio(mono="downmix") wav, sr = loader(test_file) assert isinstance(wav, Tensor) @@ -27,16 +27,16 @@ def test_basic_load_with_defaults(): def test_correct_audio_channel(): "When we specify an audio channel, it is chosen correctly" waveform = torch.rand(2, 16000 * 2) - loader = Audio() + loader = Audio(mono="downmix") wav, sr = loader({"waveform": waveform, "sample_rate": 16000, "channel": 1}) - assert torch.equal(wav, waveform[0:1]) + assert torch.equal(wav, waveform[1:2]) assert sr == 16000 def test_can_load_with_waveform(): "We can load a raw waveform" waveform = torch.rand(2, 16000 * 2) - loader = Audio() + loader = Audio(mono="downmix") wav, sr = loader({"waveform": waveform, "sample_rate": 16000}) assert isinstance(wav, Tensor) assert sr == 16000 @@ -45,7 +45,7 @@ def test_can_load_with_waveform(): def test_can_crop(): "Cropping works when we give a Segment" test_file = "tests/data/dev00.wav" - loader = Audio() + loader = Audio(mono="downmix") segment = Segment(0.2, 0.7) wav, sr = loader.crop(test_file, segment) assert wav.shape[1] / sr == 0.5 @@ -54,7 +54,7 @@ def test_can_crop(): def test_can_crop_waveform(): "Cropping works on raw waveforms" waveform = torch.rand(1, 16000 * 2) - loader = Audio() + loader = Audio(mono="downmix") segment = Segment(0.2, 0.7) wav, sr = loader.crop({"waveform": waveform, "sample_rate": 16000}, segment) assert isinstance(wav, Tensor) @@ -64,7 +64,7 @@ def test_can_crop_waveform(): # File Like Object Tests def test_can_load_from_file_like(): "Load entire wav of file like" - loader = Audio() + loader = Audio(mono="downmix") with open("tests/data/dev00.wav", "rb") as f: wav, sr = loader(f) @@ -75,7 +75,7 @@ def test_can_load_from_file_like(): def test_can_crop_from_file_like(): "Load cropped sections from file like objects" - loader = Audio() + loader = Audio(mono="downmix") with open("tests/data/dev00.wav", "rb") as f: segment = Segment(0.2, 0.7) diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index 8d8bf2ffa..3793bfe09 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -232,7 +232,7 @@ "source": [ "from pyannote.audio import Audio \n", "from IPython.display import Audio as IPythonAudio\n", - "waveform, sr = Audio().crop(DEMO_FILE, EXCERPT)\n", + "waveform, sr = Audio(mono=\"downmix\").crop(DEMO_FILE, EXCERPT)\n", "IPythonAudio(waveform.flatten(), rate=sr)" ] }, @@ -321,7 +321,7 @@ "notebook.reset()\n", "\n", "# load audio waveform and play it\n", - "waveform, sample_rate = Audio()(OWN_FILE)\n", + "waveform, sample_rate = Audio(mono=\"downmix\")(OWN_FILE)\n", "IPythonAudio(data=waveform.squeeze(), rate=sample_rate, autoplay=True)" ] }, diff --git a/tutorials/speaker_verification.ipynb b/tutorials/speaker_verification.ipynb index 84382e6bd..0014bed93 100644 --- a/tutorials/speaker_verification.ipynb +++ b/tutorials/speaker_verification.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -15,7 +16,7 @@ "\n", "from pyannote.audio import Audio\n", "from pyannote.core import Segment\n", - "audio = Audio(sample_rate=16000, mono=True)\n", + "audio = Audio(sample_rate=16000, mono=\"downmix\")\n", "\n", "# extract embedding for a speaker speaking between t=3s and t=6s\n", "speaker1 = Segment(3., 6.)\n", From 075514d7327d7e2440cb9992ba3db2153b2fb937 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 21 Apr 2023 15:19:36 +0200 Subject: [PATCH 067/112] doc: remove duplicated changelog file --- doc/source/changelog.rst | 98 ---------------------------------------- doc/source/index.rst | 3 -- 2 files changed, 101 deletions(-) delete mode 100644 doc/source/changelog.rst diff --git a/doc/source/changelog.rst b/doc/source/changelog.rst deleted file mode 100644 index 543449ff4..000000000 --- a/doc/source/changelog.rst +++ /dev/null @@ -1,98 +0,0 @@ -######### -Changelog -######### - -Version 2.2.x -~~~~~~~~~~~~~ - - - feat(pipeline): (BREAKING) send pipeline to device with Pipeline.to(device) - - feat(pipeline): add progress hook to pipelines - - fix(pipeline): fix support for IOBase audio - - fix(pipeline): fix corner case with no speaker - - setup: add support for soundfile >= 0.11 - - setup: add support for torchmetrics >= 0.11 - -Version 2.1.1 (2022-10-27) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - BREAKING(pipeline): rewrite speaker diarization pipeline - - feat(pipeline): add option to optimize for DER variant - - feat(clustering): add support for NeMo speaker embedding - - feat(clustering): add FINCH clustering - - feat(clustering): add min_cluster_size hparams to AgglomerativeClustering - - feat(hub): add support for private/gated models - - setup(hub): switch to latest hugginface_hub API - - fix(pipeline): fix support for missing reference in Resegmentation pipeline - - fix(clustering) fix corner case where HMM.fit finds too little states - -Version 2.0.1 (2022-07-20) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - BREAKING: complete rewrite - - feat: much better performance - - feat: Python-first API - - feat: pretrained pipelines (and models) on Huggingface model hub - - feat: multi-GPU training with pytorch-lightning - - feat: data augmentation with torch-audiomentations - - feat: Prodigy recipe for model-assisted audio annotation - -Version 1.1.2 (2021-01-28) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - fix: make sure master branch is used to load pretrained models (#599) - -Version 1.1 (2020-11-08) -~~~~~~~~~~~~~~~~~~~~~~~~ - - - last release before complete rewriting - -Version 1.0.1 (2018--07-19) -~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - fix: fix regression in Precomputed.__call__ (#110, #105) - -Version 1.0 (2018-07-03) -~~~~~~~~~~~~~~~~~~~~~~~~ - - - chore: switch from keras to pytorch (with tensorboard support) - - improve: faster & better traning (`AutoLR`, advanced learning rate schedulers, improved batch generators) - - feat: add tunable speaker diarization pipeline (with its own tutorial) - - chore: drop support for Python 2 (use Python 3.6 or later) - -Version 0.3.1 (2017-07-06) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - feat: add python 3 support - - chore: rewrite neural speaker embedding using autograd - - feat: add new embedding architectures - - feat: add new embedding losses - - chore: switch to Keras 2 - - doc: add tutorial for (MFCC) feature extraction - - doc: add tutorial for (LSTM-based) speech activity detection - - doc: add tutorial for (LSTM-based) speaker change detection - - doc: add tutorial for (TristouNet) neural speaker embedding - -Version 0.2.1 (2017-03-28) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - feat: add LSTM-based speech activity detection - - feat: add LSTM-based speaker change detection - - improve: refactor LSTM-based speaker embedding - - feat: add librosa basic support - - feat: add SMORMS3 optimizer - -Version 0.1.4 (2016-09-26) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - feat: add 'covariance_type' option to BIC segmentation - -Version 0.1.3 (2016-09-23) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - chore: rename sequence generator in preparation of the release of - TristouNet reproducible research package. - -Version 0.1.2 (2016-09-22) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - first public version diff --git a/doc/source/index.rst b/doc/source/index.rst index fae1d7803..925a460ce 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -11,7 +11,6 @@ Installation $ conda create -n pyannote python=3.10 $ conda activate pyannote - $ conda install pytorch torchvision torchaudio -c pytorch $ pip install pyannote.audio @@ -20,5 +19,3 @@ API documentation .. toctree:: :maxdepth: 2 - - changelog From 444720b987b3dfee6ca12e795ffa06aba9d3526a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 21 Apr 2023 15:53:02 +0200 Subject: [PATCH 068/112] setup: switch to pyannote.database 5.0.1 --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 22e63c5c4..e4c72019f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,7 +4,7 @@ huggingface_hub >= 0.13.0 lightning >= 2.0.1 omegaconf >=2.1,<3.0 pyannote.core >= 5.0.0 -pyannote.database >= 5.0.0 +pyannote.database >= 5.0.1 pyannote.metrics >= 3.2 pyannote.pipeline >= 2.3 # 2.4 pytorch_metric_learning >= 2.1.0 From 00e7a117bc46ebba70d66d25a88802af9eaf146a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 21 Apr 2023 17:31:12 +0200 Subject: [PATCH 069/112] feat(pipeline): check version compatibility at load time (#1340) --- CHANGELOG.md | 1 + pyannote/audio/core/model.py | 34 +++++++-------------- pyannote/audio/core/pipeline.py | 11 ++++++- pyannote/audio/utils/version.py | 52 +++++++++++++++++++++++++++++++++ 4 files changed, 73 insertions(+), 25 deletions(-) create mode 100644 pyannote/audio/utils/version.py diff --git a/CHANGELOG.md b/CHANGELOG.md index bf2603978..e6104c279 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,7 @@ - feat(pipeline): send pipeline to device with `pipeline.to(device)` - feat(task): add [powerset](https://arxiv.org/PLACEHOLDER) support to `SpeakerDiarization` task - feat(pipeline): add progress hook to pipelines + - feat(pipeline): check version compatibility at load time - feat(task): add support for label scope in speaker diarization task - feat(task): add support for missing classes in multi-label segmentation task - improve(task): load metadata as tensors rather than pyannote.core instances diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 2054dc99b..11b9da93d 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -38,12 +38,12 @@ from lightning_fabric.utilities.cloud_io import _load as pl_load from pyannote.core import SlidingWindow from pytorch_lightning.utilities.model_summary import ModelSummary -from semver import VersionInfo from torch.utils.data import DataLoader from pyannote.audio import __version__ from pyannote.audio.core.io import Audio from pyannote.audio.core.task import Problem, Resolution, Specifications, Task +from pyannote.audio.utils.version import check_version CACHE_DIR = os.getenv( "PYANNOTE_CACHE", @@ -412,41 +412,27 @@ def on_save_checkpoint(self, checkpoint): "specifications": self.specifications, } - @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: - warnings.warn( - f"Model was trained with {library} {theirs}, yours is {mine}. " - f"Bad things will probably happen unless you update {library} to {theirs.major}.x." - ) - if theirs.minor > mine.minor: - warnings.warn( - f"Model was trained with {library} {theirs}, yours is {mine}. " - f"This should be OK but you might want to update {library}." - ) - def on_load_checkpoint(self, checkpoint: Dict[str, Any]): - self.check_version( + check_version( "pyannote.audio", checkpoint["pyannote.audio"]["versions"]["pyannote.audio"], __version__, + what="Model", ) - self.check_version( + check_version( "torch", checkpoint["pyannote.audio"]["versions"]["torch"], torch.__version__, + what="Model", ) - self.check_version( - "pytorch-lightning", checkpoint["pytorch-lightning_version"], pl.__version__ + check_version( + "pytorch-lightning", + checkpoint["pytorch-lightning_version"], + pl.__version__, + what="Model", ) self.specifications = checkpoint["pyannote.audio"]["specifications"] diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index 8ebd76c6a..fb404d107 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -40,6 +40,7 @@ from pyannote.audio.core.inference import BaseInference from pyannote.audio.core.io import AudioFile from pyannote.audio.core.model import CACHE_DIR, Model +from pyannote.audio.utils.version import check_version PIPELINE_PARAMS_NAME = "config.yaml" @@ -119,6 +120,11 @@ def from_pretrained( with open(config_yml, "r") as fp: config = yaml.load(fp, Loader=yaml.SafeLoader) + if "version" in config: + check_version( + "pyannote.audio", config["version"], __version__, what="Pipeline" + ) + # initialize pipeline pipeline_name = config["pipeline"]["name"] Klass = get_class_by_name( @@ -173,7 +179,10 @@ def from_pretrained( # send pipeline to specified device if "device" in config: device = torch.device(config["device"]) - pipeline.to(device) + try: + pipeline.to(device) + except RuntimeError as e: + print(e) return pipeline diff --git a/pyannote/audio/utils/version.py b/pyannote/audio/utils/version.py new file mode 100644 index 000000000..17c51e583 --- /dev/null +++ b/pyannote/audio/utils/version.py @@ -0,0 +1,52 @@ +# MIT License +# +# Copyright (c) 2020- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from typing import Text + +from semver import VersionInfo + + +def check_version(library: Text, theirs: Text, mine: Text, what: Text = "Pipeline"): + + theirs = ".".join(theirs.split(".")[:3]) + mine = ".".join(mine.split(".")[:3]) + + theirs = VersionInfo.parse(theirs) + mine = VersionInfo.parse(mine) + + if theirs.major > mine.major: + print( + f"{what} was trained with {library} {theirs}, yours is {mine}. " + f"Bad things will probably happen unless you upgrade {library} to {theirs.major}.x." + ) + + elif theirs.major < mine.major: + print( + f"{what} was trained with {library} {theirs}, yours is {mine}. " + f"Bad things might happen unless you revert {library} to {theirs.major}.x." + ) + + elif theirs.minor > mine.minor: + print( + f"{what} was trained with {library} {theirs}, yours is {mine}. " + f"This should be OK but you might want to upgrade {library}." + ) From 95c533458016cd58db42ea4e7fe0ac378c829272 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 24 Apr 2023 14:47:33 +0200 Subject: [PATCH 070/112] feat: stop training on NaNs --- pyannote/audio/cli/train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index d8155c1bd..4b2611d37 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -45,7 +45,6 @@ @hydra.main(config_path="train_config", config_name="config") def train(cfg: DictConfig) -> Optional[float]: - # make sure to set the random seed before the instantiation of Trainer # so that each model initializes with the same weights when using DDP. seed = int(os.environ.get("PL_GLOBAL_SEED", "0")) @@ -130,6 +129,7 @@ def configure_optimizers(self): patience=100, strict=True, verbose=False, + check_finite=True, ) callbacks.append(early_stopping) From b35dd55bd2326fe05fbafab4f65a590d1427af98 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 24 Apr 2023 16:09:09 +0200 Subject: [PATCH 071/112] feat(cli): add support for AdamW --- pyannote/audio/cli/train_config/optimizer/AdamW.yaml | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 pyannote/audio/cli/train_config/optimizer/AdamW.yaml diff --git a/pyannote/audio/cli/train_config/optimizer/AdamW.yaml b/pyannote/audio/cli/train_config/optimizer/AdamW.yaml new file mode 100644 index 000000000..f917fb4ed --- /dev/null +++ b/pyannote/audio/cli/train_config/optimizer/AdamW.yaml @@ -0,0 +1,7 @@ +# @package _group_ +_target_: torch.optim.AdamW +lr: 1e-3 +betas: [0.9, 0.999] +eps: 1e-08 +weight_decay: 0.01 +amsgrad: False From c0b82d037a56f0565fcc20d04f741d5baf0f5215 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 24 Apr 2023 16:25:28 +0200 Subject: [PATCH 072/112] fix(metric): avoid division by zero --- .../torchmetrics/audio/diarization_error_rate.py | 15 ++++++--------- .../functional/audio/diarization_error_rate.py | 3 +-- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/pyannote/audio/torchmetrics/audio/diarization_error_rate.py b/pyannote/audio/torchmetrics/audio/diarization_error_rate.py index 2f43f856f..70cdc052f 100644 --- a/pyannote/audio/torchmetrics/audio/diarization_error_rate.py +++ b/pyannote/audio/torchmetrics/audio/diarization_error_rate.py @@ -105,20 +105,17 @@ def compute(self): class SpeakerConfusionRate(DiarizationErrorRate): def compute(self): - # TODO: handler corner case where speech_total == 0 - return self.speaker_confusion / self.speech_total + return self.speaker_confusion / (self.speech_total + 1e-8) class FalseAlarmRate(DiarizationErrorRate): def compute(self): - # TODO: handler corner case where speech_total == 0 - return self.false_alarm / self.speech_total + return self.false_alarm / (self.speech_total + 1e-8) class MissedDetectionRate(DiarizationErrorRate): def compute(self): - # TODO: handler corner case where speech_total == 0 - return self.missed_detection / self.speech_total + return self.missed_detection / (self.speech_total + 1e-8) class OptimalDiarizationErrorRate(Metric): @@ -234,7 +231,7 @@ def compute(self): self.speech_total, ) _, opt_threshold_idx = torch.min(der, dim=0) - return self.SpeakerConfusion[opt_threshold_idx] / self.speech_total + return self.SpeakerConfusion[opt_threshold_idx] / (self.speech_total + 1e-8) class OptimalFalseAlarmRate(OptimalDiarizationErrorRate): @@ -246,7 +243,7 @@ def compute(self): self.speech_total, ) _, opt_threshold_idx = torch.min(der, dim=0) - return self.FalseAlarm[opt_threshold_idx] / self.speech_total + return self.FalseAlarm[opt_threshold_idx] / (self.speech_total + 1e-8) class OptimalMissedDetectionRate(OptimalDiarizationErrorRate): @@ -258,4 +255,4 @@ def compute(self): self.speech_total, ) _, opt_threshold_idx = torch.min(der, dim=0) - return self.MissedDetection[opt_threshold_idx] / self.speech_total + return self.MissedDetection[opt_threshold_idx] / (self.speech_total + 1e-8) diff --git a/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py b/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py index ab1c248ed..9502a527e 100644 --- a/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py +++ b/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py @@ -124,8 +124,7 @@ def _der_compute( Diarization error rate. """ - # TODO: handle corner case where speech_total == 0 - return (false_alarm + missed_detection + speaker_confusion) / speech_total + return (false_alarm + missed_detection + speaker_confusion) / (speech_total + 1e-8) def diarization_error_rate( From 11b56a137a578db9335efc00298f6ec1932e6317 Mon Sep 17 00:00:00 2001 From: Dmitry Mukhutdinov Date: Tue, 25 Apr 2023 11:10:59 +0100 Subject: [PATCH 073/112] fix: fix broken initialization of `Audio` (#1344) --- pyannote/audio/interactive/common/utils.py | 2 +- pyannote/audio/pipelines/speaker_diarization.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/interactive/common/utils.py b/pyannote/audio/interactive/common/utils.py index 32114ae3b..6f8fcb51f 100644 --- a/pyannote/audio/interactive/common/utils.py +++ b/pyannote/audio/interactive/common/utils.py @@ -35,7 +35,7 @@ class AudioForProdigy(Audio): def __init__(self): - super().__init__(sample_rate=16000, mono=True) + super().__init__(sample_rate=16000, mono="downmix") def crop(self, path: Path, excerpt: Segment) -> Text: waveform, _ = super().crop(path, excerpt) diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 246e9df7f..481aa970a 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -165,7 +165,7 @@ def __init__( self._embedding = PretrainedSpeakerEmbedding( self.embedding, use_auth_token=use_auth_token ) - self._audio = Audio(sample_rate=self._embedding.sample_rate, mono=True) + self._audio = Audio(sample_rate=self._embedding.sample_rate, mono="downmix") metric = self._embedding.metric try: From 31143e0d44116362432a338034c5f167bcea9a85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 10 May 2023 17:19:34 +0200 Subject: [PATCH 074/112] feat(pipeline): make batch sizes mutable (#1365) * BREAKING(pipeline): default batch sizes to 1 * BREAKING(pipeline): remove `segmentation_duration` option --- CHANGELOG.md | 2 + .../audio/pipelines/speaker_diarization.py | 37 ++++++++----------- 2 files changed, 18 insertions(+), 21 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e6104c279..7421b38fd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ - BREAKING(pipeline): pipeline defaults to CPU (use `pipeline.to(device)`) - BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (use `SpeakerDiarization` pipeline) - BREAKING(pipeline): remove support `FINCHClustering` and `HiddenMarkovModelClustering` + - BREAKING(pipeline): remove `segmentation_duration` parameter from `SpeakerDiarization` pipeline (defaults to `duration` of segmentation model) - BREAKING(setup): drop support for Python 3.7 - BREAKING(io): channels are now 0-indexed (used to be 1-indexed) - BREAKING(io): multi-channel audio is no longer downmixed to mono by default. @@ -20,6 +21,7 @@ ### Features and improvements - feat(pipeline): send pipeline to device with `pipeline.to(device)` + - feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) - feat(task): add [powerset](https://arxiv.org/PLACEHOLDER) support to `SpeakerDiarization` task - feat(pipeline): add progress hook to pipelines - feat(pipeline): check version compatibility at load time diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 481aa970a..6bc81f28a 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -61,10 +61,6 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): segmentation : Model, str, or dict, optional Pretrained segmentation model. Defaults to "pyannote/segmentation@2022.07". See pyannote.audio.pipelines.utils.get_model for supported format. - segmentation_duration: float, optional - The segmentation model is applied on a window sliding over the whole audio file. - `segmentation_duration` controls the duration of this window. Defaults to the - duration used when training the model (model.specifications.duration). segmentation_step: float, optional The segmentation model is applied on a window sliding over the whole audio file. `segmentation_step` controls the step of this window, provided as a ratio of its @@ -79,9 +75,9 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): Clustering algorithm. See pyannote.audio.pipelines.clustering.Clustering for available options. Defaults to "AgglomerativeClustering". segmentation_batch_size : int, optional - Batch size used for speaker segmentation. Defaults to 32. + Batch size used for speaker segmentation. Defaults to 1. embedding_batch_size : int, optional - Batch size used for speaker embedding. Defaults to 32. + Batch size used for speaker embedding. Defaults to 1. der_variant : dict, optional Optimize for a variant of diarization error rate. Defaults to {"collar": 0.0, "skip_overlap": False}. This is used in `get_metric` @@ -108,26 +104,20 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): def __init__( self, segmentation: PipelineModel = "pyannote/segmentation@2022.07", - segmentation_duration: float = None, segmentation_step: float = 0.1, embedding: PipelineModel = "speechbrain/spkrec-ecapa-voxceleb@5c0be3875fda05e81f3c004ed8c7c06be308de1e", embedding_exclude_overlap: bool = False, clustering: str = "AgglomerativeClustering", - embedding_batch_size: int = 32, - segmentation_batch_size: int = 32, + embedding_batch_size: int = 1, + segmentation_batch_size: int = 1, der_variant: dict = None, use_auth_token: Union[Text, None] = None, ): - super().__init__() self.segmentation_model = segmentation model: Model = get_model(segmentation, use_auth_token=use_auth_token) - self.segmentation_batch_size = segmentation_batch_size - self.segmentation_duration = ( - segmentation_duration or model.specifications.duration - ) self.segmentation_step = segmentation_step self.embedding = embedding @@ -138,12 +128,13 @@ def __init__( self.der_variant = der_variant or {"collar": 0.0, "skip_overlap": False} + segmentation_duration = model.specifications.duration self._segmentation = Inference( model, - duration=self.segmentation_duration, - step=self.segmentation_step * self.segmentation_duration, + duration=segmentation_duration, + step=self.segmentation_step * segmentation_duration, skip_aggregation=True, - batch_size=self.segmentation_batch_size, + batch_size=segmentation_batch_size, ) self._frames: SlidingWindow = self._segmentation.model.introspection.frames @@ -176,6 +167,14 @@ def __init__( ) self.clustering = Klustering.value(metric=metric) + @property + def segmentation_batch_size(self) -> int: + return self._segmentation.batch_size + + @segmentation_batch_size.setter + def segmentation_batch_size(self, batch_size: int): + self._segmentation.batch_size = batch_size + def default_parameters(self): raise NotImplementedError() @@ -246,7 +245,6 @@ def get_embeddings( # bringing a massive speed up to the optimization process (and hence allowing to use # a larger search space). if self.training: - # we only re-use embeddings if they were extracted based on the same value of the # "segmentation.threshold" hyperparameter or if the segmentation model relies on # `powerset` mode @@ -351,7 +349,6 @@ def iter_waveform_and_mask(): # caching embeddings for subsequent trials # (see comments at the top of this method for more details) if self.training: - if self._segmentation.model.specifications.powerset: file["training_cache/embeddings"] = { "embeddings": embeddings, @@ -397,7 +394,6 @@ def reconstruct( for c, (cluster, (chunk, segmentation)) in enumerate( zip(hard_clusters, segmentations) ): - # cluster is (local_num_speakers, )-shaped # segmentation is (num_frames, local_num_speakers)-shaped for k in np.unique(cluster): @@ -492,7 +488,6 @@ def apply( if self.klustering == "OracleClustering": embeddings = None else: - embeddings = self.get_embeddings( file, binarized_segmentations, From a58153662b9a11485681c2a259d36e75d7243f2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 15 May 2023 09:37:49 +0200 Subject: [PATCH 075/112] improve: improve error message on missing specifications (#1371) --- CHANGELOG.md | 1 + pyannote/audio/core/model.py | 33 +++++++++++++++++++++++++++++---- pyannote/audio/core/task.py | 4 ++++ 3 files changed, 34 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7421b38fd..cf525f958 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,7 @@ - feat(task): add support for label scope in speaker diarization task - feat(task): add support for missing classes in multi-label segmentation task - improve(task): load metadata as tensors rather than pyannote.core instances + - improve(task): improve error message on missing specifications ### Fixes and improvements diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 11b9da93d..18b301086 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -42,7 +42,13 @@ from pyannote.audio import __version__ from pyannote.audio.core.io import Audio -from pyannote.audio.core.task import Problem, Resolution, Specifications, Task +from pyannote.audio.core.task import ( + Problem, + Resolution, + Specifications, + Task, + UnknownSpecificationsError, +) from pyannote.audio.utils.version import check_version CACHE_DIR = os.getenv( @@ -300,9 +306,28 @@ def task(self, task): @property def specifications(self): - if self.task is not None: - return self.task.specifications - return self._specifications + if self.task is None: + try: + specifications = self._specifications + + except AttributeError as e: + raise UnknownSpecificationsError( + "Model specifications are not available because it has not been assigned a task yet. " + "Use `model.task = ...` to assign a task to the model." + ) from e + + else: + try: + specifications = self.task.specifications + + except AttributeError as e: + raise UnknownSpecificationsError( + "Task specifications are not available. This is most likely because they depend on " + "the content of the training subset. Use `model.task.setup()` to go over the training " + "subset and fix this, or let lightning trainer do that for you in `trainer.fit(model)`." + ) from e + + return specifications @specifications.setter def specifications(self, specifications): diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index 95cca1dee..a46308f88 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -63,6 +63,10 @@ class Resolution(Enum): CHUNK = 2 # model outputs just one vector for the whole chunk +class UnknownSpecificationsError(Exception): + pass + + @dataclass class Specifications: problem: Problem From 8d25c45d2d181879a8f1f656c9230ea039922f44 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 15 May 2023 10:46:03 +0200 Subject: [PATCH 076/112] wip: improve support for fixed duration tasks --- pyannote/audio/core/model.py | 77 ++++++++++++++----- pyannote/audio/core/task.py | 10 +-- pyannote/audio/tasks/embedding/mixins.py | 15 +--- .../audio/tasks/segmentation/multilabel.py | 5 +- .../overlapped_speech_detection.py | 2 +- .../tasks/segmentation/speaker_diarization.py | 12 +-- .../segmentation/voice_activity_detection.py | 2 +- 7 files changed, 70 insertions(+), 53 deletions(-) diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 18b301086..da5c79fe8 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -65,13 +65,17 @@ class Introspection: Parameters ---------- min_num_samples: int - Minimum number of input samples + For fixed-duration models, expected number of input samples. + For variable-duration models, minimum number of input samples supported by + the model (i.e. model fails for smaller number of samples). min_num_frames: int - Corresponding minimum number of output frames + Corresponding number of output frames. inc_num_samples: int - Number of input samples leading to an increase of number of output frames + Number of input samples leading to an increase of number of output frames. + Has no meaning for fixed-duration models (set to 0). inc_num_frames: int Corresponding increase in number of output frames + Has no meaning for fixed-duration models (set to 0). dimension: int Output dimension sample_rate: int @@ -103,12 +107,46 @@ def __init__( self.sample_rate = sample_rate @classmethod - def from_model(cls, model: "Model", task: str = None) -> Introspection: + def from_model(cls, model: "Model") -> Introspection: + """ + + Parameters + ---------- + model : Model + """ specifications = model.specifications - if task is not None: - specifications = specifications[task] + duration = specifications.duration + min_duration = specifications.min_duration or duration + + # case 1: the model expects a fixed-duration chunk + if min_duration == duration: + num_samples = model.audio.get_num_samples(specifications.duration) + frames = model(model.example_input_array) + if specifications.resolution == Resolution.FRAME: + _, num_frames, dimension = frames.shape + return cls( + min_num_samples=num_samples, + min_num_frames=num_frames, + inc_num_samples=0, + inc_num_frames=0, + dimension=dimension, + sample_rate=model.hparams.sample_rate, + ) + elif specifications.resolution == Resolution.CHUNK: + _, dimension = frames.shape + return cls( + min_num_samples=num_samples, + min_num_frames=1, + inc_num_samples=0, + inc_num_frames=0, + dimension=dimension, + sample_rate=model.hparams.sample_rate, + ) + + # case 2: the model supports variable-duration chunks + # we use dichotomic search to find the minimum number of samples example_input_array = model.example_input_array batch_size, num_channels, num_samples = example_input_array.shape example_input_array = torch.randn( @@ -126,8 +164,6 @@ def from_model(cls, model: "Model", task: str = None) -> Introspection: try: with torch.no_grad(): frames = model(example_input_array[:, :, :num_samples]) - if task is not None: - frames = frames[task] except Exception: lower = num_samples else: @@ -175,8 +211,6 @@ def from_model(cls, model: "Model", task: str = None) -> Introspection: ) with torch.no_grad(): frames = model(example_input_array) - if task is not None: - frames = frames[task] num_frames = frames.shape[1] if num_frames > min_num_frames: break @@ -194,8 +228,6 @@ def from_model(cls, model: "Model", task: str = None) -> Introspection: ) with torch.no_grad(): frames = model(example_input_array) - if task is not None: - frames = frames[task] num_frames = frames.shape[1] if num_frames > min_num_frames: inc_num_frames = num_frames - min_num_frames @@ -232,6 +264,13 @@ def __call__(self, num_samples: int) -> Tuple[int, int]: Dimension of output frames """ + # case 1: the model expects a fixed-duration chunk + if self.inc_num_frames == 0: + assert num_samples == self.min_num_samples + return self.min_num_frames, self.dimension + + # case 2: the model supports variable-duration chunks + if num_samples < self.min_num_samples: return 0, self.dimension @@ -246,7 +285,14 @@ def __call__(self, num_samples: int) -> Tuple[int, int]: def frames(self) -> SlidingWindow: # HACK to support model trained before 'sample_rate' was an Introspection attribute sample_rate = getattr(self, "sample_rate", 16000) - step = (self.inc_num_samples / self.inc_num_frames) / sample_rate + + if self.inc_num_frames == 0: + step = (self.min_num_samples / self.min_num_frames) / sample_rate + else: + # FIXME: this is not 100% accurate, but it's good enough for now + # FIXME: it should probably be estimated from the maximum duration + step = (self.inc_num_samples / self.inc_num_frames) / sample_rate + return SlidingWindow(start=0.0, step=step, duration=step) @@ -368,7 +414,6 @@ def introspection(self): del self._introspection def setup(self, stage=None): - if stage == "fit": self.task.setup() @@ -421,7 +466,6 @@ def setup(self, stage=None): self.task_dependent = list(name for name, _ in after - before) def on_save_checkpoint(self, checkpoint): - # put everything pyannote.audio-specific under pyannote.audio # to avoid any future conflicts with pytorch-lightning updates checkpoint["pyannote.audio"] = { @@ -438,7 +482,6 @@ def on_save_checkpoint(self, checkpoint): } def on_load_checkpoint(self, checkpoint: Dict[str, Any]): - check_version( "pyannote.audio", checkpoint["pyannote.audio"]["versions"]["pyannote.audio"], @@ -636,7 +679,6 @@ def _helper_by_name( modules = [modules] for name, module in ModelSummary(self, max_depth=-1).named_modules: - if name not in modules: continue @@ -826,7 +868,6 @@ def from_pretrained( # HACK do not use it. Fails silently in case model does not # HACK have a config.yaml file. try: - _ = hf_hub_download( model_id, HF_LIGHTNING_CONFIG_NAME, diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index a46308f88..d02e643b4 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -72,9 +72,11 @@ class Specifications: problem: Problem resolution: Resolution - # chunk duration in seconds. - # use None for variable-length chunks - duration: Optional[float] = None + # (maximum) chunk duration in seconds + duration: float + + # (for variable-duration tasks only) minimum chunk duration in seconds + min_duration: Optional[float] = None # use that many seconds on the left- and rightmost parts of each chunk # to warm up the model. This is mostly useful for segmentation tasks. @@ -96,7 +98,6 @@ class Specifications: @cached_property def powerset(self): - if self.powerset_max_classes is None: return False @@ -302,7 +303,6 @@ def train_dataloader(self) -> DataLoader: @cached_property def logging_prefix(self): - prefix = f"{self.__class__.__name__}-" if hasattr(self.protocol, "name"): # "." has a special meaning for pytorch-lightning checkpointing diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index 00aa7e608..b02ae7f71 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -76,7 +76,6 @@ def batch_size(self, batch_size: int): self.batch_size_ = batch_size def setup(self, stage: Optional[str] = None): - # loop over the training set, remove annotated regions shorter than # chunk duration, and keep track of the reference annotations, per class. @@ -87,9 +86,7 @@ def setup(self, stage: Optional[str] = None): desc = f"Loading {self.protocol.name} training labels" for f in tqdm(iterable=self.protocol.train(), desc=desc, unit="file"): - for klass in f["annotation"].labels(): - # keep class's (long enough) speech turns... speech_turns = [ segment @@ -121,6 +118,7 @@ def setup(self, stage: Optional[str] = None): problem=Problem.REPRESENTATION, resolution=Resolution.CHUNK, duration=self.duration, + min_duration=self.min_duration, classes=sorted(self._train), ) @@ -133,7 +131,6 @@ def setup(self, stage: Optional[str] = None): def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: - return [ EqualErrorRate(compute_on_cpu=True, distances=False), BinaryAUROC(compute_on_cpu=True), @@ -155,11 +152,11 @@ def train__iter__(self): classes = list(self.specifications.classes) + # select batch-wise duration at random batch_duration = rng.uniform(self.min_duration, self.duration) num_samples = 0 while True: - # shuffle classes so that we don't always have the same # groups of classes in a batch (which might be especially # problematic for contrast-based losses like contrastive @@ -167,13 +164,11 @@ def train__iter__(self): rng.shuffle(classes) for klass in classes: - # class index in original sorted order y = self.specifications.classes.index(klass) # multiple chunks per class for _ in range(self.num_chunks_per_class): - # select one file at random (with probability proportional to its class duration) file, *_ = rng.choices( self._train[klass], @@ -227,7 +222,6 @@ def train__len__(self): return max(self.batch_size, math.ceil(duration / avg_chunk_duration)) def collate_fn(self, batch, stage="train"): - collated = default_collate(batch) if stage == "train": @@ -241,7 +235,6 @@ def collate_fn(self, batch, stage="train"): return collated def training_step(self, batch, batch_idx: int): - X, y = batch["X"], batch["y"] loss = self.model.loss_func(self.model(X), y) @@ -261,7 +254,6 @@ def training_step(self, batch, batch_idx: int): return {"loss": loss} def val__getitem__(self, idx): - if isinstance(self.protocol, SpeakerVerificationProtocol): trial = self._validation[idx] @@ -291,7 +283,6 @@ def val__getitem__(self, idx): pass def val__len__(self): - if isinstance(self.protocol, SpeakerVerificationProtocol): return len(self._validation) @@ -299,9 +290,7 @@ def val__len__(self): return 0 def validation_step(self, batch, batch_idx: int): - if isinstance(self.protocol, SpeakerVerificationProtocol): - with torch.no_grad(): emb1 = self.model(batch["X1"]).detach() emb2 = self.model(batch["X2"]).detach() diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 19270e26f..f27303e2a 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -95,7 +95,6 @@ def __init__( augmentation: BaseWaveformTransform = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): - if not isinstance(protocol, SegmentationProtocol): raise ValueError( f"MultiLabelSegmentation task expects a SegmentationProtocol but you gave {type(protocol)}. " @@ -121,7 +120,6 @@ def __init__( # specifications to setup() def setup(self, stage: Optional[str] = None): - super().setup(stage=stage) self.specifications = Specifications( @@ -129,6 +127,7 @@ def setup(self, stage: Optional[str] = None): problem=Problem.MULTI_LABEL_CLASSIFICATION, resolution=Resolution.FRAME, duration=self.duration, + min_duration=self.min_duration, warm_up=self.warm_up, ) @@ -208,7 +207,6 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): return sample def training_step(self, batch, batch_idx: int): - X = batch["X"] y_pred = self.model(X) y_true = batch["y"] @@ -238,7 +236,6 @@ def training_step(self, batch, batch_idx: int): return {"loss": loss} def validation_step(self, batch, batch_idx: int): - X = batch["X"] y_pred = self.model(X) y_true = batch["y"] diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index 658c350a7..8e6551447 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -106,7 +106,6 @@ def __init__( augmentation: BaseWaveformTransform = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): - super().__init__( protocol, duration=duration, @@ -122,6 +121,7 @@ def __init__( problem=Problem.BINARY_CLASSIFICATION, resolution=Resolution.FRAME, duration=self.duration, + min_duration=self.min_duration, warm_up=self.warm_up, classes=[ "overlap", diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index 21f4416cc..3ef0b1a17 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -143,7 +143,6 @@ def __init__( max_num_speakers: int = None, # deprecated in favor of `max_speakers_per_chunk`` loss: Literal["bce", "mse"] = None, # deprecated ): - super().__init__( protocol, duration=duration, @@ -188,12 +187,10 @@ def __init__( self.vad_loss = vad_loss def setup(self, stage: Optional[str] = None): - super().setup(stage=stage) # estimate maximum number of speakers per chunk when not provided if self.max_speakers_per_chunk is None: - training = self.metadata["subset"] == Subsets.index("train") num_unique_speakers = [] @@ -201,7 +198,6 @@ def setup(self, stage: Optional[str] = None): for file_id in track( np.where(training)[0], description=progress_description ): - annotations = self.annotations[ np.where(self.annotations["file_id"] == file_id)[0] ] @@ -280,6 +276,7 @@ def setup(self, stage: Optional[str] = None): else Problem.MONO_LABEL_CLASSIFICATION, resolution=Resolution.FRAME, duration=self.duration, + min_duration=self.min_duration, warm_up=self.warm_up, classes=[f"speaker#{i+1}" for i in range(self.max_speakers_per_chunk)], powerset_max_classes=self.max_speakers_per_frame, @@ -448,7 +445,6 @@ def segmentation_loss( """ if self.specifications.powerset: - # `clamp_min` is needed to set non-speech weight to 1. class_weight = ( torch.clamp_min(self.model.powerset.cardinality, 1.0) @@ -569,7 +565,6 @@ def training_step(self, batch, batch_idx: int): weight[:, num_frames - warm_up_right :] = 0.0 if self.specifications.powerset: - powerset = torch.nn.functional.one_hot( torch.argmax(prediction, dim=-1), self.model.powerset.num_powerset_classes, @@ -602,7 +597,6 @@ def training_step(self, batch, batch_idx: int): vad_loss = 0.0 else: - # TODO: vad_loss probably does not make sense in powerset mode # because first class (empty set of labels) does exactly this... if self.specifications.powerset: @@ -704,7 +698,6 @@ def validation_step(self, batch, batch_idx: int): weight[:, num_frames - warm_up_right :] = 0.0 if self.specifications.powerset: - powerset = torch.nn.functional.one_hot( torch.argmax(prediction, dim=-1), self.model.powerset.num_powerset_classes, @@ -740,7 +733,6 @@ def validation_step(self, batch, batch_idx: int): vad_loss = 0.0 else: - # TODO: vad_loss probably does not make sense in powerset mode # because first class (empty set of labels) does exactly this... if self.specifications.powerset: @@ -833,7 +825,6 @@ def validation_step(self, batch, batch_idx: int): # plot each sample for sample_idx in range(num_samples): - # find where in the grid it should be plotted row_idx = sample_idx // nrows col_idx = sample_idx % ncols @@ -893,7 +884,6 @@ def main(protocol: str, subset: str = "test", model: str = "pyannote/segmentatio files = list(getattr(protocol, subset)()) with Progress() as progress: - main_task = progress.add_task(protocol.name, total=len(files)) file_task = progress.add_task("Processing", total=1.0) diff --git a/pyannote/audio/tasks/segmentation/voice_activity_detection.py b/pyannote/audio/tasks/segmentation/voice_activity_detection.py index 559ff24eb..4851b7455 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -89,7 +89,6 @@ def __init__( augmentation: BaseWaveformTransform = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): - super().__init__( protocol, duration=duration, @@ -108,6 +107,7 @@ def __init__( problem=Problem.BINARY_CLASSIFICATION, resolution=Resolution.FRAME, duration=self.duration, + min_duration=self.min_duration, warm_up=self.warm_up, classes=[ "speech", From 840f0efb062fadd600e0d44b59e66954851cf419 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 15 May 2023 11:37:46 +0200 Subject: [PATCH 077/112] fix: add missing get_num_samples --- pyannote/audio/core/io.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/pyannote/audio/core/io.py b/pyannote/audio/core/io.py index b2e8842b1..0a44e75ea 100644 --- a/pyannote/audio/core/io.py +++ b/pyannote/audio/core/io.py @@ -150,7 +150,6 @@ def validate_file(file: AudioFile) -> Mapping: raise ValueError(AudioFileDocString) if "waveform" in file: - waveform: Union[np.ndarray, Tensor] = file["waveform"] if len(waveform.shape) != 2 or waveform.shape[0] > waveform.shape[1]: raise ValueError( @@ -166,7 +165,6 @@ def validate_file(file: AudioFile) -> Mapping: file.setdefault("uri", "waveform") elif "audio" in file: - if isinstance(file["audio"], IOBase): return file @@ -177,7 +175,6 @@ def validate_file(file: AudioFile) -> Mapping: file.setdefault("uri", path.stem) else: - raise ValueError( "Neither 'waveform' nor 'audio' is available for this file." ) @@ -185,7 +182,6 @@ def validate_file(file: AudioFile) -> Mapping: return file def __init__(self, sample_rate=None, mono=None): - super().__init__() self.sample_rate = sample_rate self.mono = mono @@ -257,6 +253,18 @@ def get_duration(self, file: AudioFile) -> float: return frames / sample_rate + def get_num_samples(self, duration: float, sample_rate: int = None) -> int: + """Deterministic number of samples from duration and sample rate""" + + sample_rate = sample_rate or self.sample_rate + + if sample_rate is None: + raise ValueError( + "`sample_rate` must be provided to compute number of samples." + ) + + return math.floor(duration * sample_rate) + def __call__(self, file: AudioFile) -> Tuple[Tensor, int]: """Obtain waveform @@ -359,7 +367,6 @@ def crop( num_frames = end_frame - start_frame if mode == "raise": - if num_frames > frames: raise ValueError( f"requested fixed duration ({duration:6f}s, or {num_frames:d} frames) is longer " @@ -400,7 +407,6 @@ def crop( if isinstance(file["audio"], IOBase): file["audio"].seek(0) except RuntimeError: - if isinstance(file["audio"], IOBase): msg = "torchaudio failed to seek-and-read in file-like object." raise RuntimeError(msg) From 7272caf888c1777f15999905727eb74533327792 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 15 May 2023 13:27:27 +0200 Subject: [PATCH 078/112] fix: make window_size consistent with training duration --- pyannote/audio/core/inference.py | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 9243babc1..998a3df67 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -93,7 +93,6 @@ def __init__( batch_size: int = 32, use_auth_token: Union[Text, None] = None, ): - self.model = ( model if isinstance(model, Model) @@ -240,7 +239,7 @@ def slide( and (num_frames, dimension) for frame-level tasks. """ - window_size: int = round(self.duration * sample_rate) + window_size: int = self.model.audio.get_num_samples(self.duration) step_size: int = round(self.step * sample_rate) _, num_samples = waveform.shape @@ -284,7 +283,6 @@ def slide( # process orphan last chunk if has_last_chunk: - last_output = self.infer(last_chunk[None]) if specifications.resolution == Resolution.FRAME: @@ -409,7 +407,6 @@ def crop( """ if self.window == "sliding": - if not isinstance(chunk, Segment): start = min(c.start for c in chunk) end = max(c.end for c in chunk) @@ -427,7 +424,6 @@ def crop( return SlidingWindowFeature(output.data, shifted_frames) elif self.window == "whole": - if isinstance(chunk, Segment): waveform, sample_rate = self.model.audio.crop( file, chunk, duration=duration @@ -685,7 +681,6 @@ def always_match(this: np.ndarray, that: np.ndarray, cost: float): stitches = [] for C, (chunk, activation) in enumerate(activations): - local_stitch = np.NAN * np.zeros( (sum(lookahead) + 1, num_frames, num_classes) ) @@ -693,7 +688,6 @@ def always_match(this: np.ndarray, that: np.ndarray, cost: float): for c in range( max(0, C - lookahead[0]), min(num_chunks, C + lookahead[1] + 1) ): - # extract common temporal support shift = round((C - c) * num_frames * chunks.step / chunks.duration) @@ -714,7 +708,6 @@ def always_match(this: np.ndarray, that: np.ndarray, cost: float): ) for this, that in enumerate(permutation): - # only stitch under certain condiditions matching = (c == C) or ( match_func( From 5a0d1bb253f3afa363107534278a3b2b6cddc69d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 15 May 2023 14:23:28 +0200 Subject: [PATCH 079/112] BREAKING: pad last audio chunk with zeros --- pyannote/audio/core/inference.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 998a3df67..692cf3814 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -27,6 +27,7 @@ import numpy as np import torch +import torch.nn.functional as F from einops import rearrange from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature from pytorch_lightning.utilities.memory import is_oom_error @@ -246,11 +247,12 @@ def slide( specifications = self.model.specifications resolution = specifications.resolution introspection = self.model.introspection + if resolution == Resolution.CHUNK: frames = SlidingWindow(start=0.0, duration=self.duration, step=self.step) + elif resolution == Resolution.FRAME: frames = introspection.frames - num_frames_per_chunk, dimension = introspection(window_size) # prepare complete chunks if num_samples >= window_size: @@ -267,7 +269,11 @@ def slide( num_samples - window_size ) % step_size > 0 if has_last_chunk: + # pad last chunk with zeros last_chunk: torch.Tensor = waveform[:, num_chunks * step_size :] + _, last_window_size = last_chunk.shape + last_pad = window_size - last_window_size + last_chunk = F.pad(last_chunk, (0, last_pad)) outputs: Union[List[np.ndarray], np.ndarray] = list() @@ -284,11 +290,6 @@ def slide( # process orphan last chunk if has_last_chunk: last_output = self.infer(last_chunk[None]) - - if specifications.resolution == Resolution.FRAME: - pad = num_frames_per_chunk - last_output.shape[1] - last_output = np.pad(last_output, ((0, 0), (0, pad), (0, 0))) - outputs.append(last_output) if hook is not None: hook( @@ -326,9 +327,11 @@ def slide( missing=0.0, ) + # remove padding that was added to last chunk if has_last_chunk: - num_frames = aggregated.data.shape[0] - aggregated.data = aggregated.data[: num_frames - pad, :] + aggregated.data = aggregated.crop( + Segment(0.0, num_samples / sample_rate), mode="loose" + ) return aggregated From 56b8ca503463716474ccb94ea468d785287a8966 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 23 May 2023 09:39:28 +0200 Subject: [PATCH 080/112] ci: remove codecov support (#1382) --- .github/workflows/test.yml | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index dbe2b54d8..b266179eb 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -30,11 +30,4 @@ jobs: - name: Test with pytest run: | export PYANNOTE_DATABASE_CONFIG=$GITHUB_WORKSPACE/tests/data/database.yml - pytest --cov-report=xml - - name: Upload coverage to Codecov - uses: codecov/codecov-action@v1 - with: - file: ./coverage.xml - env_vars: PYTHON - name: codecov-pyannote-audio - fail_ci_if_error: false + pytest From ad247501eb8f52bde73016c4b91ec73ceb329eca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 24 May 2023 14:46:20 +0200 Subject: [PATCH 081/112] feat(task): add support for multi-task models - BREAKING(model): get rid of (flaky) `Model.introspection` --- CHANGELOG.md | 11 +- pyannote/audio/core/inference.py | 309 ++++++++----- pyannote/audio/core/model.py | 432 +++++------------- pyannote/audio/core/task.py | 15 +- pyannote/audio/models/segmentation/PyanNet.py | 5 +- pyannote/audio/models/segmentation/debug.py | 12 +- .../pipelines/overlapped_speech_detection.py | 2 +- pyannote/audio/pipelines/resegmentation.py | 3 +- .../audio/pipelines/speaker_diarization.py | 2 +- .../audio/pipelines/speaker_verification.py | 51 ++- pyannote/audio/pipelines/utils/oracle.py | 2 +- pyannote/audio/tasks/segmentation/mixins.py | 26 +- .../audio/tasks/segmentation/multilabel.py | 18 +- .../overlapped_speech_detection.py | 17 +- .../tasks/segmentation/speaker_diarization.py | 29 +- .../segmentation/voice_activity_detection.py | 17 +- pyannote/audio/utils/multi_task.py | 59 +++ pyannote/audio/utils/powerset.py | 22 +- pyannote/audio/utils/preview.py | 4 +- 19 files changed, 474 insertions(+), 562 deletions(-) create mode 100644 pyannote/audio/utils/multi_task.py diff --git a/CHANGELOG.md b/CHANGELOG.md index cf525f958..79a2e93ab 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,10 +5,10 @@ ### Breaking changes - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` - - BREAKING(task): remove support for variable chunk duration + - BREAKING(task): remove support for variable chunk duration for segmentation tasks - BREAKING(pipeline): pipeline defaults to CPU (use `pipeline.to(device)`) - BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (use `SpeakerDiarization` pipeline) - - BREAKING(pipeline): remove support `FINCHClustering` and `HiddenMarkovModelClustering` + - BREAKING(pipeline): remove support for `FINCHClustering` and `HiddenMarkovModelClustering` - BREAKING(pipeline): remove `segmentation_duration` parameter from `SpeakerDiarization` pipeline (defaults to `duration` of segmentation model) - BREAKING(setup): drop support for Python 3.7 - BREAKING(io): channels are now 0-indexed (used to be 1-indexed) @@ -17,9 +17,16 @@ * replace `Audio()` by `Audio(mono="downmix")`; * replace `Audio(mono=True)` by `Audio(mono="downmix")`; * replace `Audio(mono=False)` by `Audio()`. + - BREAKING(model): get rid of (flaky) `Model.introspection` + If, for some weird reason, you wrote some custom code based on that, you should instead rely on: + * `Model.example_output(duration=...)` to get example output(s) + * `Model.output_frames` to get output frame resolution(s) + * `Model.output_dimension` to get output dimension(s) + ### Features and improvements + - feat(task): add support for multi-task models (for inference) - feat(pipeline): send pipeline to device with `pipeline.to(device)` - feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) - feat(task): add [powerset](https://arxiv.org/PLACEHOLDER) support to `SpeakerDiarization` task diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 692cf3814..98f72f6e9 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -1,6 +1,6 @@ # MIT License # -# Copyright (c) 2020-2021 CNRS +# Copyright (c) 2020- CNRS # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal @@ -27,19 +27,19 @@ import numpy as np import torch +import torch.nn as nn import torch.nn.functional as F from einops import rearrange from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature from pytorch_lightning.utilities.memory import is_oom_error from pyannote.audio.core.io import AudioFile -from pyannote.audio.core.model import Model +from pyannote.audio.core.model import Model, Specifications from pyannote.audio.core.task import Resolution +from pyannote.audio.utils.multi_task import map_with_specifications from pyannote.audio.utils.permutation import mae_cost_func, permutate from pyannote.audio.utils.powerset import Powerset -TaskName = Union[Text, None] - class BaseInference: pass @@ -68,10 +68,10 @@ class Inference(BaseInference): skip_aggregation : bool, optional Do not aggregate outputs when using "sliding" window. Defaults to False. skip_conversion: bool, optional - In case `model` has been trained with `powerset` mode, its output is automatically + In case a task has been trained with `powerset` mode, output is automatically converted to `multi-label`, unless `skip_conversion` is set to True. batch_size : int, optional - Batch size. Larger values make inference faster. Defaults to 32. + Batch size. Larger values (should) make inference faster. Defaults to 32. device : torch.device, optional Device used for inference. Defaults to `model.device`. In case `device` and `model.device` are different, model is sent to device. @@ -94,6 +94,8 @@ def __init__( batch_size: int = 32, use_auth_token: Union[Text, None] = None, ): + # ~~~~ model ~~~~~ + self.model = ( model if isinstance(model, Model) @@ -105,50 +107,70 @@ def __init__( ) ) - if window not in ["sliding", "whole"]: - raise ValueError('`window` must be "sliding" or "whole".') - - specifications = self.model.specifications - if specifications.resolution == Resolution.FRAME and window == "whole": - warnings.warn( - 'Using "whole" `window` inference with a frame-based model might lead to bad results ' - 'and huge memory consumption: it is recommended to set `window` to "sliding".' - ) - - self.window = window - self.skip_aggregation = skip_aggregation - if device is None: device = self.model.device self.device = device - self.pre_aggregation_hook = pre_aggregation_hook - self.model.eval() self.model.to(self.device) - # chunk duration used during training specifications = self.model.specifications - training_duration = specifications.duration - if duration is None: - duration = training_duration - elif training_duration != duration: + # ~~~~ sliding window ~~~~~ + + if window not in ["sliding", "whole"]: + raise ValueError('`window` must be "sliding" or "whole".') + + if window == "whole" and any( + s.resolution == Resolution.FRAME for s in specifications + ): + warnings.warn( + 'Using "whole" `window` inference with a frame-based model might lead to bad results ' + 'and huge memory consumption: it is recommended to set `window` to "sliding".' + ) + self.window = window + + training_duration = next(iter(specifications)).duration + duration = duration or training_duration + if training_duration != duration: warnings.warn( f"Model was trained with {training_duration:g}s chunks, and you requested " f"{duration:g}s chunks for inference: this might lead to suboptimal results." ) self.duration = duration - self.warm_up = specifications.warm_up + # ~~~~ powerset to multilabel conversion ~~~~ + + self.skip_conversion = skip_conversion + + conversion = list() + for s in specifications: + if s.powerset and not skip_conversion: + c = Powerset(len(s.classes), s.powerset_max_classes) + else: + c = nn.Identity() + conversion.append(c.to(self.device)) + + if isinstance(specifications, Specifications): + self.conversion = conversion[0] + else: + self.conversion = nn.ModuleList(conversion) + + # ~~~~ overlap-add aggregation ~~~~~ + + self.skip_aggregation = skip_aggregation + self.pre_aggregation_hook = pre_aggregation_hook + + self.warm_up = next(iter(specifications)).warm_up # Use that many seconds on the left- and rightmost parts of each chunk # to warm up the model. While the model does process those left- and right-most # parts, only the remaining central part of each chunk is used for aggregating # scores during inference. # step between consecutive chunks - if step is None: - step = 0.1 * self.duration if self.warm_up[0] == 0.0 else self.warm_up[0] + step = step or ( + 0.1 * self.duration if self.warm_up[0] == 0.0 else self.warm_up[0] + ) if step > self.duration: raise ValueError( @@ -159,23 +181,16 @@ def __init__( self.step = step self.batch_size = batch_size - self.skip_conversion = skip_conversion - if specifications.powerset and not self.skip_conversion: - self._powerset = Powerset( - len(specifications.classes), specifications.powerset_max_classes - ) - self._powerset.to(self.device) - def to(self, device: torch.device): + def to(self, device: torch.device) -> "Inference": """Send internal model to `device`""" self.model.to(device) - if self.model.specifications.powerset and not self.skip_conversion: - self._powerset.to(device) + self.conversion.to(device) self.device = device return self - def infer(self, chunks: torch.Tensor) -> np.ndarray: + def infer(self, chunks: torch.Tensor) -> Union[np.ndarray, Tuple[np.ndarray]]: """Forward pass Takes care of sending chunks to right device and outputs back to CPU @@ -187,11 +202,11 @@ def infer(self, chunks: torch.Tensor) -> np.ndarray: Returns ------- - outputs : (batch_size, ...) np.ndarray + outputs : (tuple of) (batch_size, ...) np.ndarray Model output. """ - with torch.no_grad(): + with torch.inference_mode(): try: outputs = self.model(chunks.to(self.device)) except RuntimeError as exception: @@ -203,22 +218,19 @@ def infer(self, chunks: torch.Tensor) -> np.ndarray: else: raise exception - # convert powerset to multi-label unless specifically requested not to - if self.model.specifications.powerset and not self.skip_conversion: - powerset = torch.nn.functional.one_hot( - torch.argmax(outputs, dim=-1), - self.model.specifications.num_powerset_classes, - ).float() - outputs = self._powerset.to_multilabel(powerset) + def __convert(output: torch.Tensor, conversion: nn.Module, **kwargs): + return conversion(output).cpu().numpy() - return outputs.cpu().numpy() + return map_with_specifications( + self.model.specifications, __convert, outputs, self.conversion + ) def slide( self, waveform: torch.Tensor, sample_rate: int, hook: Optional[Callable], - ) -> SlidingWindowFeature: + ) -> Union[SlidingWindowFeature, Tuple[SlidingWindowFeature]]: """Slide model on a waveform Parameters @@ -235,7 +247,7 @@ def slide( Returns ------- - output : SlidingWindowFeature + output : (tuple of) SlidingWindowFeature Model output. Shape is (num_chunks, dimension) for chunk-level tasks, and (num_frames, dimension) for frame-level tasks. """ @@ -244,15 +256,20 @@ def slide( step_size: int = round(self.step * sample_rate) _, num_samples = waveform.shape - specifications = self.model.specifications - resolution = specifications.resolution - introspection = self.model.introspection + frames = self.model.output_frames - if resolution == Resolution.CHUNK: - frames = SlidingWindow(start=0.0, duration=self.duration, step=self.step) + def __frames( + frames, specifications: Optional[Specifications] = None + ) -> SlidingWindow: + if specifications.resolution == Resolution.CHUNK: + return SlidingWindow(start=0.0, duration=self.duration, step=self.step) + return frames - elif resolution == Resolution.FRAME: - frames = introspection.frames + frames: Union[SlidingWindow, Tuple[SlidingWindow]] = map_with_specifications( + self.model.specifications, + __frames, + self.model.output_frames, + ) # prepare complete chunks if num_samples >= window_size: @@ -275,69 +292,107 @@ def slide( last_pad = window_size - last_window_size last_chunk = F.pad(last_chunk, (0, last_pad)) - outputs: Union[List[np.ndarray], np.ndarray] = list() + def __empty_list(**kwargs): + return list() + + outputs: Union[ + List[np.ndarray], Tuple[List[np.ndarray]] + ] = map_with_specifications(self.model.specifications, __empty_list) if hook is not None: hook(completed=0, total=num_chunks + has_last_chunk) + def __append_batch(output, batch_output, **kwargs) -> None: + output.append(batch_output) + return + # slide over audio chunks in batch for c in np.arange(0, num_chunks, self.batch_size): batch: torch.Tensor = chunks[c : c + self.batch_size] - outputs.append(self.infer(batch)) + + batch_outputs: Union[np.ndarray, Tuple[np.ndarray]] = self.infer(batch) + + _ = map_with_specifications( + self.model.specifications, __append_batch, outputs, batch_outputs + ) + if hook is not None: hook(completed=c + self.batch_size, total=num_chunks + has_last_chunk) # process orphan last chunk if has_last_chunk: - last_output = self.infer(last_chunk[None]) - outputs.append(last_output) + last_outputs = self.infer(last_chunk[None]) + + _ = map_with_specifications( + self.model.specifications, __append_batch, outputs, last_outputs + ) + if hook is not None: hook( completed=num_chunks + has_last_chunk, total=num_chunks + has_last_chunk, ) - outputs = np.vstack(outputs) - - # skip aggregation when requested, - # or when model outputs just one vector per chunk - # or when model is permutation-invariant (and not post-processed) - if ( - self.skip_aggregation - or specifications.resolution == Resolution.CHUNK - or ( - specifications.permutation_invariant - and self.pre_aggregation_hook is None - ) - ): - frames = SlidingWindow(start=0.0, duration=self.duration, step=self.step) - return SlidingWindowFeature(outputs, frames) - - if self.pre_aggregation_hook is not None: - outputs = self.pre_aggregation_hook(outputs) - - aggregated = self.aggregate( - SlidingWindowFeature( - outputs, - SlidingWindow(start=0.0, duration=self.duration, step=self.step), - ), - frames=frames, - warm_up=self.warm_up, - hamming=True, - missing=0.0, + def __vstack(output: List[np.ndarray], **kwargs) -> np.ndarray: + return np.vstack(output) + + outputs: Union[np.ndarray, Tuple[np.ndarray]] = map_with_specifications( + self.model.specifications, __vstack, outputs ) - # remove padding that was added to last chunk - if has_last_chunk: - aggregated.data = aggregated.crop( - Segment(0.0, num_samples / sample_rate), mode="loose" + def __aggregate( + outputs: np.ndarray, + frames: SlidingWindow, + specifications: Optional[Specifications] = None, + ) -> SlidingWindowFeature: + # skip aggregation when requested, + # or when model outputs just one vector per chunk + # or when model is permutation-invariant (and not post-processed) + if ( + self.skip_aggregation + or specifications.resolution == Resolution.CHUNK + or ( + specifications.permutation_invariant + and self.pre_aggregation_hook is None + ) + ): + frames = SlidingWindow( + start=0.0, duration=self.duration, step=self.step + ) + return SlidingWindowFeature(outputs, frames) + + if self.pre_aggregation_hook is not None: + outputs = self.pre_aggregation_hook(outputs) + + aggregated = self.aggregate( + SlidingWindowFeature( + outputs, + SlidingWindow(start=0.0, duration=self.duration, step=self.step), + ), + frames=frames, + warm_up=self.warm_up, + hamming=True, + missing=0.0, ) - return aggregated + # remove padding that was added to last chunk + if has_last_chunk: + aggregated.data = aggregated.crop( + Segment(0.0, num_samples / sample_rate), mode="loose" + ) + + return aggregated + + return map_with_specifications( + self.model.specifications, __aggregate, outputs, frames + ) def __call__( self, file: AudioFile, hook: Optional[Callable] = None - ) -> Union[SlidingWindowFeature, np.ndarray]: + ) -> Union[ + Tuple[Union[SlidingWindowFeature, np.ndarray]], + Union[SlidingWindowFeature, np.ndarray], + ]: """Run inference on a whole file Parameters @@ -352,7 +407,7 @@ def __call__( Returns ------- - output : SlidingWindowFeature or np.ndarray + output : (tuple of) SlidingWindowFeature or np.ndarray Model output, as `SlidingWindowFeature` if `window` is set to "sliding" and `np.ndarray` if is set to "whole". @@ -362,7 +417,14 @@ def __call__( if self.window == "sliding": return self.slide(waveform, sample_rate, hook=hook) - return self.infer(waveform[None])[0] + outputs: Union[np.ndarray, Tuple[np.ndarray]] = self.infer(waveform[None]) + + def __first_sample(outputs: np.ndarray, **kwargs) -> np.ndarray: + return outputs[0] + + return map_with_specifications( + self.model.specifications, __first_sample, outputs + ) def crop( self, @@ -370,7 +432,10 @@ def crop( chunk: Union[Segment, List[Segment]], duration: Optional[float] = None, hook: Optional[Callable] = None, - ) -> Union[SlidingWindowFeature, np.ndarray]: + ) -> Union[ + Tuple[Union[SlidingWindowFeature, np.ndarray]], + Union[SlidingWindowFeature, np.ndarray], + ]: """Run inference on a chunk or a list of chunks Parameters @@ -395,7 +460,7 @@ def crop( Returns ------- - output : SlidingWindowFeature or np.ndarray + output : (tuple of) SlidingWindowFeature or np.ndarray Model output, as `SlidingWindowFeature` if `window` is set to "sliding" and `np.ndarray` if is set to "whole". @@ -418,31 +483,37 @@ def crop( waveform, sample_rate = self.model.audio.crop( file, chunk, duration=duration ) - output = self.slide(waveform, sample_rate, hook=hook) - - frames = output.sliding_window - shifted_frames = SlidingWindow( - start=chunk.start, duration=frames.duration, step=frames.step - ) - return SlidingWindowFeature(output.data, shifted_frames) - - elif self.window == "whole": - if isinstance(chunk, Segment): - waveform, sample_rate = self.model.audio.crop( - file, chunk, duration=duration - ) - else: - waveform = torch.cat( - [self.model.audio.crop(file, c)[0] for c in chunk], dim=1 + outputs: Union[ + SlidingWindowFeature, Tuple[SlidingWindowFeature] + ] = self.slide(waveform, sample_rate, hook=hook) + + def __shift(output: SlidingWindowFeature, **kwargs) -> SlidingWindowFeature: + frames = output.sliding_window + shifted_frames = SlidingWindow( + start=chunk.start, duration=frames.duration, step=frames.step ) + return SlidingWindowFeature(output.data, shifted_frames) - return self.infer(waveform[None])[0] + return map_with_specifications(self.model.specifications, __shift, outputs) + if isinstance(chunk, Segment): + waveform, sample_rate = self.model.audio.crop( + file, chunk, duration=duration + ) else: - raise NotImplementedError( - f"Unsupported window type '{self.window}': should be 'sliding' or 'whole'." + waveform = torch.cat( + [self.model.audio.crop(file, c)[0] for c in chunk], dim=1 ) + outputs: Union[np.ndarray, Tuple[np.ndarray]] = self.infer(waveform[None]) + + def __first_sample(outputs: np.ndarray, **kwargs) -> np.ndarray: + return outputs[0] + + return map_with_specifications( + self.model.specifications, __first_sample, outputs + ) + @staticmethod def aggregate( scores: SlidingWindowFeature, diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index da5c79fe8..199dcfb24 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -1,6 +1,6 @@ # MIT License # -# Copyright (c) 2020-2021 CNRS +# Copyright (c) 2020- CNRS # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal @@ -49,6 +49,7 @@ Task, UnknownSpecificationsError, ) +from pyannote.audio.utils.multi_task import map_with_specifications from pyannote.audio.utils.version import check_version CACHE_DIR = os.getenv( @@ -59,241 +60,9 @@ HF_LIGHTNING_CONFIG_NAME = "config.yaml" +# NOTE: needed to backward compatibility to load models trained before pyannote.audio 3.x class Introspection: - """Model introspection - - Parameters - ---------- - min_num_samples: int - For fixed-duration models, expected number of input samples. - For variable-duration models, minimum number of input samples supported by - the model (i.e. model fails for smaller number of samples). - min_num_frames: int - Corresponding number of output frames. - inc_num_samples: int - Number of input samples leading to an increase of number of output frames. - Has no meaning for fixed-duration models (set to 0). - inc_num_frames: int - Corresponding increase in number of output frames - Has no meaning for fixed-duration models (set to 0). - dimension: int - Output dimension - sample_rate: int - Expected input sample rate - - Usage - ----- - >>> introspection = Introspection.from_model(model) - >>> isinstance(introspection.frames, SlidingWindow) - >>> num_samples = 16000 # 1s at 16kHz - >>> num_frames, dimension = introspection(num_samples) - """ - - def __init__( - self, - min_num_samples: int, - min_num_frames: int, - inc_num_samples: int, - inc_num_frames: int, - dimension: int, - sample_rate: int, - ): - super().__init__() - self.min_num_samples = min_num_samples - self.min_num_frames = min_num_frames - self.inc_num_samples = inc_num_samples - self.inc_num_frames = inc_num_frames - self.dimension = dimension - self.sample_rate = sample_rate - - @classmethod - def from_model(cls, model: "Model") -> Introspection: - """ - - Parameters - ---------- - model : Model - """ - - specifications = model.specifications - duration = specifications.duration - min_duration = specifications.min_duration or duration - - # case 1: the model expects a fixed-duration chunk - if min_duration == duration: - num_samples = model.audio.get_num_samples(specifications.duration) - frames = model(model.example_input_array) - if specifications.resolution == Resolution.FRAME: - _, num_frames, dimension = frames.shape - return cls( - min_num_samples=num_samples, - min_num_frames=num_frames, - inc_num_samples=0, - inc_num_frames=0, - dimension=dimension, - sample_rate=model.hparams.sample_rate, - ) - - elif specifications.resolution == Resolution.CHUNK: - _, dimension = frames.shape - return cls( - min_num_samples=num_samples, - min_num_frames=1, - inc_num_samples=0, - inc_num_frames=0, - dimension=dimension, - sample_rate=model.hparams.sample_rate, - ) - - # case 2: the model supports variable-duration chunks - # we use dichotomic search to find the minimum number of samples - example_input_array = model.example_input_array - batch_size, num_channels, num_samples = example_input_array.shape - example_input_array = torch.randn( - (batch_size, num_channels, num_samples), - dtype=example_input_array.dtype, - layout=example_input_array.layout, - device=example_input_array.device, - requires_grad=False, - ) - - # dichotomic search of "min_num_samples" - lower, upper, min_num_samples = 1, num_samples, None - while True: - num_samples = (lower + upper) // 2 - try: - with torch.no_grad(): - frames = model(example_input_array[:, :, :num_samples]) - except Exception: - lower = num_samples - else: - min_num_samples = num_samples - if specifications.resolution == Resolution.FRAME: - _, min_num_frames, dimension = frames.shape - elif specifications.resolution == Resolution.CHUNK: - _, dimension = frames.shape - else: - # should never happen - pass - upper = num_samples - - if lower + 1 == upper: - break - - # if "min_num_samples" is still None at this point, it means that - # the forward pass always failed and raised an exception. most likely, - # it means that there is a problem with the model definition. - # we try again without catching the exception to help the end user debug - # their model - if min_num_samples is None: - frames = model(example_input_array) - - # corner case for chunk-level tasks - if specifications.resolution == Resolution.CHUNK: - return cls( - min_num_samples=min_num_samples, - min_num_frames=1, - inc_num_samples=0, - inc_num_frames=0, - dimension=dimension, - sample_rate=model.hparams.sample_rate, - ) - - # search reasonable upper bound for "inc_num_samples" - while True: - num_samples = 2 * min_num_samples - example_input_array = torch.randn( - (batch_size, num_channels, num_samples), - dtype=example_input_array.dtype, - layout=example_input_array.layout, - device=example_input_array.device, - requires_grad=False, - ) - with torch.no_grad(): - frames = model(example_input_array) - num_frames = frames.shape[1] - if num_frames > min_num_frames: - break - - # dichotomic search of "inc_num_samples" - lower, upper = min_num_samples, num_samples - while True: - num_samples = (lower + upper) // 2 - example_input_array = torch.randn( - (batch_size, num_channels, num_samples), - dtype=example_input_array.dtype, - layout=example_input_array.layout, - device=example_input_array.device, - requires_grad=False, - ) - with torch.no_grad(): - frames = model(example_input_array) - num_frames = frames.shape[1] - if num_frames > min_num_frames: - inc_num_frames = num_frames - min_num_frames - inc_num_samples = num_samples - min_num_samples - upper = num_samples - else: - lower = num_samples - - if lower + 1 == upper: - break - - return cls( - min_num_samples=min_num_samples, - min_num_frames=min_num_frames, - inc_num_samples=inc_num_samples, - inc_num_frames=inc_num_frames, - dimension=dimension, - sample_rate=model.hparams.sample_rate, - ) - - def __call__(self, num_samples: int) -> Tuple[int, int]: - """Predict output shape, given number of input samples - - Parameters - ---------- - num_samples : int - Number of input samples. - - Returns - ------- - num_frames : int - Number of output frames - dimension : int - Dimension of output frames - """ - - # case 1: the model expects a fixed-duration chunk - if self.inc_num_frames == 0: - assert num_samples == self.min_num_samples - return self.min_num_frames, self.dimension - - # case 2: the model supports variable-duration chunks - - if num_samples < self.min_num_samples: - return 0, self.dimension - - return ( - self.min_num_frames - + self.inc_num_frames - * ((num_samples - self.min_num_samples + 1) // self.inc_num_samples), - self.dimension, - ) - - @property - def frames(self) -> SlidingWindow: - # HACK to support model trained before 'sample_rate' was an Introspection attribute - sample_rate = getattr(self, "sample_rate", 16000) - - if self.inc_num_frames == 0: - step = (self.min_num_samples / self.min_num_frames) / sample_rate - else: - # FIXME: this is not 100% accurate, but it's good enough for now - # FIXME: it should probably be estimated from the maximum duration - step = (self.inc_num_samples / self.inc_num_frames) / sample_rate - - return SlidingWindow(start=0.0, step=step, duration=step) + pass class Model(pl.LightningModule): @@ -327,31 +96,21 @@ def __init__( self.audio = Audio(sample_rate=self.hparams.sample_rate, mono="downmix") @property - def example_input_array(self) -> torch.Tensor: - batch_size = 3 if self.task is None else self.task.batch_size - duration = 2.0 if self.task is None else self.task.duration - - return torch.randn( - ( - batch_size, - self.hparams.num_channels, - int(self.hparams.sample_rate * duration), - ), - device=self.device, - ) - - @property - def task(self): + def task(self) -> Task: return self._task @task.setter - def task(self, task): + def task(self, task: Task): self._task = task - del self.introspection del self.specifications + def build(self): + # use this method to add task-dependent layers to the model + # (e.g. the final classification and activation layers) + pass + @property - def specifications(self): + def specifications(self) -> Union[Specifications, Tuple[Specifications]]: if self.task is None: try: specifications = self._specifications @@ -376,7 +135,22 @@ def specifications(self): return specifications @specifications.setter - def specifications(self, specifications): + def specifications( + self, specifications: Union[Specifications, Tuple[Specifications]] + ): + if not isinstance(specifications, (Specifications, tuple)): + raise ValueError( + "Only regular specifications or tuple of specifications are supported." + ) + + durations = set(s.duration for s in specifications) + if len(durations) > 1: + raise ValueError("All tasks must share the same (maximum) duration.") + + min_durations = set(s.min_duration for s in specifications) + if len(min_durations) > 1: + raise ValueError("All tasks must share the same minimum duration.") + self._specifications = specifications @specifications.deleter @@ -384,34 +158,70 @@ def specifications(self): if hasattr(self, "_specifications"): del self._specifications - def build(self): - # use this method to add task-dependent layers to the model - # (e.g. the final classification and activation layers) - pass + def __example_input_array(self, duration: Optional[float] = None) -> torch.Tensor: + duration = duration or next(iter(self.specifications)).duration + return torch.randn( + ( + 1, + self.hparams.num_channels, + self.audio.get_num_samples(duration), + ), + device=self.device, + ) @property - def introspection(self) -> Introspection: - """Introspection + def example_input_array(self) -> torch.Tensor: + return self.__example_input_array() + + def example_output( + self, duration: Optional[float] = None + ) -> Union[torch.Tensor, Tuple[torch.Tensor]]: + """Example output""" + example_input_array = self.__example_input_array(duration=duration) + with torch.inference_mode(): + example_output = self(example_input_array) + + if not isinstance(example_output, (torch.Tensor, tuple)): + raise ValueError( + "Models must return either a torch.Tensor or a tuple of torch.Tensor" + ) - Returns - ------- - introspection: Introspection - Model introspection - """ + return example_output - if not hasattr(self, "_introspection"): - self._introspection = Introspection.from_model(self) + @property + def output_frames( + self, + ) -> Union[Optional[SlidingWindow], Tuple[Optional[SlidingWindow]]]: + """Output frames as (tuple of) SlidingWindow(s)""" + + def __output_frames( + example_output: torch.Tensor, + specifications: Specifications = None, + ) -> Optional[SlidingWindow]: + if specifications.resolution == Resolution.FRAME: + _, num_frames, _ = example_output.shape + frame_duration = specifications.duration / num_frames + return SlidingWindow(step=frame_duration, duration=frame_duration) + + return None + + return map_with_specifications( + self.specifications, __output_frames, self.example_output() + ) + + @property + def output_dimension(self) -> Union[int, Tuple[int]]: + """Output dimension as (tuple of) int(s)""" - return self._introspection + duration = next(iter(self.specifications)).duration + example_output = self.example_output(duration=duration) - @introspection.setter - def introspection(self, introspection): - self._introspection = introspection + def __output_dimension(example_output: torch.Tensor, **kwargs) -> int: + return example_output.shape[-1] - @introspection.deleter - def introspection(self): - if hasattr(self, "_introspection"): - del self._introspection + return map_with_specifications( + self.specifications, __output_dimension, example_output + ) def setup(self, stage=None): if stage == "fit": @@ -456,9 +266,6 @@ def setup(self, stage=None): # setup custom validation metrics self.task.setup_validation_metric() - # this is to make sure introspection is performed here, once and for all - _ = self.introspection - # list of layers after adding task-dependent layers after = set((name, id(module)) for name, module in self.named_modules()) @@ -477,7 +284,6 @@ def on_save_checkpoint(self, checkpoint): "module": self.__class__.__module__, "class": self.__class__.__name__, }, - "introspection": self.introspection, "specifications": self.specifications, } @@ -507,41 +313,14 @@ def on_load_checkpoint(self, checkpoint: Dict[str, Any]): self.setup() - self.introspection = checkpoint["pyannote.audio"]["introspection"] - - def forward(self, waveforms: torch.Tensor) -> torch.Tensor: + def forward( + self, waveforms: torch.Tensor, **kwargs + ) -> Union[torch.Tensor, Tuple[torch.Tensor]]: msg = "Class {self.__class__.__name__} should define a `forward` method." raise NotImplementedError(msg) - def helper_default_activation(self, specifications: Specifications) -> nn.Module: - """Helper function for default_activation - - Parameters - ---------- - specifications: Specifications - Task specification. - - Returns - ------- - activation : nn.Module - Default activation function. - """ - - if specifications.problem == Problem.BINARY_CLASSIFICATION: - return nn.Sigmoid() - - elif specifications.problem == Problem.MONO_LABEL_CLASSIFICATION: - return nn.LogSoftmax(dim=-1) - - elif specifications.problem == Problem.MULTI_LABEL_CLASSIFICATION: - return nn.Sigmoid() - - else: - msg = "TODO: implement default activation for other types of problems" - raise NotImplementedError(msg) - # convenience function to automate the choice of the final activation function - def default_activation(self) -> nn.Module: + def default_activation(self) -> Union[nn.Module, Tuple[nn.Module]]: """Guess default activation function according to task specification * sigmoid for binary classification @@ -550,10 +329,25 @@ def default_activation(self) -> nn.Module: Returns ------- - activation : nn.Module + activation : (tuple of) nn.Module Activation. """ - return self.helper_default_activation(self.specifications) + + def __default_activation(specifications: Specifications = None) -> nn.Module: + if specifications.problem == Problem.BINARY_CLASSIFICATION: + return nn.Sigmoid() + + elif specifications.problem == Problem.MONO_LABEL_CLASSIFICATION: + return nn.LogSoftmax(dim=-1) + + elif specifications.problem == Problem.MULTI_LABEL_CLASSIFICATION: + return nn.Sigmoid() + + else: + msg = "TODO: implement default activation for other types of problems" + raise NotImplementedError(msg) + + return map_with_specifications(self.specifications, __default_activation) # training data logic is delegated to the task because the # model does not really need to know how it is being used. @@ -578,9 +372,7 @@ def validation_step(self, batch, batch_idx): def configure_optimizers(self): return torch.optim.Adam(self.parameters(), lr=1e-3) - def _helper_up_to( - self, module_name: Text, requires_grad: bool = False - ) -> List[Text]: + def __up_to(self, module_name: Text, requires_grad: bool = False) -> List[Text]: """Helper function for freeze_up_to and unfreeze_up_to""" tokens = module_name.split(".") @@ -637,7 +429,7 @@ def freeze_up_to(self, module_name: Text) -> List[Text]: If your model does not follow a sequential structure, you might want to use freeze_by_name for more control. """ - return self._helper_up_to(module_name, requires_grad=False) + return self.__up_to(module_name, requires_grad=False) def unfreeze_up_to(self, module_name: Text) -> List[Text]: """Unfreeze model up to specific module @@ -662,9 +454,9 @@ def unfreeze_up_to(self, module_name: Text) -> List[Text]: If your model does not follow a sequential structure, you might want to use freeze_by_name for more control. """ - return self._helper_up_to(module_name, requires_grad=True) + return self.__up_to(module_name, requires_grad=True) - def _helper_by_name( + def __by_name( self, modules: Union[List[Text], Text], recurse: bool = True, @@ -720,7 +512,7 @@ def freeze_by_name( ValueError if at least one of `modules` does not exist. """ - return self._helper_by_name( + return self.__by_name( modules, recurse=recurse, requires_grad=False, @@ -751,7 +543,7 @@ def unfreeze_by_name( ValueError if at least one of `modules` does not exist. """ - return self._helper_by_name(modules, recurse=recurse, requires_grad=True) + return self.__by_name(modules, recurse=recurse, requires_grad=True) @classmethod def from_pretrained( diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index d02e643b4..e8baee29f 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -97,7 +97,7 @@ class Specifications: permutation_invariant: bool = False @cached_property - def powerset(self): + def powerset(self) -> bool: if self.powerset_max_classes is None: return False @@ -120,6 +120,12 @@ def num_powerset_classes(self) -> int: ) ) + def __len__(self): + return 1 + + def __iter__(self): + yield self + class TrainDataset(IterableDataset): def __init__(self, task: Task): @@ -193,7 +199,7 @@ class Task(pl.LightningDataModule): Attributes ---------- - specifications : Specifications or dict of Specifications + specifications : Specifications or tuple of Specifications Task specifications (available after `Task.setup` has been called.) """ @@ -375,6 +381,11 @@ def common_step(self, batch, batch_idx: int, stage: Literal["train", "val"]): {"loss": loss} """ + if isinstance(self.specifications, tuple): + raise NotImplementedError( + "Default training/validation step is not implemented for multi-task." + ) + # forward pass y_pred = self.model(batch["X"]) diff --git a/pyannote/audio/models/segmentation/PyanNet.py b/pyannote/audio/models/segmentation/PyanNet.py index 1b68a32a9..5af3734b1 100644 --- a/pyannote/audio/models/segmentation/PyanNet.py +++ b/pyannote/audio/models/segmentation/PyanNet.py @@ -80,7 +80,6 @@ def __init__( num_channels: int = 1, task: Optional[Task] = None, ): - super().__init__(sample_rate=sample_rate, num_channels=num_channels, task=task) sincnet = merge_dict(self.SINCNET_DEFAULTS, sincnet) @@ -140,7 +139,6 @@ def __init__( ) def build(self): - if self.hparams.linear["num_layers"] > 0: in_features = self.hparams.linear["hidden_size"] else: @@ -148,6 +146,9 @@ def build(self): 2 if self.hparams.lstm["bidirectional"] else 1 ) + if isinstance(self.specifications, tuple): + raise ValueError("PyanNet does not support multi-tasking.") + if self.specifications.powerset: out_features = self.specifications.num_powerset_classes else: diff --git a/pyannote/audio/models/segmentation/debug.py b/pyannote/audio/models/segmentation/debug.py index 498faee27..89512320c 100644 --- a/pyannote/audio/models/segmentation/debug.py +++ b/pyannote/audio/models/segmentation/debug.py @@ -39,7 +39,6 @@ def __init__( num_channels: int = 1, task: Optional[Task] = None, ): - super().__init__(sample_rate=sample_rate, num_channels=num_channels, task=task) self.mfcc = MFCC( @@ -60,7 +59,16 @@ def __init__( def build(self): # define task-dependent layers - self.classifier = nn.Linear(32 * 2, len(self.specifications.classes)) + + if isinstance(self.specifications, tuple): + raise ValueError("SimpleSegmentationModel does not support multi-tasking.") + + if self.specifications.powerset: + out_features = self.specifications.num_powerset_classes + else: + out_features = len(self.specifications.classes) + + self.classifier = nn.Linear(32 * 2, out_features) self.activation = self.default_activation() def forward(self, waveforms: torch.Tensor) -> torch.Tensor: diff --git a/pyannote/audio/pipelines/overlapped_speech_detection.py b/pyannote/audio/pipelines/overlapped_speech_detection.py index 9b14ee10f..a326b8786 100644 --- a/pyannote/audio/pipelines/overlapped_speech_detection.py +++ b/pyannote/audio/pipelines/overlapped_speech_detection.py @@ -128,7 +128,7 @@ def __init__( # load model model = get_model(segmentation, use_auth_token=use_auth_token) - if model.introspection.dimension > 1: + if model.output_dimension > 1: inference_kwargs["pre_aggregation_hook"] = lambda scores: np.partition( scores, -2, axis=-1 )[:, :, -2, np.newaxis] diff --git a/pyannote/audio/pipelines/resegmentation.py b/pyannote/audio/pipelines/resegmentation.py index 57cf9004b..468d5087d 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -88,7 +88,6 @@ def __init__( der_variant: dict = None, use_auth_token: Union[Text, None] = None, ): - super().__init__() self.segmentation = segmentation @@ -96,7 +95,7 @@ def __init__( model: Model = get_model(segmentation, use_auth_token=use_auth_token) self._segmentation = Inference(model) - self._frames = self._segmentation.model.introspection.frames + self._frames = self._segmentation.model.output_frames self._audio = model.audio diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 6bc81f28a..038bd4676 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -136,7 +136,7 @@ def __init__( skip_aggregation=True, batch_size=segmentation_batch_size, ) - self._frames: SlidingWindow = self._segmentation.model.introspection.frames + self._frames: SlidingWindow = self._segmentation.model.output_frames if self._segmentation.model.specifications.powerset: self.segmentation = ParamDict( diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 1a672d614..f928aabbb 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -64,7 +64,6 @@ def __init__( embedding: Text = "nvidia/speakerverification_en_titanet_large", device: torch.device = None, ): - if not NEMO_IS_AVAILABLE: raise ImportError( f"'NeMo' must be installed to use '{embedding}' embeddings. " @@ -90,7 +89,6 @@ def sample_rate(self) -> int: @cached_property def dimension(self) -> int: - input_signal = torch.rand(1, self.sample_rate).to(self.device) input_signal_length = torch.tensor([self.sample_rate]).to(self.device) _, embeddings = self.model_( @@ -105,7 +103,6 @@ def metric(self) -> str: @cached_property def min_num_samples(self) -> int: - lower, upper = 2, round(0.5 * self.sample_rate) middle = (lower + upper) // 2 while lower + 1 < upper: @@ -152,7 +149,6 @@ def __call__( wav_lens = signals.shape[1] * torch.ones(batch_size) else: - batch_size_masks, _ = masks.shape assert batch_size == batch_size_masks @@ -229,7 +225,6 @@ def __init__( device: torch.device = None, use_auth_token: Union[Text, None] = None, ): - if not SPEECHBRAIN_IS_AVAILABLE: raise ImportError( f"'speechbrain' must be installed to use '{embedding}' embeddings. " @@ -281,19 +276,19 @@ def metric(self) -> str: @cached_property def min_num_samples(self) -> int: - - lower, upper = 2, round(0.5 * self.sample_rate) - middle = (lower + upper) // 2 - while lower + 1 < upper: - try: - _ = self.classifier_.encode_batch( - torch.randn(1, middle).to(self.device) - ) - upper = middle - except RuntimeError: - lower = middle - + with torch.inference_mode(): + lower, upper = 2, round(0.5 * self.sample_rate) middle = (lower + upper) // 2 + while lower + 1 < upper: + try: + _ = self.classifier_.encode_batch( + torch.randn(1, middle).to(self.device) + ) + upper = middle + except RuntimeError: + lower = middle + + middle = (lower + upper) // 2 return upper @@ -324,7 +319,6 @@ def __call__( wav_lens = signals.shape[1] * torch.ones(batch_size) else: - batch_size_masks, _ = masks.shape assert batch_size == batch_size_masks @@ -425,7 +419,7 @@ def sample_rate(self) -> int: @cached_property def dimension(self) -> int: - return self.model_.introspection.dimension + return self.model_.output_dimension @cached_property def metric(self) -> str: @@ -433,12 +427,24 @@ def metric(self) -> str: @cached_property def min_num_samples(self) -> int: - return self.model_.introspection.min_num_samples + with torch.inference_mode(): + lower, upper = 2, round(0.5 * self.sample_rate) + middle = (lower + upper) // 2 + while lower + 1 < upper: + try: + _ = self.model_(torch.randn(1, 1, middle).to(self.device)) + upper = middle + except RuntimeError: + lower = middle + + middle = (lower + upper) // 2 + + return upper def __call__( self, waveforms: torch.Tensor, masks: torch.Tensor = None ) -> np.ndarray: - with torch.no_grad(): + with torch.inference_mode(): if masks is None: embeddings = self.model_(waveforms.to(self.device)) else: @@ -557,7 +563,6 @@ def __init__( ) def apply(self, file: AudioFile) -> np.ndarray: - device = self.embedding_model_.device # read audio file and send it to GPU @@ -583,7 +588,6 @@ def main( embedding: str = "pyannote/embedding", segmentation: str = None, ): - import typer from pyannote.database import FileFinder, get_protocol from pyannote.metrics.binary_classification import det_curve @@ -601,7 +605,6 @@ def main( trials = getattr(protocol, f"{subset}_trial")() for t, trial in enumerate(tqdm(trials)): - audio1 = trial["file1"]["audio"] if audio1 not in emb: emb[audio1] = pipeline(audio1) diff --git a/pyannote/audio/pipelines/utils/oracle.py b/pyannote/audio/pipelines/utils/oracle.py index 486b09274..0b6b58f85 100644 --- a/pyannote/audio/pipelines/utils/oracle.py +++ b/pyannote/audio/pipelines/utils/oracle.py @@ -39,7 +39,7 @@ def oracle_segmentation( Simulates inference based on an (imaginary) oracle segmentation model: >>> oracle = Model.from_pretrained("oracle") - >>> assert frames == oracle.introspection.frames + >>> assert frames == oracle.output_frames >>> inference = Inference(oracle, duration=window.duration, step=window.step, skip_aggregation=True) >>> oracle_segmentation = inference(file) diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 1cdb9840d..8dbb04488 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -25,11 +25,13 @@ import random import warnings from collections import defaultdict +from functools import cached_property from typing import Dict, Optional, Sequence, Union import matplotlib.pyplot as plt import numpy as np import torch +from pyannote.core import SlidingWindow from pyannote.database.protocol import SegmentationProtocol, SpeakerDiarizationProtocol from pyannote.database.protocol.protocol import Scope, Subset from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger @@ -49,7 +51,6 @@ class SegmentationTaskMixin: """Methods common to most segmentation tasks""" def get_file(self, file_id): - file = dict() file["audio"] = str(self.audios[file_id], encoding="utf-8") @@ -121,7 +122,6 @@ def setup(self, stage: Optional[str] = None): files_iter = self.protocol.train() for file_id, file in enumerate(files_iter): - # gather metadata and update metadata_unique_values so that each metadatum # (e.g. source database or label) is represented by an integer. metadatum = dict() @@ -142,7 +142,6 @@ def setup(self, stage: Optional[str] = None): # Different files may be annotated using a different set of classes # (e.g. one database for speech/music/noise, and another one for male/female/child) if isinstance(self.protocol, SegmentationProtocol): - if "classes" in file: local_classes = file["classes"] else: @@ -191,7 +190,6 @@ def setup(self, stage: Optional[str] = None): # keep track of any other (integer or string) metadata provided by the protocol # (e.g. a "domain" key for domain-adversarial training) for key in remaining_metadata_keys: - value = file[key] if isinstance(value, str): @@ -233,7 +231,6 @@ def setup(self, stage: Optional[str] = None): # annotated regions and duration _annotated_duration = 0.0 for segment in file["annotated"]: - # skip annotated regions that are shorter than training chunk duration if segment.duration < duration: continue @@ -255,13 +252,11 @@ def setup(self, stage: Optional[str] = None): # annotations for segment, _, label in file["annotation"].itertracks(yield_label=True): - # "scope" is provided by speaker diarization protocols to indicate # whether speaker labels are local to the file ('file'), consistent across # all files in a database ('database'), or globally consistent ('global') if "scope" in file: - # 0 = 'file' # 1 = 'database' # 2 = 'global' @@ -276,7 +271,6 @@ def setup(self, stage: Optional[str] = None): database_label_idx = global_label_idx = -1 if scope > 0: # 'database' or 'global' - # update list of database-scope labels if label not in database_unique_labels: database_unique_labels.append(label) @@ -285,7 +279,6 @@ def setup(self, stage: Optional[str] = None): database_label_idx = database_unique_labels.index(label) if scope > 1: # 'global' - # update list of global-scope labels if label not in unique_labels: unique_labels.append(label) @@ -381,7 +374,6 @@ def setup(self, stage: Optional[str] = None): # iterate over files in the validation subset for file_id in validation_file_ids: - # get annotated regions in file annotated_regions = self.annotated_regions[ self.annotated_regions["file_id"] == file_id @@ -389,7 +381,6 @@ def setup(self, stage: Optional[str] = None): # iterate over annotated regions for annotated_region in annotated_regions: - # number of chunks in annotated region num_chunks = round(annotated_region["duration"] // duration) @@ -401,6 +392,15 @@ def setup(self, stage: Optional[str] = None): dtype = [("file_id", "i"), ("start", "f"), ("duration", "f")] self.validation_chunks = np.array(validation_chunks, dtype=dtype) + @cached_property + def frames(self) -> SlidingWindow: + return self.model.output_frames + + @cached_property + def num_frames_per_chunk(self) -> int: + batch_size, num_frames, num_classes = self.model.example_output().shape + return num_frames + def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: @@ -450,13 +450,11 @@ def train__iter__helper(self, rng: random.Random, **filters): num_chunks_per_file = getattr(self, "num_chunks_per_file", 1) while True: - # select one file at random (with probability proportional to its annotated duration) file_id = np.random.choice(file_ids, p=prob_annotated_duration) # generate `num_chunks_per_file` chunks from this file for _ in range(num_chunks_per_file): - # find indices of annotated regions in this file annotated_region_indices = np.where( self.annotated_regions["file_id"] == file_id @@ -510,7 +508,6 @@ def train__iter__(self): subchunks[product] = self.train__iter__helper(rng, **filters) while True: - # select one subchunk generator at random (with uniform probability) # so that it is balanced on average if balance is not None: @@ -686,7 +683,6 @@ def validation_step(self, batch, batch_idx: int): # plot each sample for sample_idx in range(num_samples): - # find where in the grid it should be plotted row_idx = sample_idx // nrows col_idx = sample_idx % ncols diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index f27303e2a..70b1e1fc8 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -25,7 +25,7 @@ import numpy as np import torch import torch.nn.functional as F -from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature +from pyannote.core import Segment, SlidingWindowFeature from pyannote.database import Protocol from pyannote.database.protocol import SegmentationProtocol from torch_audiomentations.core.transforms_interface import BaseWaveformTransform @@ -168,14 +168,6 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): sample = dict() sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) - - # TODO: this should be cached - # use model introspection to predict how many frames it will output - num_samples = sample["X"].shape[1] - num_frames, _ = self.model.introspection(num_samples) - resolution = duration / num_frames - frames = SlidingWindow(start=0.0, duration=resolution, step=resolution) - # gather all annotations of current file annotations = self.annotations[self.annotations["file_id"] == file_id] @@ -186,19 +178,19 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / resolution).astype(int) + start_idx = np.floor(start / self.frames.step).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / resolution).astype(int) + end_idx = np.ceil(end / self.frames.step).astype(int) # frame-level targets (-1 for un-annotated classes) - y = -np.ones((num_frames, len(self.classes)), dtype=np.int8) + y = -np.ones((self.num_frames_per_chunk, len(self.classes)), dtype=np.int8) y[:, self.annotated_classes[file_id]] = 0 for start, end, label in zip( start_idx, end_idx, chunk_annotations["global_label_idx"] ): y[start:end, label] = 1 - sample["y"] = SlidingWindowFeature(y, frames, labels=self.classes) + sample["y"] = SlidingWindowFeature(y, self.frames, labels=self.classes) metadata = self.metadata[file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index 8e6551447..492190938 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -24,7 +24,7 @@ from typing import Dict, Sequence, Text, Tuple, Union import numpy as np -from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature +from pyannote.core import Segment, SlidingWindowFeature from pyannote.database import Protocol from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric @@ -162,13 +162,6 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): sample = dict() sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) - # use model introspection to predict how many frames it will output - # TODO: this should be cached - num_samples = sample["X"].shape[1] - num_frames, _ = self.model.introspection(num_samples) - resolution = duration / num_frames - frames = SlidingWindow(start=0.0, duration=resolution, step=resolution) - # gather all annotations of current file annotations = self.annotations[self.annotations["file_id"] == file_id] @@ -179,17 +172,17 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / resolution).astype(int) + start_idx = np.floor(start / self.frames.step).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / resolution).astype(int) + end_idx = np.ceil(end / self.frames.step).astype(int) # frame-level targets - y = np.zeros((num_frames, 1), dtype=np.uint8) + y = np.zeros((self.num_frames_per_chunk, 1), dtype=np.uint8) for start, end in zip(start_idx, end_idx): y[start:end, 0] += 1 y = 1 * (y > 1) - sample["y"] = SlidingWindowFeature(y, frames, labels=["speech"]) + sample["y"] = SlidingWindowFeature(y, self.frames, labels=["speech"]) metadata = self.metadata[file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index 3ef0b1a17..dc3a33025 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -29,7 +29,7 @@ import torch import torch.nn.functional from matplotlib import pyplot as plt -from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature +from pyannote.core import Segment, SlidingWindowFeature from pyannote.database.protocol import SpeakerDiarizationProtocol from pyannote.database.protocol.protocol import Scope, Subset from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger @@ -327,13 +327,6 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): sample = dict() sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) - # use model introspection to predict how many frames it will output - # TODO: this should be cached - num_samples = sample["X"].shape[1] - num_frames, _ = self.model.introspection(num_samples) - resolution = duration / num_frames - frames = SlidingWindow(start=0.0, duration=resolution, step=resolution) - # gather all annotations of current file annotations = self.annotations[self.annotations["file_id"] == file_id] @@ -344,9 +337,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / resolution).astype(int) + start_idx = np.floor(start / self.frames.step).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / resolution).astype(int) + end_idx = np.ceil(end / self.frames.step).astype(int) # get list and number of labels for current scope labels = list(np.unique(chunk_annotations[label_scope_key])) @@ -356,7 +349,7 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): pass # initial frame-level targets - y = np.zeros((num_frames, num_labels), dtype=np.uint8) + y = np.zeros((self.num_frames_per_chunk, num_labels), dtype=np.uint8) # map labels to indices mapping = {label: idx for idx, label in enumerate(labels)} @@ -367,7 +360,7 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): mapped_label = mapping[label] y[start:end, mapped_label] = 1 - sample["y"] = SlidingWindowFeature(y, frames, labels=labels) + sample["y"] = SlidingWindowFeature(y, self.frames, labels=labels) metadata = self.metadata[file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} @@ -565,11 +558,7 @@ def training_step(self, batch, batch_idx: int): weight[:, num_frames - warm_up_right :] = 0.0 if self.specifications.powerset: - powerset = torch.nn.functional.one_hot( - torch.argmax(prediction, dim=-1), - self.model.powerset.num_powerset_classes, - ).float() - multilabel = self.model.powerset.to_multilabel(powerset) + multilabel = self.model.powerset.to_multilabel(prediction) permutated_target, _ = permutate(multilabel, target) permutated_target_powerset = self.model.powerset.to_powerset( permutated_target.float() @@ -698,11 +687,7 @@ def validation_step(self, batch, batch_idx: int): weight[:, num_frames - warm_up_right :] = 0.0 if self.specifications.powerset: - powerset = torch.nn.functional.one_hot( - torch.argmax(prediction, dim=-1), - self.model.powerset.num_powerset_classes, - ).float() - multilabel = self.model.powerset.to_multilabel(powerset) + multilabel = self.model.powerset.to_multilabel(prediction) permutated_target, _ = permutate(multilabel, target) # FIXME: handle case where target have too many speakers? diff --git a/pyannote/audio/tasks/segmentation/voice_activity_detection.py b/pyannote/audio/tasks/segmentation/voice_activity_detection.py index 4851b7455..d740427f0 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -23,7 +23,7 @@ from typing import Dict, Sequence, Text, Tuple, Union import numpy as np -from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature +from pyannote.core import Segment, SlidingWindowFeature from pyannote.database import Protocol from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric @@ -144,13 +144,6 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): sample = dict() sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) - # use model introspection to predict how many frames it will output - # TODO: this should be cached - num_samples = sample["X"].shape[1] - num_frames, _ = self.model.introspection(num_samples) - resolution = duration / num_frames - frames = SlidingWindow(start=0.0, duration=resolution, step=resolution) - # gather all annotations of current file annotations = self.annotations[self.annotations["file_id"] == file_id] @@ -161,16 +154,16 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / resolution).astype(int) + start_idx = np.floor(start / self.frames.step).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / resolution).astype(int) + end_idx = np.ceil(end / self.frames.step).astype(int) # frame-level targets - y = np.zeros((num_frames, 1), dtype=np.uint8) + y = np.zeros((self.num_frames_per_chunk, 1), dtype=np.uint8) for start, end in zip(start_idx, end_idx): y[start:end, 0] = 1 - sample["y"] = SlidingWindowFeature(y, frames, labels=["speech"]) + sample["y"] = SlidingWindowFeature(y, self.frames, labels=["speech"]) metadata = self.metadata[file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} diff --git a/pyannote/audio/utils/multi_task.py b/pyannote/audio/utils/multi_task.py new file mode 100644 index 000000000..3886a0eeb --- /dev/null +++ b/pyannote/audio/utils/multi_task.py @@ -0,0 +1,59 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +from typing import Any, Callable, Tuple, Union + +from pyannote.audio.core.model import Specifications + + +def map_with_specifications( + specifications: Union[Specifications, Tuple[Specifications]], + func: Callable, + *iterables, +) -> Union[Any, Tuple[Any]]: + """Compute the function using arguments from each of the iterables + + Returns a tuple if provided `specifications` is a tuple, + otherwise returns the function return value. + + Parameters + ---------- + specifications : (tuple of) Specifications + Specifications or tuple of specifications + func : callable + Function called for each specification with + `func(*iterables[i], specifications=specifications[i])` + *iterables : + List of iterables with same length as `specifications`. + + Returns + ------- + output : (tuple of) `func` return value(s) + """ + + if isinstance(specifications, Specifications): + return func(*iterables, specifications=specifications) + + return tuple( + func(*i, specifications=s) for s, *i in zip(specifications, *iterables) + ) diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index 215cb7946..0f5cfb5bc 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -85,25 +85,29 @@ def build_cardinality(self) -> torch.Tensor: return cardinality def to_multilabel(self, powerset: torch.Tensor) -> torch.Tensor: - """Convert (hard) predictions from powerset to multi-label + """Convert predictions from (soft) powerset to (hard) multi-label Parameter --------- powerset : (batch_size, num_frames, num_powerset_classes) torch.Tensor - Hard predictions in "powerset" space. + Soft predictions in "powerset" space. Returns ------- multi_label : (batch_size, num_frames, num_classes) torch.Tensor Hard predictions in "multi-label" space. - - Note - ---- - This method will not complain if `powerset` is provided a soft predictions - (e.g. the output of a softmax-ed classifier). However, in that particular - case, the resulting soft multi-label output will not make much sense. """ - return torch.matmul(powerset, self.mapping) + + hard_powerset = torch.nn.functional.one_hot( + torch.argmax(powerset, dim=-1), + self.num_powerset_classes, + ).float() + + return torch.matmul(hard_powerset, self.mapping) + + def forward(self, powerset: torch.Tensor) -> torch.Tensor: + """Alias for `to_multilabel`""" + return self.to_multilabel(powerset) def to_powerset(self, multilabel: torch.Tensor) -> torch.Tensor: """Convert (hard) predictions from multi-label to powerset diff --git a/pyannote/audio/utils/preview.py b/pyannote/audio/utils/preview.py index ac085b10f..0464b165f 100644 --- a/pyannote/audio/utils/preview.py +++ b/pyannote/audio/utils/preview.py @@ -196,7 +196,6 @@ def make_audio_frame(T: float): ylim = (-0.1, 1.1) def make_frame(T: float): - # make sure all subsequent calls to notebook.plot_* # will only display the region center on current time t = T + segment.start @@ -215,7 +214,6 @@ def make_frame(T: float): ax_wav.set_ylabel("waveform") for (name, view), ax_view in zip(views.items(), ax_views): - ax_view.clear() if isinstance(view, Timeline): @@ -258,7 +256,7 @@ def make_frame(T: float): return IPythonVideo(video_path, embed=True) -def preview_training_samples( +def BROKEN_preview_training_samples( model: Model, blank: float = 1.0, video_fps: int = 5, From c12077c2adb220a31dd6dfeb685ba3bcdb57878b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 24 May 2023 16:14:39 +0200 Subject: [PATCH 082/112] chore(task): remove `stage` argument from Task.setup --- pyannote/audio/core/task.py | 2 +- pyannote/audio/tasks/embedding/mixins.py | 4 ++-- pyannote/audio/tasks/segmentation/mixins.py | 12 +++--------- pyannote/audio/tasks/segmentation/multilabel.py | 4 ++-- .../audio/tasks/segmentation/speaker_diarization.py | 6 +++--- 5 files changed, 11 insertions(+), 17 deletions(-) diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index e8baee29f..de441590b 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -268,7 +268,7 @@ def prepare_data(self): """ pass - def setup(self, stage: Optional[str] = None): + def setup(self): """Called at the beginning of training at the very beginning of Model.setup(stage="fit") Notes diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index b02ae7f71..d83009802 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -21,7 +21,7 @@ # SOFTWARE. import math -from typing import Dict, Optional, Sequence, Union +from typing import Dict, Sequence, Union import torch import torch.nn.functional as F @@ -75,7 +75,7 @@ def batch_size(self) -> int: def batch_size(self, batch_size: int): self.batch_size_ = batch_size - def setup(self, stage: Optional[str] = None): + def setup(self): # loop over the training set, remove annotated regions shorter than # chunk duration, and keep track of the reference annotations, per class. diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 8dbb04488..016d2032d 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -26,7 +26,7 @@ import warnings from collections import defaultdict from functools import cached_property -from typing import Dict, Optional, Sequence, Union +from typing import Dict, Sequence, Union import matplotlib.pyplot as plt import numpy as np @@ -73,14 +73,8 @@ def get_file(self, file_id): return file - def setup(self, stage: Optional[str] = None): - """Setup method - - Parameters - ---------- - stage : {'fit', 'validate', 'test'}, optional - Setup stage. Defaults to 'fit'. - """ + def setup(self): + """Setup""" # duration of training chunks # TODO: handle variable duration case diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 70b1e1fc8..3afdd6bda 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -119,8 +119,8 @@ def __init__( # classes should be detected. therefore, we postpone the definition of # specifications to setup() - def setup(self, stage: Optional[str] = None): - super().setup(stage=stage) + def setup(self): + super().setup() self.specifications = Specifications( classes=self.classes, diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index dc3a33025..b5ffe3da1 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -23,7 +23,7 @@ import math import warnings from collections import Counter -from typing import Dict, Literal, Optional, Sequence, Text, Tuple, Union +from typing import Dict, Literal, Sequence, Text, Tuple, Union import numpy as np import torch @@ -186,8 +186,8 @@ def __init__( self.weight = weight self.vad_loss = vad_loss - def setup(self, stage: Optional[str] = None): - super().setup(stage=stage) + def setup(self): + super().setup() # estimate maximum number of speakers per chunk when not provided if self.max_speakers_per_chunk is None: From d19a728a0c157491a50eedc31035957d75ef3d31 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 24 May 2023 17:17:08 +0200 Subject: [PATCH 083/112] fix(test): force test training to run on CPU --- tests/inference_test.py | 9 +- tests/test_train.py | 44 ++++----- tutorials/add_your_own_task.ipynb | 100 ++++++++++---------- tutorials/overlapped_speech_detection.ipynb | 18 +++- 4 files changed, 92 insertions(+), 79 deletions(-) diff --git a/tests/inference_test.py b/tests/inference_test.py index 807f94cc1..bd5040394 100644 --- a/tests/inference_test.py +++ b/tests/inference_test.py @@ -1,13 +1,13 @@ import numpy as np import pytest import pytorch_lightning as pl +from pyannote.core import SlidingWindowFeature +from pyannote.database import FileFinder, get_protocol from pyannote.audio import Inference, Model from pyannote.audio.core.task import Resolution from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel from pyannote.audio.tasks import VoiceActivityDetection -from pyannote.core import SlidingWindowFeature -from pyannote.database import FileFinder, get_protocol HF_SAMPLE_MODEL_ID = "pyannote/TestModelForContinuousIntegration" @@ -29,8 +29,8 @@ def trained(): ) vad = VoiceActivityDetection(protocol, duration=2.0, batch_size=16, num_workers=4) model = SimpleSegmentationModel(task=vad) - trainer = pl.Trainer(fast_dev_run=True) - trainer.fit(model, vad) + trainer = pl.Trainer(fast_dev_run=True, accelerator="cpu") + trainer.fit(model) return protocol, model @@ -91,7 +91,6 @@ def test_on_file_path(trained): def test_skip_aggregation(pretrained_model, dev_file): - inference = Inference(pretrained_model, skip_aggregation=True) scores = inference(dev_file) assert len(scores.data.shape) == 3 diff --git a/tests/test_train.py b/tests/test_train.py index 79e7f071a..7a7bfe338 100644 --- a/tests/test_train.py +++ b/tests/test_train.py @@ -20,125 +20,119 @@ def protocol(): def test_train_segmentation(protocol): segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_train_voice_activity_detection(protocol): voice_activity_detection = VoiceActivityDetection(protocol) model = SimpleSegmentationModel(task=voice_activity_detection) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_train_overlapped_speech_detection(protocol): overlapped_speech_detection = OverlappedSpeechDetection(protocol) model = SimpleSegmentationModel(task=overlapped_speech_detection) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_finetune_with_task_that_does_not_need_setup_for_specs(protocol): voice_activity_detection = VoiceActivityDetection(protocol) model = SimpleSegmentationModel(task=voice_activity_detection) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) voice_activity_detection = VoiceActivityDetection(protocol) model.task = voice_activity_detection - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_finetune_with_task_that_needs_setup_for_specs(protocol): segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) segmentation = SpeakerDiarization(protocol) model.task = segmentation - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_transfer_with_task_that_does_not_need_setup_for_specs(protocol): - segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) voice_activity_detection = VoiceActivityDetection(protocol) model.task = voice_activity_detection - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_transfer_with_task_that_needs_setup_for_specs(protocol): - voice_activity_detection = VoiceActivityDetection(protocol) model = SimpleSegmentationModel(task=voice_activity_detection) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) segmentation = SpeakerDiarization(protocol) model.task = segmentation - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_finetune_freeze_with_task_that_needs_setup_for_specs(protocol): - segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) segmentation = SpeakerDiarization(protocol) model.task = segmentation model.freeze_up_to("mfcc") - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_finetune_freeze_with_task_that_does_not_need_setup_for_specs(protocol): - vad = VoiceActivityDetection(protocol) model = SimpleSegmentationModel(task=vad) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) vad = VoiceActivityDetection(protocol) model.task = vad model.freeze_up_to("mfcc") - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_transfer_freeze_with_task_that_does_not_need_setup_for_specs(protocol): - segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) voice_activity_detection = VoiceActivityDetection(protocol) model.task = voice_activity_detection model.freeze_up_to("mfcc") - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) def test_transfer_freeze_with_task_that_needs_setup_for_specs(protocol): - voice_activity_detection = VoiceActivityDetection(protocol) model = SimpleSegmentationModel(task=voice_activity_detection) - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) segmentation = SpeakerDiarization(protocol) model.task = segmentation model.freeze_up_to("mfcc") - trainer = Trainer(fast_dev_run=True) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) diff --git a/tutorials/add_your_own_task.ipynb b/tutorials/add_your_own_task.ipynb index b2053f459..251846957 100644 --- a/tutorials/add_your_own_task.ipynb +++ b/tutorials/add_your_own_task.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -32,6 +33,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -48,6 +50,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -57,6 +60,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -82,6 +86,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -125,6 +130,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -176,54 +182,52 @@ " augmentation=augmentation,\n", " )\n", "\n", - " def setup(self, stage=None):\n", - "\n", - " if stage == \"fit\":\n", - "\n", - " # load metadata for training subset\n", - " self.train_metadata_ = list()\n", - " for training_file in self.protocol.train():\n", - " self.training_metadata_.append({\n", - " # path to audio file (str)\n", - " \"audio\": training_file[\"audio\"],\n", - " # duration of audio file (float)\n", - " \"duration\": training_file[\"duration\"],\n", - " # reference annotation (pyannote.core.Annotation)\n", - " \"annotation\": training_file[\"annotation\"],\n", - " })\n", - "\n", - " # gather the list of classes\n", - " classes = set()\n", - " for training_file in self.train_metadata_:\n", - " classes.update(training_file[\"reference\"].labels())\n", - " classes = sorted(classes)\n", - "\n", - " # specify the addressed problem\n", - " self.specifications = Specifications(\n", - " # it is a multi-label classification problem\n", - " problem=Problem.MULTI_LABEL_CLASSIFICATION,\n", - " # we expect the model to output one prediction \n", - " # for the whole chunk\n", - " resolution=Resolution.CHUNK,\n", - " # the model will ingest chunks with that duration (in seconds)\n", - " duration=self.duration,\n", - " # human-readable names of classes\n", - " classes=classes)\n", - "\n", - " # `has_validation` is True iff protocol defines a development set\n", - " if not self.has_validation:\n", - " return\n", - "\n", - " # load metadata for validation subset\n", - " self.validation_metadata_ = list()\n", - " for validation_file in self.protocol.development():\n", - " self.validation_metadata_.append({\n", - " \"audio\": validation_file[\"audio\"],\n", - " \"num_samples\": math.floor(validation_file[\"duration\"] / self.duration),\n", - " \"annotation\": validation_file[\"annotation\"],\n", - " })\n", - " \n", - " \n", + " def setup(self):\n", + "\n", + " # load metadata for training subset\n", + " self.train_metadata_ = list()\n", + " for training_file in self.protocol.train():\n", + " self.training_metadata_.append({\n", + " # path to audio file (str)\n", + " \"audio\": training_file[\"audio\"],\n", + " # duration of audio file (float)\n", + " \"duration\": training_file[\"duration\"],\n", + " # reference annotation (pyannote.core.Annotation)\n", + " \"annotation\": training_file[\"annotation\"],\n", + " })\n", + "\n", + " # gather the list of classes\n", + " classes = set()\n", + " for training_file in self.train_metadata_:\n", + " classes.update(training_file[\"reference\"].labels())\n", + " classes = sorted(classes)\n", + "\n", + " # specify the addressed problem\n", + " self.specifications = Specifications(\n", + " # it is a multi-label classification problem\n", + " problem=Problem.MULTI_LABEL_CLASSIFICATION,\n", + " # we expect the model to output one prediction \n", + " # for the whole chunk\n", + " resolution=Resolution.CHUNK,\n", + " # the model will ingest chunks with that duration (in seconds)\n", + " duration=self.duration,\n", + " # human-readable names of classes\n", + " classes=classes)\n", + "\n", + " # `has_validation` is True iff protocol defines a development set\n", + " if not self.has_validation:\n", + " return\n", + "\n", + " # load metadata for validation subset\n", + " self.validation_metadata_ = list()\n", + " for validation_file in self.protocol.development():\n", + " self.validation_metadata_.append({\n", + " \"audio\": validation_file[\"audio\"],\n", + " \"num_samples\": math.floor(validation_file[\"duration\"] / self.duration),\n", + " \"annotation\": validation_file[\"annotation\"],\n", + " })\n", + " \n", + " \n", "\n", " def train__iter__(self):\n", " # this method generates training samples, one at a time, \"ad infinitum\". each worker \n", diff --git a/tutorials/overlapped_speech_detection.ipynb b/tutorials/overlapped_speech_detection.ipynb index 78c6372cb..1ad5d4090 100644 --- a/tutorials/overlapped_speech_detection.ipynb +++ b/tutorials/overlapped_speech_detection.ipynb @@ -20,6 +20,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -39,6 +40,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -49,6 +51,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -84,6 +87,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -103,6 +107,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -110,6 +115,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -130,6 +136,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -147,6 +154,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -161,10 +169,11 @@ "source": [ "import pytorch_lightning as pl\n", "trainer = pl.Trainer(max_epochs=10)\n", - "trainer.fit(model, osd)" + "trainer.fit(model)" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -185,6 +194,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -212,6 +222,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -219,6 +230,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -242,6 +254,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -258,6 +271,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -265,6 +279,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -297,6 +312,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ From 7ea9c9ac72e07f6afc3a103256e0fe7d640adffc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 24 May 2023 17:24:31 +0200 Subject: [PATCH 084/112] fix(train): prevent metadata preparation to happen twice cc @clement-pages --- CHANGELOG.md | 1 + pyannote/audio/core/model.py | 5 +++-- pyannote/audio/core/task.py | 28 ++++++++++++++++++++++-- pyannote/audio/tasks/embedding/mixins.py | 3 --- 4 files changed, 30 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 79a2e93ab..64eaea2ce 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -41,6 +41,7 @@ - fix(pipeline): fix support for IOBase audio - fix(pipeline): fix corner case with no speaker + - fix(train): prevent metadata preparation to happen twice ### Dependencies diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 199dcfb24..2286f010f 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -101,8 +101,8 @@ def task(self) -> Task: @task.setter def task(self, task: Task): - self._task = task del self.specifications + self._task = task def build(self): # use this method to add task-dependent layers to the model @@ -225,7 +225,7 @@ def __output_dimension(example_output: torch.Tensor, **kwargs) -> int: def setup(self, stage=None): if stage == "fit": - self.task.setup() + self.task.setup_metadata() # list of layers before adding task-dependent layers before = set((name, id(module)) for name, module in self.named_modules()) @@ -311,6 +311,7 @@ def on_load_checkpoint(self, checkpoint: Dict[str, Any]): self.specifications = checkpoint["pyannote.audio"]["specifications"] + # add task-dependent (e.g. final classifier) layers self.setup() def forward( diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index de441590b..b7a626bd9 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -268,7 +268,28 @@ def prepare_data(self): """ pass - def setup(self): + @property + def specifications(self) -> Union[Specifications, Tuple[Specifications]]: + # setup metadata on-demand the first time specifications are requested and missing + if not hasattr(self, "_specifications"): + self.setup_metadata() + return self._specifications + + @specifications.setter + def specifications( + self, specifications: Union[Specifications, Tuple[Specifications]] + ): + self._specifications = specifications + + @property + def has_setup_metadata(self): + return getattr(self, "_has_setup_metadata", False) + + @has_setup_metadata.setter + def has_setup_metadata(self, value: bool): + self._has_setup_metadata = value + + def setup_metadata(self): """Called at the beginning of training at the very beginning of Model.setup(stage="fit") Notes @@ -278,7 +299,10 @@ def setup(self): If `specifications` attribute has not been set in `__init__`, `setup` is your last chance to set it. """ - pass + + if not self.has_setup_metadata: + self.setup() + self.has_setup_metadata = True def setup_loss_func(self): pass diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index d83009802..4bc51c9b5 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -79,9 +79,6 @@ def setup(self): # loop over the training set, remove annotated regions shorter than # chunk duration, and keep track of the reference annotations, per class. - # FIXME: it looks like this time consuming step is called multiple times. - # it should not be... - self._train = dict() desc = f"Loading {self.protocol.name} training labels" From 93ab70a33c228fd1bf8a50321ae8ae8b1cd8f0dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 24 May 2023 22:22:07 +0200 Subject: [PATCH 085/112] fix: tentative fix for CUDA error --- CHANGELOG.md | 4 +- pyannote/audio/core/inference.py | 4 +- pyannote/audio/core/model.py | 70 +++++++++---------- .../pipelines/overlapped_speech_detection.py | 2 +- pyannote/audio/pipelines/resegmentation.py | 2 +- .../audio/pipelines/speaker_diarization.py | 2 +- .../audio/pipelines/speaker_verification.py | 2 +- pyannote/audio/pipelines/utils/oracle.py | 2 +- pyannote/audio/tasks/segmentation/mixins.py | 11 --- .../audio/tasks/segmentation/multilabel.py | 12 ++-- .../overlapped_speech_detection.py | 10 +-- .../tasks/segmentation/speaker_diarization.py | 10 +-- .../segmentation/voice_activity_detection.py | 10 +-- 13 files changed, 68 insertions(+), 73 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 64eaea2ce..66a5a7f69 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,8 +20,8 @@ - BREAKING(model): get rid of (flaky) `Model.introspection` If, for some weird reason, you wrote some custom code based on that, you should instead rely on: * `Model.example_output(duration=...)` to get example output(s) - * `Model.output_frames` to get output frame resolution(s) - * `Model.output_dimension` to get output dimension(s) + * `Model.example_output.frames` to get output frame resolution(s) + * `Model.example_output.dimension` to get output dimension(s) ### Features and improvements diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 98f72f6e9..a4847b83e 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -256,7 +256,7 @@ def slide( step_size: int = round(self.step * sample_rate) _, num_samples = waveform.shape - frames = self.model.output_frames + frames = self.model.example_output.frames def __frames( frames, specifications: Optional[Specifications] = None @@ -268,7 +268,7 @@ def __frames( frames: Union[SlidingWindow, Tuple[SlidingWindow]] = map_with_specifications( self.model.specifications, __frames, - self.model.output_frames, + self.model.example_output.frames, ) # prepare complete chunks diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 2286f010f..5cb6c0e6b 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -24,6 +24,8 @@ import os import warnings +from dataclasses import dataclass +from functools import cached_property from importlib import import_module from pathlib import Path from typing import Any, Dict, List, Optional, Text, Tuple, Union @@ -65,6 +67,13 @@ class Introspection: pass +@dataclass +class Output: + num_frames: int + dimension: int + frames: SlidingWindow + + class Model(pl.LightningModule): """Base model @@ -101,7 +110,12 @@ def task(self) -> Task: @task.setter def task(self, task: Task): + # reset (cached) properties when task changes del self.specifications + try: + del self.example_output + except AttributeError: + pass self._task = task def build(self): @@ -173,54 +187,33 @@ def __example_input_array(self, duration: Optional[float] = None) -> torch.Tenso def example_input_array(self) -> torch.Tensor: return self.__example_input_array() - def example_output( - self, duration: Optional[float] = None - ) -> Union[torch.Tensor, Tuple[torch.Tensor]]: + @cached_property + def example_output(self) -> Union[Output, Tuple[Output]]: """Example output""" - example_input_array = self.__example_input_array(duration=duration) + example_input_array = self.__example_input_array() with torch.inference_mode(): example_output = self(example_input_array) - if not isinstance(example_output, (torch.Tensor, tuple)): - raise ValueError( - "Models must return either a torch.Tensor or a tuple of torch.Tensor" - ) - - return example_output - - @property - def output_frames( - self, - ) -> Union[Optional[SlidingWindow], Tuple[Optional[SlidingWindow]]]: - """Output frames as (tuple of) SlidingWindow(s)""" - - def __output_frames( + def __example_output( example_output: torch.Tensor, specifications: Specifications = None, - ) -> Optional[SlidingWindow]: + ) -> Output: + _, num_frames, dimension = example_output.shape + if specifications.resolution == Resolution.FRAME: - _, num_frames, _ = example_output.shape frame_duration = specifications.duration / num_frames - return SlidingWindow(step=frame_duration, duration=frame_duration) - - return None - - return map_with_specifications( - self.specifications, __output_frames, self.example_output() - ) - - @property - def output_dimension(self) -> Union[int, Tuple[int]]: - """Output dimension as (tuple of) int(s)""" - - duration = next(iter(self.specifications)).duration - example_output = self.example_output(duration=duration) + frames = SlidingWindow(step=frame_duration, duration=frame_duration) + else: + frames = None - def __output_dimension(example_output: torch.Tensor, **kwargs) -> int: - return example_output.shape[-1] + return Output( + num_frames=num_frames, + dimension=dimension, + frames=frames, + ) return map_with_specifications( - self.specifications, __output_dimension, example_output + self.specifications, __example_output, example_output ) def setup(self, stage=None): @@ -266,6 +259,9 @@ def setup(self, stage=None): # setup custom validation metrics self.task.setup_validation_metric() + # cache for later (and to avoid later CUDA error with multiprocessing) + _ = self.example_output + # list of layers after adding task-dependent layers after = set((name, id(module)) for name, module in self.named_modules()) diff --git a/pyannote/audio/pipelines/overlapped_speech_detection.py b/pyannote/audio/pipelines/overlapped_speech_detection.py index a326b8786..064cae1be 100644 --- a/pyannote/audio/pipelines/overlapped_speech_detection.py +++ b/pyannote/audio/pipelines/overlapped_speech_detection.py @@ -128,7 +128,7 @@ def __init__( # load model model = get_model(segmentation, use_auth_token=use_auth_token) - if model.output_dimension > 1: + if model.example_output.dimension > 1: inference_kwargs["pre_aggregation_hook"] = lambda scores: np.partition( scores, -2, axis=-1 )[:, :, -2, np.newaxis] diff --git a/pyannote/audio/pipelines/resegmentation.py b/pyannote/audio/pipelines/resegmentation.py index 468d5087d..bb71abf22 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -95,7 +95,7 @@ def __init__( model: Model = get_model(segmentation, use_auth_token=use_auth_token) self._segmentation = Inference(model) - self._frames = self._segmentation.model.output_frames + self._frames = self._segmentation.model.example_output.frames self._audio = model.audio diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 038bd4676..8cf30f3b9 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -136,7 +136,7 @@ def __init__( skip_aggregation=True, batch_size=segmentation_batch_size, ) - self._frames: SlidingWindow = self._segmentation.model.output_frames + self._frames: SlidingWindow = self._segmentation.model.example_output.frames if self._segmentation.model.specifications.powerset: self.segmentation = ParamDict( diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index f928aabbb..a672e2017 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -419,7 +419,7 @@ def sample_rate(self) -> int: @cached_property def dimension(self) -> int: - return self.model_.output_dimension + return self.model_.example_output.dimension @cached_property def metric(self) -> str: diff --git a/pyannote/audio/pipelines/utils/oracle.py b/pyannote/audio/pipelines/utils/oracle.py index 0b6b58f85..44b4ded61 100644 --- a/pyannote/audio/pipelines/utils/oracle.py +++ b/pyannote/audio/pipelines/utils/oracle.py @@ -39,7 +39,7 @@ def oracle_segmentation( Simulates inference based on an (imaginary) oracle segmentation model: >>> oracle = Model.from_pretrained("oracle") - >>> assert frames == oracle.output_frames + >>> assert frames == oracle.example_output.frames >>> inference = Inference(oracle, duration=window.duration, step=window.step, skip_aggregation=True) >>> oracle_segmentation = inference(file) diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 016d2032d..f071488ab 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -25,13 +25,11 @@ import random import warnings from collections import defaultdict -from functools import cached_property from typing import Dict, Sequence, Union import matplotlib.pyplot as plt import numpy as np import torch -from pyannote.core import SlidingWindow from pyannote.database.protocol import SegmentationProtocol, SpeakerDiarizationProtocol from pyannote.database.protocol.protocol import Scope, Subset from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger @@ -386,15 +384,6 @@ def setup(self): dtype = [("file_id", "i"), ("start", "f"), ("duration", "f")] self.validation_chunks = np.array(validation_chunks, dtype=dtype) - @cached_property - def frames(self) -> SlidingWindow: - return self.model.output_frames - - @cached_property - def num_frames_per_chunk(self) -> int: - batch_size, num_frames, num_classes = self.model.example_output().shape - return num_frames - def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 3afdd6bda..1917d2806 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -178,19 +178,23 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / self.frames.step).astype(int) + start_idx = np.floor(start / self.model.example_output.frames.step).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / self.frames.step).astype(int) + end_idx = np.ceil(end / self.model.example_output.frames.step).astype(int) # frame-level targets (-1 for un-annotated classes) - y = -np.ones((self.num_frames_per_chunk, len(self.classes)), dtype=np.int8) + y = -np.ones( + (self.model.example_output.num_frames, len(self.classes)), dtype=np.int8 + ) y[:, self.annotated_classes[file_id]] = 0 for start, end, label in zip( start_idx, end_idx, chunk_annotations["global_label_idx"] ): y[start:end, label] = 1 - sample["y"] = SlidingWindowFeature(y, self.frames, labels=self.classes) + sample["y"] = SlidingWindowFeature( + y, self.model.example_output.frames, labels=self.classes + ) metadata = self.metadata[file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index 492190938..cd3711d61 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -172,17 +172,19 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / self.frames.step).astype(int) + start_idx = np.floor(start / self.model.example_output.frames.step).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / self.frames.step).astype(int) + end_idx = np.ceil(end / self.model.example_output.frames.step).astype(int) # frame-level targets - y = np.zeros((self.num_frames_per_chunk, 1), dtype=np.uint8) + y = np.zeros((self.model.example_output.num_frames, 1), dtype=np.uint8) for start, end in zip(start_idx, end_idx): y[start:end, 0] += 1 y = 1 * (y > 1) - sample["y"] = SlidingWindowFeature(y, self.frames, labels=["speech"]) + sample["y"] = SlidingWindowFeature( + y, self.model.example_output.frames, labels=["speech"] + ) metadata = self.metadata[file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index b5ffe3da1..27c4b2dc9 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -337,9 +337,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / self.frames.step).astype(int) + start_idx = np.floor(start / self.model.example_output.frames.step).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / self.frames.step).astype(int) + end_idx = np.ceil(end / self.model.example_output.frames.step).astype(int) # get list and number of labels for current scope labels = list(np.unique(chunk_annotations[label_scope_key])) @@ -349,7 +349,7 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): pass # initial frame-level targets - y = np.zeros((self.num_frames_per_chunk, num_labels), dtype=np.uint8) + y = np.zeros((self.model.example_output.num_frames, num_labels), dtype=np.uint8) # map labels to indices mapping = {label: idx for idx, label in enumerate(labels)} @@ -360,7 +360,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): mapped_label = mapping[label] y[start:end, mapped_label] = 1 - sample["y"] = SlidingWindowFeature(y, self.frames, labels=labels) + sample["y"] = SlidingWindowFeature( + y, self.model.example_output.frames, labels=labels + ) metadata = self.metadata[file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} diff --git a/pyannote/audio/tasks/segmentation/voice_activity_detection.py b/pyannote/audio/tasks/segmentation/voice_activity_detection.py index d740427f0..967ea1f9b 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -154,16 +154,18 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # discretize chunk annotations at model output resolution start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - start_idx = np.floor(start / self.frames.step).astype(int) + start_idx = np.floor(start / self.model.example_output.frames.step).astype(int) end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / self.frames.step).astype(int) + end_idx = np.ceil(end / self.model.example_output.frames.step).astype(int) # frame-level targets - y = np.zeros((self.num_frames_per_chunk, 1), dtype=np.uint8) + y = np.zeros((self.model.example_output.num_frames, 1), dtype=np.uint8) for start, end in zip(start_idx, end_idx): y[start:end, 0] = 1 - sample["y"] = SlidingWindowFeature(y, self.frames, labels=["speech"]) + sample["y"] = SlidingWindowFeature( + y, self.model.example_output.frames, labels=["speech"] + ) metadata = self.metadata[file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} From f4337641260fae097aea38409c11bf25123ceaed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 24 May 2023 22:39:10 +0200 Subject: [PATCH 086/112] doc: update changelog --- CHANGELOG.md | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 66a5a7f69..15e11405a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,15 +18,13 @@ * replace `Audio(mono=True)` by `Audio(mono="downmix")`; * replace `Audio(mono=False)` by `Audio()`. - BREAKING(model): get rid of (flaky) `Model.introspection` - If, for some weird reason, you wrote some custom code based on that, you should instead rely on: - * `Model.example_output(duration=...)` to get example output(s) - * `Model.example_output.frames` to get output frame resolution(s) - * `Model.example_output.dimension` to get output dimension(s) + If, for some weird reason, you wrote some custom code based on that, + you should instead rely on `Model.example_output`. ### Features and improvements - - feat(task): add support for multi-task models (for inference) + - feat(task): add support for multi-task models - feat(pipeline): send pipeline to device with `pipeline.to(device)` - feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) - feat(task): add [powerset](https://arxiv.org/PLACEHOLDER) support to `SpeakerDiarization` task From 9d500dc9957da91147797d06823a6e7b2a780ab4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 26 May 2023 13:38:43 +0200 Subject: [PATCH 087/112] fix(pipeline): fix reproducibility issue with Ampere CUDA device (#1381) --- CHANGELOG.md | 10 +++ pyannote/audio/core/inference.py | 6 ++ pyannote/audio/core/pipeline.py | 7 ++- pyannote/audio/utils/reproducibility.py | 83 +++++++++++++++++++++++++ 4 files changed, 104 insertions(+), 2 deletions(-) create mode 100644 pyannote/audio/utils/reproducibility.py diff --git a/CHANGELOG.md b/CHANGELOG.md index cf525f958..d53a906cc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,15 @@ ## Version 3.0 (xxxx-xx-xx) +### Highlights + +- *"Harder"*. Fixed [major reproducibility issue](https://github.com/pyannote/pyannote-audio/issues/1370) with Ampere (A100) NVIDIA GPUs + In case you tried `pyannote.audio` pretrained pipelines in the past on Ampera (A100) NVIDIA GPUs + and were disappointed by the accuracy, please give it another try with this new version. +- "Better". +- "Faster". +- "Stronger". + ### Breaking changes - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` @@ -32,6 +41,7 @@ ### Fixes and improvements + - fix(pipeline): fix reproducibility issue with Ampere CUDA devices - fix(pipeline): fix support for IOBase audio - fix(pipeline): fix corner case with no speaker diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 9243babc1..c38fef0f9 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -36,6 +36,7 @@ from pyannote.audio.core.task import Resolution from pyannote.audio.utils.permutation import mae_cost_func, permutate from pyannote.audio.utils.powerset import Powerset +from pyannote.audio.utils.reproducibility import fix_reproducibility TaskName = Union[Text, None] @@ -356,6 +357,9 @@ def __call__( and `np.ndarray` if is set to "whole". """ + + fix_reproducibility(self.device) + waveform, sample_rate = self.model.audio(file) if self.window == "sliding": @@ -408,6 +412,8 @@ def crop( >>> inference.crop(file, extended_chunk).crop(chunk_of_interest, returns_data=False) """ + fix_reproducibility(self.device) + if self.window == "sliding": if not isinstance(chunk, Segment): diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index fb404d107..a5b4b1bc5 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -40,6 +40,7 @@ from pyannote.audio.core.inference import BaseInference from pyannote.audio.core.io import AudioFile from pyannote.audio.core.model import CACHE_DIR, Model +from pyannote.audio.utils.reproducibility import fix_reproducibility from pyannote.audio.utils.version import check_version PIPELINE_PARAMS_NAME = "config.yaml" @@ -148,7 +149,6 @@ def from_pretrained( if "preprocessors" in config: preprocessors = {} for key, preprocessor in config.get("preprocessors", {}).items(): - # preprocessors: # key: # name: package.module.ClassName @@ -253,7 +253,6 @@ def remove_from(*dicts): super().__setattr__(name, value) def __delattr__(self, name): - if name in self._models: del self._models[name] @@ -295,6 +294,8 @@ def classes(self) -> Union[List, Iterator]: raise NotImplementedError() def __call__(self, file: AudioFile, **kwargs): + fix_reproducibility(getattr(self, "device", torch.device("cpu"))) + if not self.instantiated: # instantiate with default parameters when available try: @@ -336,4 +337,6 @@ def to(self, device): for _, inference in self._inferences.items(): _ = inference.to(device) + self.device = device + return self diff --git a/pyannote/audio/utils/reproducibility.py b/pyannote/audio/utils/reproducibility.py new file mode 100644 index 000000000..5997b7bd5 --- /dev/null +++ b/pyannote/audio/utils/reproducibility.py @@ -0,0 +1,83 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# Context: https://github.com/pyannote/pyannote-audio/issues/1370 + +import warnings + +import torch + + +class ReproducibilityError(Exception): + ... + + +class ReproducibilityWarning(UserWarning): + ... + + +def raise_reproducibility(device: torch.device): + if (device.type == "cuda") and ( + torch.backends.cuda.matmul.allow_tf32 or torch.backends.cudnn.allow_tf32 + ): + raise ReproducibilityError( + "Please disable TensorFloat-32 (TF32) by calling\n" + " >>> import torch\n" + " >>> torch.backends.cuda.matmul.allow_tf32 = False\n" + " >>> torch.backends.cudnn.allow_tf32 = False\n" + "or you might face reproducibility issues and obtain lower accuracy.\n" + "See https://github.com/pyannote/pyannote-audio/issues/1370 for more details." + ) + + +def warn_reproducibility(device: torch.device): + if (device.type == "cuda") and ( + torch.backends.cuda.matmul.allow_tf32 or torch.backends.cudnn.allow_tf32 + ): + warnings.warn( + ReproducibilityWarning( + "Please disable TensorFloat-32 (TF32) by calling\n" + " >>> import torch\n" + " >>> torch.backends.cuda.matmul.allow_tf32 = False\n" + " >>> torch.backends.cudnn.allow_tf32 = False\n" + "or you might face reproducibility issues and obtain lower accuracy.\n" + "See https://github.com/pyannote/pyannote-audio/issues/1370 for more details." + ) + ) + + +def fix_reproducibility(device: torch.device): + if (device.type == "cuda") and ( + torch.backends.cuda.matmul.allow_tf32 or torch.backends.cudnn.allow_tf32 + ): + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + warnings.warn( + ReproducibilityWarning( + "TensorFloat-32 (TF32) has been disabled as it might lead to reproducibility issues and lower accuracy.\n" + "It can be re-enabled by calling\n" + " >>> import torch\n" + " >>> torch.backends.cuda.matmul.allow_tf32 = True\n" + " >>> torch.backends.cudnn.allow_tf32 = True\n" + "See https://github.com/pyannote/pyannote-audio/issues/1370 for more details.\n" + ) + ) From 7379f1c82be093078354449100e1a84cbdfbafdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 26 May 2023 15:31:12 +0200 Subject: [PATCH 088/112] improve(task): shorten and improve structure of logging tags (#1385) --- CHANGELOG.md | 1 + pyannote/audio/cli/train.py | 6 +- pyannote/audio/core/task.py | 19 +---- pyannote/audio/tasks/embedding/mixins.py | 17 +---- pyannote/audio/tasks/segmentation/mixins.py | 21 +----- .../audio/tasks/segmentation/multilabel.py | 12 ++-- .../tasks/segmentation/speaker_diarization.py | 70 ++++++------------- pyannote/audio/utils/preview.py | 4 +- 8 files changed, 41 insertions(+), 109 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d53a906cc..d7e50dba7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -44,6 +44,7 @@ - fix(pipeline): fix reproducibility issue with Ampere CUDA devices - fix(pipeline): fix support for IOBase audio - fix(pipeline): fix corner case with no speaker + - improve(task): shorten and improve structure of Tensorboard tags ### Dependencies diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index 4b2611d37..9ab8b1658 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -99,7 +99,11 @@ def configure_optimizers(self): model.configure_optimizers = MethodType(configure_optimizers, model) - callbacks = [RichProgressBar(), LearningRateMonitor(logging_interval="step")] + # avoid creating big log files + callbacks = [ + RichProgressBar(refresh_rate=20, leave=True), + LearningRateMonitor(), + ] if fine_tuning: # TODO: configure layer freezing diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index a46308f88..9bf93bf1c 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -96,7 +96,6 @@ class Specifications: @cached_property def powerset(self): - if self.powerset_max_classes is None: return False @@ -300,18 +299,6 @@ def train_dataloader(self) -> DataLoader: collate_fn=partial(self.collate_fn, stage="train"), ) - @cached_property - def logging_prefix(self): - - prefix = f"{self.__class__.__name__}-" - if hasattr(self.protocol, "name"): - # "." has a special meaning for pytorch-lightning checkpointing - # so we remove dots from protocol names - name_without_dots = "".join(self.protocol.name.split(".")) - prefix += f"{name_without_dots}-" - - return prefix - def default_loss( self, specifications: Specifications, target, prediction, weight=None ) -> torch.Tensor: @@ -406,11 +393,11 @@ def common_step(self, batch, batch_idx: int, stage: Literal["train", "val"]): return None self.model.log( - f"{self.logging_prefix}{stage.capitalize()}Loss", + f"loss/{stage}", loss, on_step=False, on_epoch=True, - prog_bar=True, + prog_bar=False, logger=True, ) return {"loss": loss} @@ -458,7 +445,7 @@ def metric(self) -> MetricCollection: if self._metric is None: self._metric = self.default_metric() - return MetricCollection(self._metric, prefix=self.logging_prefix) + return MetricCollection(self._metric) def setup_validation_metric(self): metric = self.metric diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index 00aa7e608..f5e41d3ee 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -76,7 +76,6 @@ def batch_size(self, batch_size: int): self.batch_size_ = batch_size def setup(self, stage: Optional[str] = None): - # loop over the training set, remove annotated regions shorter than # chunk duration, and keep track of the reference annotations, per class. @@ -87,9 +86,7 @@ def setup(self, stage: Optional[str] = None): desc = f"Loading {self.protocol.name} training labels" for f in tqdm(iterable=self.protocol.train(), desc=desc, unit="file"): - for klass in f["annotation"].labels(): - # keep class's (long enough) speech turns... speech_turns = [ segment @@ -133,7 +130,6 @@ def setup(self, stage: Optional[str] = None): def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: - return [ EqualErrorRate(compute_on_cpu=True, distances=False), BinaryAUROC(compute_on_cpu=True), @@ -159,7 +155,6 @@ def train__iter__(self): num_samples = 0 while True: - # shuffle classes so that we don't always have the same # groups of classes in a batch (which might be especially # problematic for contrast-based losses like contrastive @@ -167,13 +162,11 @@ def train__iter__(self): rng.shuffle(classes) for klass in classes: - # class index in original sorted order y = self.specifications.classes.index(klass) # multiple chunks per class for _ in range(self.num_chunks_per_class): - # select one file at random (with probability proportional to its class duration) file, *_ = rng.choices( self._train[klass], @@ -227,7 +220,6 @@ def train__len__(self): return max(self.batch_size, math.ceil(duration / avg_chunk_duration)) def collate_fn(self, batch, stage="train"): - collated = default_collate(batch) if stage == "train": @@ -241,7 +233,6 @@ def collate_fn(self, batch, stage="train"): return collated def training_step(self, batch, batch_idx: int): - X, y = batch["X"], batch["y"] loss = self.model.loss_func(self.model(X), y) @@ -250,18 +241,17 @@ def training_step(self, batch, batch_idx: int): return None self.model.log( - f"{self.logging_prefix}TrainLoss", + "loss/train", loss, on_step=False, on_epoch=True, - prog_bar=True, + prog_bar=False, logger=True, ) return {"loss": loss} def val__getitem__(self, idx): - if isinstance(self.protocol, SpeakerVerificationProtocol): trial = self._validation[idx] @@ -291,7 +281,6 @@ def val__getitem__(self, idx): pass def val__len__(self): - if isinstance(self.protocol, SpeakerVerificationProtocol): return len(self._validation) @@ -299,9 +288,7 @@ def val__len__(self): return 0 def validation_step(self, batch, batch_idx: int): - if isinstance(self.protocol, SpeakerVerificationProtocol): - with torch.no_grad(): emb1 = self.model(batch["X1"]).detach() emb2 = self.model(batch["X2"]).detach() diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 1cdb9840d..3db93824d 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -49,7 +49,6 @@ class SegmentationTaskMixin: """Methods common to most segmentation tasks""" def get_file(self, file_id): - file = dict() file["audio"] = str(self.audios[file_id], encoding="utf-8") @@ -121,7 +120,6 @@ def setup(self, stage: Optional[str] = None): files_iter = self.protocol.train() for file_id, file in enumerate(files_iter): - # gather metadata and update metadata_unique_values so that each metadatum # (e.g. source database or label) is represented by an integer. metadatum = dict() @@ -142,7 +140,6 @@ def setup(self, stage: Optional[str] = None): # Different files may be annotated using a different set of classes # (e.g. one database for speech/music/noise, and another one for male/female/child) if isinstance(self.protocol, SegmentationProtocol): - if "classes" in file: local_classes = file["classes"] else: @@ -191,7 +188,6 @@ def setup(self, stage: Optional[str] = None): # keep track of any other (integer or string) metadata provided by the protocol # (e.g. a "domain" key for domain-adversarial training) for key in remaining_metadata_keys: - value = file[key] if isinstance(value, str): @@ -233,7 +229,6 @@ def setup(self, stage: Optional[str] = None): # annotated regions and duration _annotated_duration = 0.0 for segment in file["annotated"]: - # skip annotated regions that are shorter than training chunk duration if segment.duration < duration: continue @@ -255,13 +250,11 @@ def setup(self, stage: Optional[str] = None): # annotations for segment, _, label in file["annotation"].itertracks(yield_label=True): - # "scope" is provided by speaker diarization protocols to indicate # whether speaker labels are local to the file ('file'), consistent across # all files in a database ('database'), or globally consistent ('global') if "scope" in file: - # 0 = 'file' # 1 = 'database' # 2 = 'global' @@ -276,7 +269,6 @@ def setup(self, stage: Optional[str] = None): database_label_idx = global_label_idx = -1 if scope > 0: # 'database' or 'global' - # update list of database-scope labels if label not in database_unique_labels: database_unique_labels.append(label) @@ -285,7 +277,6 @@ def setup(self, stage: Optional[str] = None): database_label_idx = database_unique_labels.index(label) if scope > 1: # 'global' - # update list of global-scope labels if label not in unique_labels: unique_labels.append(label) @@ -381,7 +372,6 @@ def setup(self, stage: Optional[str] = None): # iterate over files in the validation subset for file_id in validation_file_ids: - # get annotated regions in file annotated_regions = self.annotated_regions[ self.annotated_regions["file_id"] == file_id @@ -389,7 +379,6 @@ def setup(self, stage: Optional[str] = None): # iterate over annotated regions for annotated_region in annotated_regions: - # number of chunks in annotated region num_chunks = round(annotated_region["duration"] // duration) @@ -450,13 +439,11 @@ def train__iter__helper(self, rng: random.Random, **filters): num_chunks_per_file = getattr(self, "num_chunks_per_file", 1) while True: - # select one file at random (with probability proportional to its annotated duration) file_id = np.random.choice(file_ids, p=prob_annotated_duration) # generate `num_chunks_per_file` chunks from this file for _ in range(num_chunks_per_file): - # find indices of annotated regions in this file annotated_region_indices = np.where( self.annotated_regions["file_id"] == file_id @@ -510,7 +497,6 @@ def train__iter__(self): subchunks[product] = self.train__iter__helper(rng, **filters) while True: - # select one subchunk generator at random (with uniform probability) # so that it is balanced on average if balance is not None: @@ -686,7 +672,6 @@ def validation_step(self, batch, batch_idx: int): # plot each sample for sample_idx in range(num_samples): - # find where in the grid it should be plotted row_idx = sample_idx // nrows col_idx = sample_idx % ncols @@ -716,14 +701,12 @@ def validation_step(self, batch, batch_idx: int): for logger in self.model.loggers: if isinstance(logger, TensorBoardLogger): - logger.experiment.add_figure( - f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch - ) + logger.experiment.add_figure("samples", fig, self.model.current_epoch) elif isinstance(logger, MLFlowLogger): logger.experiment.log_figure( run_id=logger.run_id, figure=fig, - artifact_file=f"{self.logging_prefix}ValSamples_epoch{self.model.current_epoch}.png", + artifact_file=f"samples_epoch{self.model.current_epoch}.png", ) plt.close(fig) diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 19270e26f..da6104386 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -95,7 +95,6 @@ def __init__( augmentation: BaseWaveformTransform = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): - if not isinstance(protocol, SegmentationProtocol): raise ValueError( f"MultiLabelSegmentation task expects a SegmentationProtocol but you gave {type(protocol)}. " @@ -121,7 +120,6 @@ def __init__( # specifications to setup() def setup(self, stage: Optional[str] = None): - super().setup(stage=stage) self.specifications = Specifications( @@ -208,7 +206,6 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): return sample def training_step(self, batch, batch_idx: int): - X = batch["X"] y_pred = self.model(X) y_true = batch["y"] @@ -228,17 +225,16 @@ def training_step(self, batch, batch_idx: int): return None self.model.log( - f"{self.logging_prefix}TrainLoss", + "loss/train", loss, on_step=False, on_epoch=True, - prog_bar=True, + prog_bar=False, logger=True, ) return {"loss": loss} def validation_step(self, batch, batch_idx: int): - X = batch["X"] y_pred = self.model(X) y_true = batch["y"] @@ -256,7 +252,7 @@ def validation_step(self, batch, batch_idx: int): loss = F.binary_cross_entropy(y_pred, y_true.type(torch.float)) self.model.log( - f"{self.logging_prefix}ValLoss", + "loss/val", loss, on_step=False, on_epoch=True, @@ -284,4 +280,4 @@ def val_monitor(self): pytorch_lightning.callbacks.EarlyStopping """ - return f"{self.logging_prefix}ValLoss", "min" + return "ValLoss", "min" diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index 21f4416cc..b6838a71c 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -143,7 +143,6 @@ def __init__( max_num_speakers: int = None, # deprecated in favor of `max_speakers_per_chunk`` loss: Literal["bce", "mse"] = None, # deprecated ): - super().__init__( protocol, duration=duration, @@ -188,12 +187,10 @@ def __init__( self.vad_loss = vad_loss def setup(self, stage: Optional[str] = None): - super().setup(stage=stage) # estimate maximum number of speakers per chunk when not provided if self.max_speakers_per_chunk is None: - training = self.metadata["subset"] == Subsets.index("train") num_unique_speakers = [] @@ -201,7 +198,6 @@ def setup(self, stage: Optional[str] = None): for file_id in track( np.where(training)[0], description=progress_description ): - annotations = self.annotations[ np.where(self.annotations["file_id"] == file_id)[0] ] @@ -448,7 +444,6 @@ def segmentation_loss( """ if self.specifications.powerset: - # `clamp_min` is needed to set non-speech weight to 1. class_weight = ( torch.clamp_min(self.model.powerset.cardinality, 1.0) @@ -534,17 +529,6 @@ def training_step(self, batch, batch_idx: int): target = target[keep] waveform = waveform[keep] - # log effective batch size - self.model.log( - f"{self.logging_prefix}BatchSize", - keep.sum(), - prog_bar=False, - logger=True, - on_step=False, - on_epoch=True, - reduce_fx="mean", - ) - # corner case if not keep.any(): return None @@ -569,7 +553,6 @@ def training_step(self, batch, batch_idx: int): weight[:, num_frames - warm_up_right :] = 0.0 if self.specifications.powerset: - powerset = torch.nn.functional.one_hot( torch.argmax(prediction, dim=-1), self.model.powerset.num_powerset_classes, @@ -590,7 +573,7 @@ def training_step(self, batch, batch_idx: int): ) self.model.log( - f"{self.logging_prefix}TrainSegLoss", + "loss/train/segmentation", seg_loss, on_step=False, on_epoch=True, @@ -602,7 +585,6 @@ def training_step(self, batch, batch_idx: int): vad_loss = 0.0 else: - # TODO: vad_loss probably does not make sense in powerset mode # because first class (empty set of labels) does exactly this... if self.specifications.powerset: @@ -616,7 +598,7 @@ def training_step(self, batch, batch_idx: int): ) self.model.log( - f"{self.logging_prefix}TrainVADLoss", + "loss/train/vad", vad_loss, on_step=False, on_epoch=True, @@ -631,11 +613,11 @@ def training_step(self, batch, batch_idx: int): return None self.model.log( - f"{self.logging_prefix}TrainLoss", + "loss/train", loss, on_step=False, on_epoch=True, - prog_bar=True, + prog_bar=False, logger=True, ) @@ -647,20 +629,20 @@ def default_metric( """Returns diarization error rate and its components""" if self.specifications.powerset: - return [ - DiarizationErrorRate(0.5), - SpeakerConfusionRate(0.5), - MissedDetectionRate(0.5), - FalseAlarmRate(0.5), - ] - - return [ - OptimalDiarizationErrorRate(), - OptimalDiarizationErrorRateThreshold(), - OptimalSpeakerConfusionRate(), - OptimalMissedDetectionRate(), - OptimalFalseAlarmRate(), - ] + return { + "DiarizationErrorRate": DiarizationErrorRate(0.5), + "DiarizationErrorRate/Confusion": SpeakerConfusionRate(0.5), + "DiarizationErrorRate/Miss": MissedDetectionRate(0.5), + "DiarizationErrorRate/FalseAlarm": FalseAlarmRate(0.5), + } + + return { + "DiarizationErrorRate": OptimalDiarizationErrorRate(), + "DiarizationErrorRate/Threshold": OptimalDiarizationErrorRateThreshold(), + "DiarizationErrorRate/Confusion": OptimalSpeakerConfusionRate(), + "DiarizationErrorRate/Miss": OptimalMissedDetectionRate(), + "DiarizationErrorRate/FalseAlarm": OptimalFalseAlarmRate(), + } # TODO: no need to compute gradient in this method def validation_step(self, batch, batch_idx: int): @@ -704,7 +686,6 @@ def validation_step(self, batch, batch_idx: int): weight[:, num_frames - warm_up_right :] = 0.0 if self.specifications.powerset: - powerset = torch.nn.functional.one_hot( torch.argmax(prediction, dim=-1), self.model.powerset.num_powerset_classes, @@ -728,7 +709,7 @@ def validation_step(self, batch, batch_idx: int): ) self.model.log( - f"{self.logging_prefix}ValSegLoss", + "loss/val/segmentation", seg_loss, on_step=False, on_epoch=True, @@ -740,7 +721,6 @@ def validation_step(self, batch, batch_idx: int): vad_loss = 0.0 else: - # TODO: vad_loss probably does not make sense in powerset mode # because first class (empty set of labels) does exactly this... if self.specifications.powerset: @@ -754,7 +734,7 @@ def validation_step(self, batch, batch_idx: int): ) self.model.log( - f"{self.logging_prefix}ValVADLoss", + "loss/val/vad", vad_loss, on_step=False, on_epoch=True, @@ -765,7 +745,7 @@ def validation_step(self, batch, batch_idx: int): loss = seg_loss + vad_loss self.model.log( - f"{self.logging_prefix}ValLoss", + "loss/val", loss, on_step=False, on_epoch=True, @@ -833,7 +813,6 @@ def validation_step(self, batch, batch_idx: int): # plot each sample for sample_idx in range(num_samples): - # find where in the grid it should be plotted row_idx = sample_idx // nrows col_idx = sample_idx % ncols @@ -863,14 +842,12 @@ def validation_step(self, batch, batch_idx: int): for logger in self.model.loggers: if isinstance(logger, TensorBoardLogger): - logger.experiment.add_figure( - f"{self.logging_prefix}ValSamples", fig, self.model.current_epoch - ) + logger.experiment.add_figure("samples", fig, self.model.current_epoch) elif isinstance(logger, MLFlowLogger): logger.experiment.log_figure( run_id=logger.run_id, figure=fig, - artifact_file=f"{self.logging_prefix}ValSamples_epoch{self.model.current_epoch}.png", + artifact_file=f"samples_epoch{self.model.current_epoch}.png", ) plt.close(fig) @@ -893,7 +870,6 @@ def main(protocol: str, subset: str = "test", model: str = "pyannote/segmentatio files = list(getattr(protocol, subset)()) with Progress() as progress: - main_task = progress.add_task(protocol.name, total=len(files)) file_task = progress.add_task("Processing", total=1.0) diff --git a/pyannote/audio/utils/preview.py b/pyannote/audio/utils/preview.py index ac085b10f..6094c71cd 100644 --- a/pyannote/audio/utils/preview.py +++ b/pyannote/audio/utils/preview.py @@ -196,7 +196,6 @@ def make_audio_frame(T: float): ylim = (-0.1, 1.1) def make_frame(T: float): - # make sure all subsequent calls to notebook.plot_* # will only display the region center on current time t = T + segment.start @@ -215,7 +214,6 @@ def make_frame(T: float): ax_wav.set_ylabel("waveform") for (name, view), ax_view in zip(views.items(), ax_views): - ax_view.clear() if isinstance(view, Timeline): @@ -313,7 +311,7 @@ def preview_training_samples( audio_file = { "waveform": waveform, "sample_rate": sample_rate, - "uri": model.task.logging_prefix + "TrainingSamples", + "uri": "TrainingSamples", } return preview( From f13dc1bd75b1f1a99bbc37904bf1b921f5eb68dd Mon Sep 17 00:00:00 2001 From: chai3 <16031581+chai3@users.noreply.github.com> Date: Thu, 8 Jun 2023 15:42:15 +0900 Subject: [PATCH 089/112] fix: raise TypeError on wrong device type in Pipeline.to and Inference.to Fixes 1397 --- pyannote/audio/core/inference.py | 5 +++++ pyannote/audio/core/pipeline.py | 7 ++++++- pyannote/audio/pipelines/speaker_verification.py | 15 +++++++++++++++ 3 files changed, 26 insertions(+), 1 deletion(-) diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 339cef0b3..703aa06cb 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -186,6 +186,11 @@ def __init__( def to(self, device: torch.device) -> "Inference": """Send internal model to `device`""" + if not isinstance(device, torch.device): + raise TypeError( + f"`device` must be an instance of `torch.device`, got `{type(device).__name__}`" + ) + self.model.to(device) self.conversion.to(device) self.device = device diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index a5b4b1bc5..f844d584f 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -324,9 +324,14 @@ def __call__(self, file: AudioFile, **kwargs): return self.apply(file, **kwargs) - def to(self, device): + def to(self, device: torch.device): """Send pipeline to `device`""" + if not isinstance(device, torch.device): + raise TypeError( + f"`device` must be an instance of `torch.device`, got `{type(device).__name__}`" + ) + for _, pipeline in self._pipelines.items(): if hasattr(pipeline, "to"): _ = pipeline.to(device) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index a672e2017..005c8964f 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -79,6 +79,11 @@ def __init__( self.model_.to(self.device) def to(self, device: torch.device): + if not isinstance(device, torch.device): + raise TypeError( + f"`device` must be an instance of `torch.device`, got `{type(device).__name__}`" + ) + self.model_.to(device) self.device = device return self @@ -250,6 +255,11 @@ def __init__( ) def to(self, device: torch.device): + if not isinstance(device, torch.device): + raise TypeError( + f"`device` must be an instance of `torch.device`, got `{type(device).__name__}`" + ) + self.classifier_ = SpeechBrain_EncoderClassifier.from_hparams( source=self.embedding, savedir=f"{CACHE_DIR}/speechbrain", @@ -409,6 +419,11 @@ def __init__( self.model_.to(self.device) def to(self, device: torch.device): + if not isinstance(device, torch.device): + raise TypeError( + f"`device` must be an instance of `torch.device`, got `{type(device).__name__}`" + ) + self.model_.to(device) self.device = device return self From a675a55c0dc5d9665eeea75bd698426a8284e228 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 12 Jun 2023 12:21:09 +0200 Subject: [PATCH 090/112] feat(task): add support for multi-task models (#1374) BREAKING(model): get rid of (flaky) `Model.introspection` From 3c9e23f36bbe89fba84aaf0a2908bd0ee9555fbf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 12 Jun 2023 13:10:50 +0200 Subject: [PATCH 091/112] fix(inference): fix multi-task inference --- pyannote/audio/core/inference.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 703aa06cb..dcf21868d 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -262,19 +262,17 @@ def slide( step_size: int = round(self.step * sample_rate) _, num_samples = waveform.shape - frames = self.model.example_output.frames - def __frames( - frames, specifications: Optional[Specifications] = None + example_output, specifications: Optional[Specifications] = None ) -> SlidingWindow: if specifications.resolution == Resolution.CHUNK: return SlidingWindow(start=0.0, duration=self.duration, step=self.step) - return frames + return example_output.frames frames: Union[SlidingWindow, Tuple[SlidingWindow]] = map_with_specifications( self.model.specifications, __frames, - self.model.example_output.frames, + self.model.example_output, ) # prepare complete chunks From 524881c44854b0a5029d1acd5047c0818f51be33 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 15 Jun 2023 13:53:04 +0200 Subject: [PATCH 092/112] feat: update FAQtory default answer --- .faq/suggest.md | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/.faq/suggest.md b/.faq/suggest.md index 0a9233998..5fd8b252f 100644 --- a/.faq/suggest.md +++ b/.faq/suggest.md @@ -1,3 +1,5 @@ +Thank you for your issue. + {%- if questions -%} {% if questions|length == 1 %} We found the following entry in the [FAQ]({{ faq_url }}) which you may find helpful: @@ -9,12 +11,22 @@ We found the following entries in the [FAQ]({{ faq_url }}) which you may find he - [{{ question.title }}]({{ faq_url }}#{{ question.slug }}) {%- endfor %} -Feel free to close this issue if you found an answer in the FAQ. Otherwise, please give us a little time to review. - {%- else -%} -Thank you for your issue. Give us a little time to review it. - -PS. You might want to check the [FAQ]({{ faq_url }}) if you haven't done so already. +You might want to check the [FAQ]({{ faq_url }}) if you haven't done so already. {%- endif %} -This is an automated reply, generated by [FAQtory](https://github.com/willmcgugan/faqtory) +Feel free to close this issue if you found an answer in the FAQ. + +If your issue is a feature request, please read [this](https://xyproblem.info/) first and update your request accordingly, if needed. + +If your issue is a bug report, please provide a [minimum reproducible example](https://stackoverflow.com/help/minimal-reproducible-example) as a link to a self-contained [Google Colab](https://colab.research.google.com/) notebook containing everthing needed to reproduce the bug: + - installation + - data preparation + - model download + - etc. + +Providing an MRE will increase your chance of getting an answer from the community (either maintainers or other power users). + +[We](https://herve.niderb.fr) also offer paid scientific consulting services around speaker diarization (and speech processing in general). + +> This is an automated reply, generated by [FAQtory](https://github.com/willmcgugan/faqtory) From e9a92740a0931a31da0ed9dff374f9949ad55c72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 22 Jun 2023 17:32:59 +0200 Subject: [PATCH 093/112] improve(test): use pyannote.database.registry (#1413) --- .github/workflows/test.yml | 1 - README.md | 5 ++--- tests/conftest.py | 32 ++++++++++++++++++++++++++++++++ 3 files changed, 34 insertions(+), 4 deletions(-) create mode 100644 tests/conftest.py diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index b266179eb..df1182cf3 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -29,5 +29,4 @@ jobs: pip install -e .[dev,testing] - name: Test with pytest run: | - export PYANNOTE_DATABASE_CONFIG=$GITHUB_WORKSPACE/tests/data/database.yml pytest diff --git a/README.md b/README.md index c3f9a8dcc..3bf1b2c8a 100644 --- a/README.md +++ b/README.md @@ -126,9 +126,8 @@ pip install -e .[dev,testing] pre-commit install ``` -Tests rely on a set of debugging files available in [`test/data`](test/data) directory. -Set `PYANNOTE_DATABASE_CONFIG` environment variable to `test/data/database.yml` before running tests: +## Test ```bash -PYANNOTE_DATABASE_CONFIG=tests/data/database.yml pytest +pytest ``` diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 000000000..fe2a00e12 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,32 @@ +# MIT License +# +# Copyright (c) 2020- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +def pytest_sessionstart(session): + """ + Called after the Session object has been created and + before performing collection and entering the run test loop. + """ + + from pyannote.database import registry + + registry.load_database("tests/data/database.yml") From ef029bccd2d5d7698c753945f487c9ce896a3e1f Mon Sep 17 00:00:00 2001 From: Dmitry Mukhutdinov Date: Fri, 23 Jun 2023 22:11:54 +0800 Subject: [PATCH 094/112] feat(pipeline): add `return_embeddings` option to `SpeakerDiarization` pipeline MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Hervé BREDIN --- CHANGELOG.md | 4 +- pyannote/audio/pipelines/clustering.py | 61 ++++++++------ .../audio/pipelines/speaker_diarization.py | 81 +++++++++++++++---- pyannote/audio/pipelines/utils/diarization.py | 28 +++++-- 4 files changed, 128 insertions(+), 46 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bc51c0e9c..6e7d220fd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -30,13 +30,13 @@ If, for some weird reason, you wrote some custom code based on that, you should instead rely on `Model.example_output`. - ### Features and improvements - feat(task): add support for multi-task models - feat(pipeline): send pipeline to device with `pipeline.to(device)` - feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) - feat(task): add [powerset](https://arxiv.org/PLACEHOLDER) support to `SpeakerDiarization` task + - feat(pipeline): add `return_embeddings` option to `SpeakerDiarization` pipeline - feat(pipeline): add progress hook to pipelines - feat(pipeline): check version compatibility at load time - feat(task): add support for label scope in speaker diarization task @@ -88,7 +88,7 @@ - last release before complete rewriting -## Version 1.0.1 (2018--07-19) +## Version 1.0.1 (2018-07-19) - fix: fix regression in Precomputed.__call__ (#110, #105) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index f282ea39c..3c2786232 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -48,7 +48,6 @@ def __init__( max_num_embeddings: int = 1000, constrained_assignment: bool = False, ): - super().__init__() self.metric = metric self.max_num_embeddings = max_num_embeddings @@ -61,7 +60,6 @@ def set_num_clusters( min_clusters: int = None, max_clusters: int = None, ): - min_clusters = num_clusters or min_clusters or 1 min_clusters = max(1, min(num_embeddings, min_clusters)) max_clusters = num_clusters or max_clusters or num_embeddings @@ -113,7 +111,6 @@ def filter_embeddings( return embeddings[chunk_idx, speaker_idx], chunk_idx, speaker_idx def constrained_argmax(self, soft_clusters: np.ndarray) -> np.ndarray: - soft_clusters = np.nan_to_num(soft_clusters, nan=np.nanmin(soft_clusters)) num_chunks, num_speakers, num_clusters = soft_clusters.shape # num_chunks, num_speakers, num_clusters @@ -156,6 +153,8 @@ def assign_embeddings( ------- soft_clusters : (num_chunks, num_speakers, num_clusters)-shaped array hard_clusters : (num_chunks, num_speakers)-shaped array + centroids : (num_clusters, dimension)-shaped array + Clusters centroids """ # TODO: option to add a new (dummy) cluster in case num_clusters < max(frame_speaker_count) @@ -194,7 +193,7 @@ def assign_embeddings( # TODO: add a flag to revert argmax for trainign subset # hard_clusters[train_chunk_idx, train_speaker_idx] = train_clusters - return hard_clusters, soft_clusters + return hard_clusters, soft_clusters, centroids def __call__( self, @@ -230,6 +229,8 @@ def __call__( soft_clusters : (num_chunks, num_speakers, num_clusters) array Soft cluster assignment (the higher soft_clusters[c, s, k], the most likely the sth speaker of cth chunk belongs to kth cluster) + centroids : (num_clusters, dimension) array + Centroid vectors of each cluster """ train_embeddings, train_chunk_idx, train_speaker_idx = self.filter_embeddings( @@ -250,7 +251,9 @@ def __call__( num_chunks, num_speakers, _ = embeddings.shape hard_clusters = np.zeros((num_chunks, num_speakers), dtype=np.int8) soft_clusters = np.ones((num_chunks, num_speakers, 1)) - return hard_clusters, soft_clusters + centroids = np.mean(train_embeddings, axis=0, keepdims=True) + + return hard_clusters, soft_clusters, centroids train_clusters = self.cluster( train_embeddings, @@ -259,7 +262,7 @@ def __call__( num_clusters=num_clusters, ) - hard_clusters, soft_clusters = self.assign_embeddings( + hard_clusters, soft_clusters, centroids = self.assign_embeddings( embeddings, train_chunk_idx, train_speaker_idx, @@ -267,7 +270,7 @@ def __call__( constrained=self.constrained_assignment, ) - return hard_clusters, soft_clusters + return hard_clusters, soft_clusters, centroids class AgglomerativeClustering(BaseClustering): @@ -286,19 +289,6 @@ class AgglomerativeClustering(BaseClustering): Clustering threshold. min_cluster_size : int in range [1, 20] Minimum cluster size - - Usage - ----- - >>> clustering = AgglomerativeClustering(metric="cosine") - >>> clustering.instantiate({"method": "average", - ... "threshold": 1.0, - ... "min_cluster_size": 1}) - >>> clusters, _ = clustering(embeddings, # shape - ... num_clusters=None, - ... min_clusters=None, - ... max_clusters=None) - where `embeddings` is a np.ndarray with shape (num_embeddings, embedding_dimension) - and `clusters` is a np.ndarray with shape (num_embeddings, ) """ def __init__( @@ -307,7 +297,6 @@ def __init__( max_num_embeddings: int = np.inf, constrained_assignment: bool = False, ): - super().__init__( metric=metric, max_num_embeddings=max_num_embeddings, @@ -397,7 +386,6 @@ def cluster( num_clusters = max_clusters if num_clusters is not None: - # switch stopping criterion from "inter-cluster distance" stopping to "iteration index" _dendrogram = np.copy(dendrogram) _dendrogram[:, 2] = np.arange(num_embeddings - 1) @@ -409,7 +397,6 @@ def cluster( # from the "optimal" threshold for iteration in np.argsort(np.abs(dendrogram[:, 2] - self.threshold)): - # only consider iterations that might have resulted # in changing the number of (large) clusters new_cluster_size = _dendrogram[iteration, 3] @@ -481,6 +468,7 @@ class OracleClustering(BaseClustering): def __call__( self, + embeddings: np.ndarray = None, segmentations: SlidingWindowFeature = None, file: AudioFile = None, frames: SlidingWindow = None, @@ -490,6 +478,9 @@ def __call__( Parameters ---------- + embeddings : (num_chunks, num_speakers, dimension) array, optional + Sequence of embeddings. When provided, compute speaker centroids + based on these embeddings. segmentations : (num_chunks, num_frames, num_speakers) array Binary segmentations. file : AudioFile @@ -503,6 +494,8 @@ def __call__( soft_clusters : (num_chunks, num_speakers, num_clusters) array Soft cluster assignment (the higher soft_clusters[c, s, k], the most likely the sth speaker of cth chunk belongs to kth cluster) + centroids : (num_clusters, dimension), optional + Clusters centroids if `embeddings` is provided, None otherwise. """ num_chunks, num_frames, num_speakers = segmentations.data.shape @@ -532,7 +525,27 @@ def __call__( hard_clusters[c, i] = j soft_clusters[c, i, j] = 1.0 - return hard_clusters, soft_clusters + if embeddings is None: + return hard_clusters, soft_clusters, None + + ( + train_embeddings, + train_chunk_idx, + train_speaker_idx, + ) = self.filter_embeddings( + embeddings, + segmentations=segmentations, + ) + + train_clusters = hard_clusters[train_chunk_idx, train_speaker_idx] + centroids = np.vstack( + [ + np.mean(train_embeddings[train_clusters == k], axis=0) + for k in range(num_clusters) + ] + ) + + return hard_clusters, soft_clusters, centroids class Clustering(Enum): diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 8cf30f3b9..f59551176 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -89,11 +89,20 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): Usage ----- - >>> pipeline = SpeakerDiarization() + # perform (unconstrained) diarization >>> diarization = pipeline("/path/to/audio.wav") + + # perform diarization, targetting exactly 4 speakers >>> diarization = pipeline("/path/to/audio.wav", num_speakers=4) + + # perform diarization, with at least 2 speakers and at most 10 speakers >>> diarization = pipeline("/path/to/audio.wav", min_speakers=2, max_speakers=10) + # perform diarization and get one representative embedding per speaker + >>> diarization, embeddings = pipeline("/path/to/audio.wav", return_embedding=True) + >>> for s, speaker in enumerate(diarization.labels()): + ... # embeddings[s] is the embedding of speaker `speaker` + Hyper-parameters ---------------- segmentation.threshold @@ -417,6 +426,7 @@ def apply( num_speakers: int = None, min_speakers: int = None, max_speakers: int = None, + return_embeddings: bool = False, hook: Optional[Callable] = None, ) -> Annotation: """Apply speaker diarization @@ -431,6 +441,8 @@ def apply( Minimum number of speakers. Has no effect when `num_speakers` is provided. max_speakers : int, optional Maximum number of speakers. Has no effect when `num_speakers` is provided. + return_embeddings : bool, optional + Return representative speaker embeddings. hook : callable, optional Callback called after each major steps of the pipeline as follows: hook(step_name, # human-readable name of current step @@ -444,6 +456,10 @@ def apply( ------- diarization : Annotation Speaker diarization + embeddings : np.array, optional + Representative speaker embeddings such that `embeddings[i]` is the + speaker embedding for i-th speaker in diarization.labels(). + Only returned when `return_embeddings` is True. """ # setup hook (e.g. for debugging purposes) @@ -473,7 +489,11 @@ def apply( # exit early when no speaker is ever active if np.nanmax(count.data) == 0.0: - return Annotation(uri=file["uri"]) + diarization = Annotation(uri=file["uri"]) + if return_embeddings: + return diarization, np.zeros((0, self._embedding.dimension)) + + return diarization # binarize segmentation if self._segmentation.model.specifications.powerset: @@ -485,7 +505,7 @@ def apply( initial_state=False, ) - if self.klustering == "OracleClustering": + if self.klustering == "OracleClustering" and not return_embeddings: embeddings = None else: embeddings = self.get_embeddings( @@ -497,7 +517,7 @@ def apply( hook("embeddings", embeddings) # shape: (num_chunks, local_num_speakers, dimension) - hard_clusters, _ = self.clustering( + hard_clusters, _, centroids = self.clustering( embeddings=embeddings, segmentations=binarized_segmentations, num_clusters=num_speakers, @@ -506,7 +526,8 @@ def apply( file=file, # <== for oracle clustering frames=self._frames, # <== for oracle clustering ) - # hard_clusters: (num_chunks, num_speakers) + # hard_clusters: (num_chunks, num_speakers) + # centroids: (num_speakers, dimension) # reconstruct discrete diarization from raw hard clusters @@ -530,20 +551,52 @@ def apply( ) diarization.uri = file["uri"] - # when reference is available, use it to map hypothesized speakers - # to reference speakers (this makes later error analysis easier - # but does not modify the actual output of the diarization pipeline) + # at this point, `diarization` speaker labels are integers + # from 0 to `num_speakers - 1`, aligned with `centroids` rows. + if "annotation" in file and file["annotation"]: - return self.optimal_mapping(file["annotation"], diarization) + # when reference is available, use it to map hypothesized speakers + # to reference speakers (this makes later error analysis easier + # but does not modify the actual output of the diarization pipeline) + _, mapping = self.optimal_mapping( + file["annotation"], diarization, return_mapping=True + ) + + # in case there are more speakers in the hypothesis than in + # the reference, those extra speakers are missing from `mapping`. + # we add them back here + mapping = {key: mapping.get(key, key) for key in diarization.labels()} - # when reference is not available, rename hypothesized speakers - # to human-readable SPEAKER_00, SPEAKER_01, ... - return diarization.rename_labels( - { + else: + # when reference is not available, rename hypothesized speakers + # to human-readable SPEAKER_00, SPEAKER_01, ... + mapping = { label: expected_label for label, expected_label in zip(diarization.labels(), self.classes()) } - ) + + diarization = diarization.rename_labels(mapping=mapping) + + # at this point, `diarization` speaker labels are strings (or mix of + # strings and integers when reference is available and some hypothesis + # speakers are not present in the reference) + + if not return_embeddings: + return diarization + + # re-order centroids so that they match + # the order given by diarization.labels() + inverse_mapping = {label: index for index, label in mapping.items()} + centroids = centroids[ + [inverse_mapping[label] for label in diarization.labels()] + ] + + # FIXME: the number of centroids may be smaller than the number of speakers + # in the annotation. This can happen if the number of active speakers + # obtained from `speaker_count` for some frames is larger than the number + # of clusters obtained from `clustering`. Will be fixed in the future + + return diarization, centroids def get_metric(self) -> GreedyDiarizationErrorRate: return GreedyDiarizationErrorRate(**self.der_variant) diff --git a/pyannote/audio/pipelines/utils/diarization.py b/pyannote/audio/pipelines/utils/diarization.py index de07524e6..f494c6073 100644 --- a/pyannote/audio/pipelines/utils/diarization.py +++ b/pyannote/audio/pipelines/utils/diarization.py @@ -20,10 +20,11 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -from typing import Mapping, Tuple, Union +from typing import Dict, Mapping, Tuple, Union import numpy as np from pyannote.core import Annotation, SlidingWindow, SlidingWindowFeature +from pyannote.core.utils.types import Label from pyannote.metrics.diarization import DiarizationErrorRate from pyannote.audio.core.inference import Inference @@ -74,8 +75,10 @@ def set_num_speakers( @staticmethod def optimal_mapping( - reference: Union[Mapping, Annotation], hypothesis: Annotation - ) -> Annotation: + reference: Union[Mapping, Annotation], + hypothesis: Annotation, + return_mapping: bool = False, + ) -> Union[Annotation, Tuple[Annotation, Dict[Label, Label]]]: """Find the optimal bijective mapping between reference and hypothesis labels Parameters @@ -84,13 +87,19 @@ def optimal_mapping( Reference annotation. Can be an Annotation instance or a mapping with an "annotation" key. hypothesis : Annotation + Hypothesized annotation. + return_mapping : bool, optional + Return the label mapping itself along with the mapped annotation. Defaults to False. Returns ------- mapped : Annotation Hypothesis mapped to reference speakers. - + mapping : dict, optional + Mapping between hypothesis (key) and reference (value) labels + Only returned if `return_mapping` is True. """ + if isinstance(reference, Mapping): reference = reference["annotation"] annotated = reference["annotated"] if "annotated" in reference else None @@ -100,7 +109,13 @@ def optimal_mapping( mapping = DiarizationErrorRate().optimal_mapping( reference, hypothesis, uem=annotated ) - return hypothesis.rename_labels(mapping=mapping) + mapped_hypothesis = hypothesis.rename_labels(mapping=mapping) + + if return_mapping: + return mapped_hypothesis, mapping + + else: + return mapped_hypothesis # TODO: get rid of onset/offset (binarization should be applied before calling speaker_count) # TODO: get rid of warm-up parameter (trimming should be applied before calling speaker_count) @@ -171,7 +186,8 @@ def to_annotation( Returns ------- continuous_diarization : Annotation - Continuous diarization + Continuous diarization, with speaker labels as integers, + corresponding to the speaker indices in the discrete diarization. """ binarize = Binarize( From f53e00bec5deafff25c635d38d6c6a82cba38211 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 27 Jun 2023 13:41:41 +0200 Subject: [PATCH 095/112] fix: fix missed speech at the very beginning/end --- pyannote/audio/pipelines/speaker_diarization.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index f59551176..0bc0f449a 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -482,6 +482,7 @@ def apply( if self._segmentation.model.specifications.powerset else self.segmentation.threshold, frames=self._frames, + warm_up=(0.0, 0.0), ) hook("speaker_counting", count) # shape: (num_frames, 1) From 8d65777dbe6ec7b06ac80e89230e2a63135f8162 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 28 Jun 2023 09:09:53 +0200 Subject: [PATCH 096/112] doc: add note to self regarding cluster reassignment (#1419) --- pyannote/audio/pipelines/clustering.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index 3c2786232..a779016cb 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -190,8 +190,9 @@ def assign_embeddings( else: hard_clusters = np.argmax(soft_clusters, axis=2) - # TODO: add a flag to revert argmax for trainign subset - # hard_clusters[train_chunk_idx, train_speaker_idx] = train_clusters + # NOTE: train_embeddings might be reassigned to a different cluster + # in the process. based on experiments, this seems to lead to better + # results than sticking to the original assignment. return hard_clusters, soft_clusters, centroids From 3c5e81aaa3bf38d83f653d99c502719eddbdb93e Mon Sep 17 00:00:00 2001 From: ~/trisqwit <34287923+DiaaAj@users.noreply.github.com> Date: Sun, 9 Jul 2023 15:07:35 +0300 Subject: [PATCH 097/112] fix(doc): fix typo in diarization docstring --- pyannote/audio/pipelines/speaker_diarization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 0bc0f449a..18b6565d3 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -99,7 +99,7 @@ class SpeakerDiarization(SpeakerDiarizationMixin, Pipeline): >>> diarization = pipeline("/path/to/audio.wav", min_speakers=2, max_speakers=10) # perform diarization and get one representative embedding per speaker - >>> diarization, embeddings = pipeline("/path/to/audio.wav", return_embedding=True) + >>> diarization, embeddings = pipeline("/path/to/audio.wav", return_embeddings=True) >>> for s, speaker in enumerate(diarization.labels()): ... # embeddings[s] is the embedding of speaker `speaker` From 339e66310f55a798b1bd9883f5096f72688da498 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sun, 16 Jul 2023 15:48:03 +0200 Subject: [PATCH 098/112] ci: update suggest.md (#1435) --- .faq/suggest.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.faq/suggest.md b/.faq/suggest.md index 5fd8b252f..19e7b6d69 100644 --- a/.faq/suggest.md +++ b/.faq/suggest.md @@ -27,6 +27,8 @@ If your issue is a bug report, please provide a [minimum reproducible example](h Providing an MRE will increase your chance of getting an answer from the community (either maintainers or other power users). -[We](https://herve.niderb.fr) also offer paid scientific consulting services around speaker diarization (and speech processing in general). +Companies relying on `pyannote.audio` in production may contact [me](https://herve.niderb.fr) via email regarding: +* paid scientific consulting around speaker diarization and speech processing in general; +* custom models and tailored features (via the local tech transfer office). > This is an automated reply, generated by [FAQtory](https://github.com/willmcgugan/faqtory) From c18fd1414642012508f55fb740cd6f49d6a4777f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 2 Aug 2023 23:56:20 +0200 Subject: [PATCH 099/112] feat: add support for WeSpeaker embeddings (#1444) --- .../audio/pipelines/speaker_verification.py | 219 ++++++++++++++++++ 1 file changed, 219 insertions(+) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 005c8964f..b30ea2b21 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -28,6 +28,7 @@ import torch import torch.nn.functional as F import torchaudio +import torchaudio.compliance.kaldi as kaldi from torch.nn.utils.rnn import pad_sequence from pyannote.audio import Inference, Model, Pipeline @@ -57,6 +58,13 @@ except ImportError: NEMO_IS_AVAILABLE = False +try: + import onnxruntime as ort + + ONNX_IS_AVAILABLE = True +except ImportError: + ONNX_IS_AVAILABLE = False + class NeMoPretrainedSpeakerEmbedding(BaseInference): def __init__( @@ -375,6 +383,214 @@ def __call__( return embeddings +class WeSpeakerPretrainedSpeakerEmbedding(BaseInference): + """Pretrained WeSpeaker speaker embedding + + Parameters + ---------- + embedding : str + Path to WeSpeaker pretrained speaker embedding + device : torch.device, optional + Device + + Usage + ----- + >>> get_embedding = WeSpeakerPretrainedSpeakerEmbedding("wespeaker.xxxx.onnx") + >>> assert waveforms.ndim == 3 + >>> batch_size, num_channels, num_samples = waveforms.shape + >>> assert num_channels == 1 + >>> embeddings = get_embedding(waveforms) + >>> assert embeddings.ndim == 2 + >>> assert embeddings.shape[0] == batch_size + + >>> assert binary_masks.ndim == 1 + >>> assert binary_masks.shape[0] == batch_size + >>> embeddings = get_embedding(waveforms, masks=binary_masks) + """ + + def __init__( + self, + embedding: Text = "speechbrain/spkrec-ecapa-voxceleb", + device: torch.device = None, + ): + if not ONNX_IS_AVAILABLE: + raise ImportError( + f"'onnxruntime' must be installed to use '{embedding}' embeddings. " + ) + + super().__init__() + + self.embedding = embedding + + self.to(device or torch.device("cpu")) + + def to(self, device: torch.device): + if not isinstance(device, torch.device): + raise TypeError( + f"`device` must be an instance of `torch.device`, got `{type(device).__name__}`" + ) + + if device.type == "cpu": + providers = ["CPUExecutionProvider"] + elif device.type == "cuda": + providers = ["CUDAExecutionProvider"] + else: + warnings.warn( + f"Unsupported device type: {device.type}, falling back to CPU" + ) + device = torch.device("cpu") + providers = ["CPUExecutionProvider"] + + sess_options = ort.SessionOptions() + sess_options.inter_op_num_threads = 1 + sess_options.intra_op_num_threads = 1 + self.session_ = ort.InferenceSession( + self.embedding, sess_options=sess_options, providers=providers + ) + + self.device = device + return self + + @cached_property + def sample_rate(self) -> int: + return 16000 + + @cached_property + def dimension(self) -> int: + dummy_waveforms = torch.rand(1, 1, 16000) + features = self.compute_fbank(dummy_waveforms) + embeddings = self.session_.run( + output_names=["embs"], input_feed={"feats": features.numpy()} + )[0] + _, dimension = embeddings.shape + return dimension + + @cached_property + def metric(self) -> str: + return "cosine" + + @cached_property + def min_num_samples(self) -> int: + lower, upper = 2, round(0.5 * self.sample_rate) + middle = (lower + upper) // 2 + while lower + 1 < upper: + try: + features = self.compute_fbank(torch.randn(1, 1, middle)) + + except AssertionError: + lower = middle + middle = (lower + upper) // 2 + continue + + embeddings = self.session_.run( + output_names=["embs"], input_feed={"feats": features.numpy()} + )[0] + + if np.any(np.isnan(embeddings)): + lower = middle + else: + upper = middle + middle = (lower + upper) // 2 + + return upper + + @cached_property + def min_num_frames(self) -> int: + return self.compute_fbank(torch.randn(1, 1, self.min_num_samples)).shape[1] + + def compute_fbank( + self, + waveforms: torch.Tensor, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + ) -> torch.Tensor: + """Extract fbank features + + Parameters + ---------- + waveforms : (batch_size, num_channels, num_samples) + + Returns + ------- + fbank : (batch_size, num_frames, num_mel_bins) + + Source: https://github.com/wenet-e2e/wespeaker/blob/45941e7cba2c3ea99e232d02bedf617fc71b0dad/wespeaker/bin/infer_onnx.py#L30C1-L50 + """ + + waveforms = waveforms * (1 << 15) + features = torch.stack( + [ + kaldi.fbank( + waveform, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + sample_frequency=self.sample_rate, + window_type="hamming", + use_energy=False, + ) + for waveform in waveforms + ] + ) + return features - torch.mean(features, dim=1, keepdim=True) + + def __call__( + self, waveforms: torch.Tensor, masks: torch.Tensor = None + ) -> np.ndarray: + """ + + Parameters + ---------- + waveforms : (batch_size, num_channels, num_samples) + Only num_channels == 1 is supported. + masks : (batch_size, num_samples), optional + + Returns + ------- + embeddings : (batch_size, dimension) + + """ + + batch_size, num_channels, num_samples = waveforms.shape + assert num_channels == 1 + + features = self.compute_fbank(waveforms) + _, num_frames, _ = features.shape + + if masks is None: + embeddings = self.session_.run( + output_names=["embs"], input_feed={"feats": features.numpy()} + )[0] + + return embeddings + + batch_size_masks, _ = masks.shape + assert batch_size == batch_size_masks + + imasks = F.interpolate( + masks.unsqueeze(dim=1), size=num_frames, mode="nearest" + ).squeeze(dim=1) + + imasks = imasks > 0.5 + + embeddings = np.NAN * np.zeros((batch_size, self.dimension)) + + for f, (feature, imask) in enumerate(zip(features, imasks)): + masked_feature = feature[imask] + if masked_feature.shape[0] < self.min_num_frames: + continue + + embeddings[f] = self.session_.run( + output_names=["embs"], + input_feed={"feats": masked_feature.numpy()[None]}, + )[0][0] + + return embeddings + + class PyannoteAudioPretrainedSpeakerEmbedding(BaseInference): """Pretrained pyannote.audio speaker embedding @@ -515,6 +731,9 @@ def PretrainedSpeakerEmbedding( elif isinstance(embedding, str) and "nvidia" in embedding: return NeMoPretrainedSpeakerEmbedding(embedding, device=device) + elif isinstance(embedding, str) and "wespeaker" in embedding: + return WeSpeakerPretrainedSpeakerEmbedding(embedding, device=device) + else: return PyannoteAudioPretrainedSpeakerEmbedding( embedding, device=device, use_auth_token=use_auth_token From 1cc43c091466ea86acb7ee712deba6fad919ae21 Mon Sep 17 00:00:00 2001 From: Aashish Malhotra <74505547+aashish-19@users.noreply.github.com> Date: Mon, 7 Aug 2023 13:37:10 +0400 Subject: [PATCH 100/112] fix: fix security issue in FAQtory bot --- .github/workflows/new_issue.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/new_issue.yml b/.github/workflows/new_issue.yml index a67bcdcd5..b8477dc16 100644 --- a/.github/workflows/new_issue.yml +++ b/.github/workflows/new_issue.yml @@ -14,7 +14,9 @@ jobs: - name: Install FAQtory run: pip install FAQtory - name: Run Suggest - run: faqtory suggest "${{ github.event.issue.title }}" > suggest.md + env: + TITLE: ${{ github.event.issue.title }} + run: faqtory suggest "$TITLE" > suggest.md - name: Read suggest.md id: suggest uses: juliangruber/read-file-action@v1 From a1e075d646d9d0f9c6cc9f186d151aeb73d047bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 30 Aug 2023 17:39:57 +0200 Subject: [PATCH 101/112] Update README.md --- README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 3bf1b2c8a..3b77bfe46 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,7 @@ -# Neural speaker diarization with `pyannote.audio` +> [!IMPORTANT] +> I propose (paid) scientific [consulting services](https://herve.niderb.fr/consulting.html) to companies willing to make the most of their data and open-source speech processing toolkits (and pyannote in particular). + +# Speaker diarization with `pyannote.audio` `pyannote.audio` is an open-source toolkit written in Python for speaker diarization. Based on [PyTorch](pytorch.org) machine learning framework, it provides a set of trainable end-to-end neural building blocks that can be combined and jointly optimized to build speaker diarization pipelines. From 28a247dd1401bbe5de64cb4cd516ac8a483e85f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 30 Aug 2023 17:40:28 +0200 Subject: [PATCH 102/112] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3b77bfe46..1d314cd92 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ > [!IMPORTANT] -> I propose (paid) scientific [consulting services](https://herve.niderb.fr/consulting.html) to companies willing to make the most of their data and open-source speech processing toolkits (and pyannote in particular). +> I propose (paid) scientific [consulting services](https://herve.niderb.fr/consulting.html) to companies willing to make the most of their data and open-source speech processing toolkits (and `pyannote` in particular). # Speaker diarization with `pyannote.audio` From 610fd8b9d6fd9394dde11980d406f18467e016b4 Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Fri, 15 Sep 2023 17:19:04 +0200 Subject: [PATCH 103/112] fix(task): fix MultiLabelSegmentation.val_monitor --- pyannote/audio/tasks/segmentation/multilabel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 5588ccdff..4265d5e86 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -277,4 +277,4 @@ def val_monitor(self): pytorch_lightning.callbacks.EarlyStopping """ - return "ValLoss", "min" + return "loss/val", "min" From 6740db2b8fe0d571b889147df7a2b85edbc3602f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sat, 16 Sep 2023 15:50:40 +0200 Subject: [PATCH 104/112] fix(core): fix Model.example_output for embedding models --- pyannote/audio/core/model.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 5cb6c0e6b..bedb7f6c4 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -198,12 +198,13 @@ def __example_output( example_output: torch.Tensor, specifications: Specifications = None, ) -> Output: - _, num_frames, dimension = example_output.shape - if specifications.resolution == Resolution.FRAME: + _, num_frames, dimension = example_output.shape frame_duration = specifications.duration / num_frames frames = SlidingWindow(step=frame_duration, duration=frame_duration) else: + _, dimension = example_output.shape + num_frames = None frames = None return Output( From b9548a75e44a523000f1eb5644d588b96686095f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9verin?= <123748182+SevKod@users.noreply.github.com> Date: Mon, 18 Sep 2023 10:24:59 +0200 Subject: [PATCH 105/112] feat(model) : add segmentation model based on self-supervised representation (#1362) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Hervé BREDIN --- CHANGELOG.md | 9 +- .../cli/train_config/model/SSeRiouSS.yaml | 13 + .../audio/models/segmentation/SSeRiouSS.py | 234 ++++++++++++++++++ .../audio/models/segmentation/__init__.py | 5 +- 4 files changed, 255 insertions(+), 6 deletions(-) create mode 100644 pyannote/audio/cli/train_config/model/SSeRiouSS.yaml create mode 100644 pyannote/audio/models/segmentation/SSeRiouSS.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 6e7d220fd..a6f2161c5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -32,15 +32,16 @@ ### Features and improvements + - feat(task): add [powerset](https://www.isca-speech.org/archive/interspeech_2023/plaquet23_interspeech.html) support to `SpeakerDiarization` task - feat(task): add support for multi-task models + - feat(task): add support for label scope in speaker diarization task + - feat(task): add support for missing classes in multi-label segmentation task + - feat(model): add segmentation model based on torchaudio self-supervised representation - feat(pipeline): send pipeline to device with `pipeline.to(device)` - - feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) - - feat(task): add [powerset](https://arxiv.org/PLACEHOLDER) support to `SpeakerDiarization` task - feat(pipeline): add `return_embeddings` option to `SpeakerDiarization` pipeline + - feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) - feat(pipeline): add progress hook to pipelines - feat(pipeline): check version compatibility at load time - - feat(task): add support for label scope in speaker diarization task - - feat(task): add support for missing classes in multi-label segmentation task - improve(task): load metadata as tensors rather than pyannote.core instances - improve(task): improve error message on missing specifications diff --git a/pyannote/audio/cli/train_config/model/SSeRiouSS.yaml b/pyannote/audio/cli/train_config/model/SSeRiouSS.yaml new file mode 100644 index 000000000..73f7f963a --- /dev/null +++ b/pyannote/audio/cli/train_config/model/SSeRiouSS.yaml @@ -0,0 +1,13 @@ +# @package _group_ +_target_: pyannote.audio.models.segmentation.SSeRiouSS +wav2vec: WAVLM_BASE +wav2vec_layer: -1 +lstm: + hidden_size: 128 + num_layers: 4 + bidirectional: true + monolithic: true + dropout: 0.5 +linear: + hidden_size: 128 + num_layers: 2 diff --git a/pyannote/audio/models/segmentation/SSeRiouSS.py b/pyannote/audio/models/segmentation/SSeRiouSS.py new file mode 100644 index 000000000..7cd545177 --- /dev/null +++ b/pyannote/audio/models/segmentation/SSeRiouSS.py @@ -0,0 +1,234 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +from typing import Optional, Union + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torchaudio +from pyannote.core.utils.generators import pairwise + +from pyannote.audio.core.model import Model +from pyannote.audio.core.task import Task +from pyannote.audio.utils.params import merge_dict + + +class SSeRiouSS(Model): + """Self-Supervised Representation for Speaker Segmentation + + wav2vec > LSTM > Feed forward > Classifier + + Parameters + ---------- + sample_rate : int, optional + Audio sample rate. Defaults to 16kHz (16000). + num_channels : int, optional + Number of channels. Defaults to mono (1). + wav2vec: dict or str, optional + Defaults to "WAVLM_BASE". + wav2vec_layer: int, optional + Index of layer to use as input to the LSTM. + Defaults (-1) to use average of all layers (with learnable weights). + lstm : dict, optional + Keyword arguments passed to the LSTM layer. + Defaults to {"hidden_size": 128, "num_layers": 4, "bidirectional": True}, + i.e. two bidirectional layers with 128 units each. + Set "monolithic" to False to split monolithic multi-layer LSTM into multiple mono-layer LSTMs. + This may proove useful for probing LSTM internals. + linear : dict, optional + Keyword arugments used to initialize linear layers + Defaults to {"hidden_size": 128, "num_layers": 2}, + i.e. two linear layers with 128 units each. + """ + + WAV2VEC_DEFAULTS = "WAVLM_BASE" + + LSTM_DEFAULTS = { + "hidden_size": 128, + "num_layers": 4, + "bidirectional": True, + "monolithic": True, + "dropout": 0.0, + } + LINEAR_DEFAULTS = {"hidden_size": 128, "num_layers": 2} + + def __init__( + self, + wav2vec: Union[dict, str] = None, + wav2vec_layer: int = -1, + lstm: dict = None, + linear: dict = None, + sample_rate: int = 16000, + num_channels: int = 1, + task: Optional[Task] = None, + ): + super().__init__(sample_rate=sample_rate, num_channels=num_channels, task=task) + + if isinstance(wav2vec, str): + # `wav2vec` is one of the supported pipelines from torchaudio (e.g. "WAVLM_BASE") + if hasattr(torchaudio.pipelines, wav2vec): + bundle = getattr(torchaudio.pipelines, wav2vec) + if sample_rate != bundle._sample_rate: + raise ValueError( + f"Expected {bundle._sample_rate}Hz, found {sample_rate}Hz." + ) + wav2vec_dim = bundle._params["encoder_embed_dim"] + wav2vec_num_layers = bundle._params["encoder_num_layers"] + self.wav2vec = bundle.get_model() + + # `wav2vec` is a path to a self-supervised representation checkpoint + else: + _checkpoint = torch.load(wav2vec) + wav2vec = _checkpoint.pop("config") + self.wav2vec = torchaudio.models.wav2vec2_model(**wav2vec) + state_dict = _checkpoint.pop("state_dict") + self.wav2vec.load_state_dict(state_dict) + wav2vec_dim = wav2vec["encoder_embed_dim"] + wav2vec_num_layers = wav2vec["encoder_num_layers"] + + # `wav2vec` is a config dictionary understood by `wav2vec2_model` + # this branch is typically used by Model.from_pretrained(...) + elif isinstance(wav2vec, dict): + self.wav2vec = torchaudio.models.wav2vec2_model(**wav2vec) + wav2vec_dim = wav2vec["encoder_embed_dim"] + wav2vec_num_layers = wav2vec["encoder_num_layers"] + + if wav2vec_layer < 0: + self.wav2vec_weights = nn.Parameter( + data=torch.ones(wav2vec_num_layers), requires_grad=True + ) + + lstm = merge_dict(self.LSTM_DEFAULTS, lstm) + lstm["batch_first"] = True + linear = merge_dict(self.LINEAR_DEFAULTS, linear) + + self.save_hyperparameters("wav2vec", "wav2vec_layer", "lstm", "linear") + + monolithic = lstm["monolithic"] + if monolithic: + multi_layer_lstm = dict(lstm) + del multi_layer_lstm["monolithic"] + self.lstm = nn.LSTM(wav2vec_dim, **multi_layer_lstm) + + else: + num_layers = lstm["num_layers"] + if num_layers > 1: + self.dropout = nn.Dropout(p=lstm["dropout"]) + + one_layer_lstm = dict(lstm) + one_layer_lstm["num_layers"] = 1 + one_layer_lstm["dropout"] = 0.0 + del one_layer_lstm["monolithic"] + + self.lstm = nn.ModuleList( + [ + nn.LSTM( + wav2vec_dim + if i == 0 + else lstm["hidden_size"] * (2 if lstm["bidirectional"] else 1), + **one_layer_lstm, + ) + for i in range(num_layers) + ] + ) + + if linear["num_layers"] < 1: + return + + lstm_out_features: int = self.hparams.lstm["hidden_size"] * ( + 2 if self.hparams.lstm["bidirectional"] else 1 + ) + self.linear = nn.ModuleList( + [ + nn.Linear(in_features, out_features) + for in_features, out_features in pairwise( + [ + lstm_out_features, + ] + + [self.hparams.linear["hidden_size"]] + * self.hparams.linear["num_layers"] + ) + ] + ) + + def build(self): + if self.hparams.linear["num_layers"] > 0: + in_features = self.hparams.linear["hidden_size"] + else: + in_features = self.hparams.lstm["hidden_size"] * ( + 2 if self.hparams.lstm["bidirectional"] else 1 + ) + + if isinstance(self.specifications, tuple): + raise ValueError("SSeRiouSS model does not support multi-tasking.") + + if self.specifications.powerset: + out_features = self.specifications.num_powerset_classes + else: + out_features = len(self.specifications.classes) + + self.classifier = nn.Linear(in_features, out_features) + self.activation = self.default_activation() + + def forward(self, waveforms: torch.Tensor) -> torch.Tensor: + """Pass forward + + Parameters + ---------- + waveforms : (batch, channel, sample) + + Returns + ------- + scores : (batch, frame, classes) + """ + + num_layers = ( + None if self.hparams.wav2vec_layer < 0 else self.hparams.wav2vec_layer + ) + + with torch.no_grad(): + outputs, _ = self.wav2vec.extract_features( + waveforms.squeeze(1), num_layers=num_layers + ) + + if num_layers is None: + outputs = torch.stack(outputs, dim=-1) @ F.softmax( + self.wav2vec_weights, dim=0 + ) + else: + outputs = outputs[-1] + + if self.hparams.lstm["monolithic"]: + outputs, _ = self.lstm(outputs) + else: + for i, lstm in enumerate(self.lstm): + outputs, _ = lstm(outputs) + if i + 1 < self.hparams.lstm["num_layers"]: + outputs = self.dropout(outputs) + + if self.hparams.linear["num_layers"] > 0: + for linear in self.linear: + outputs = F.leaky_relu(linear(outputs)) + + return self.activation(self.classifier(outputs)) diff --git a/pyannote/audio/models/segmentation/__init__.py b/pyannote/audio/models/segmentation/__init__.py index 82e149853..9f6f5f6e3 100644 --- a/pyannote/audio/models/segmentation/__init__.py +++ b/pyannote/audio/models/segmentation/__init__.py @@ -1,6 +1,6 @@ # MIT License # -# Copyright (c) 2020 CNRS +# Copyright (c) 2020- CNRS # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal @@ -21,5 +21,6 @@ # SOFTWARE. from .PyanNet import PyanNet +from .SSeRiouSS import SSeRiouSS -__all__ = ["PyanNet"] +__all__ = ["PyanNet", "SSeRiouSS"] From 1af9d44309f4317bc5d74774c2f2acdfc1642002 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 20 Sep 2023 21:01:11 +0200 Subject: [PATCH 106/112] github: fix test action (#1464) --- .github/workflows/test.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index df1182cf3..90a4302c6 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -23,6 +23,7 @@ jobs: - name: Install libsndfile if: matrix.os == 'ubuntu-latest' run: | + sudo apt-get update sudo apt-get install libsndfile1 - name: Install pyannote.audio run: | From 71f012bfd4c24d42331af0928ea64020a08aef44 Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Wed, 20 Sep 2023 21:08:31 +0200 Subject: [PATCH 107/112] fix(task): fix support for "balance" option --- CHANGELOG.md | 1 + pyannote/audio/tasks/segmentation/mixins.py | 9 ++++++--- pyannote/audio/tasks/segmentation/multilabel.py | 10 +++++----- .../tasks/segmentation/overlapped_speech_detection.py | 10 +++++----- .../audio/tasks/segmentation/speaker_diarization.py | 10 +++++----- .../tasks/segmentation/voice_activity_detection.py | 10 +++++----- 6 files changed, 27 insertions(+), 23 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a6f2161c5..8bfc4be3e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -51,6 +51,7 @@ - fix(pipeline): fix support for IOBase audio - fix(pipeline): fix corner case with no speaker - fix(train): prevent metadata preparation to happen twice + - fix(task): fix support for "balance" option - improve(task): shorten and improve structure of Tensorboard tags ### Dependencies diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 142245ae8..018e8db70 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -421,7 +421,7 @@ def train__iter__helper(self, rng: random.Random, **filters): # indices of training files that matches domain filters training = self.metadata["subset"] == Subsets.index("train") for key, value in filters.items(): - training &= self.metadata[key] == value + training &= self.metadata[key] == self.metadata_unique_values[key].index(value) file_ids = np.where(training)[0] # turn annotated duration into a probability distribution @@ -485,8 +485,11 @@ def train__iter__(self): # create a subchunk generator for each combination of "balance" keys subchunks = dict() for product in itertools.product( - [self.metadata_unique_values[key] for key in balance] + *[self.metadata_unique_values[key] for key in balance] ): + # we iterate on the cartesian product of the values in metadata_unique_values + # eg: for balance=["database", "split"], with 2 databases and 2 splits: + # ("DIHARD", "A"), ("DIHARD", "B"), ("REPERE", "A"), ("REPERE", "B") filters = {key: value for key, value in zip(balance, product)} subchunks[product] = self.train__iter__helper(rng, **filters) @@ -494,7 +497,7 @@ def train__iter__(self): # select one subchunk generator at random (with uniform probability) # so that it is balanced on average if balance is not None: - chunks = subchunks[rng.choice(subchunks)] + chunks = subchunks[rng.choice(list(subchunks))] # generate random chunk yield next(chunks) diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 4265d5e86..c1d58431a 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -58,10 +58,10 @@ class MultiLabelSegmentation(SegmentationTaskMixin, Task): parts, only the remaining central part of each chunk is used for computing the loss during training, and for aggregating scores during inference. Defaults to 0. (i.e. no warm-up). - balance: str, optional - When provided, training samples are sampled uniformly with respect to that key. - For instance, setting `balance` to "uri" will make sure that each file will be - equally represented in the training samples. + balance: Sequence[Text], optional + When provided, training samples are sampled uniformly with respect to these keys. + For instance, setting `balance` to ["database","subset"] will make sure that each + database & subset combination will be equally represented in the training samples. weight: str, optional When provided, use this key to as frame-wise weight in loss function. batch_size : int, optional @@ -87,7 +87,7 @@ def __init__( classes: Optional[List[str]] = None, duration: float = 2.0, warm_up: Union[float, Tuple[float, float]] = 0.0, - balance: Text = None, + balance: Sequence[Text] = None, weight: Text = None, batch_size: int = 32, num_workers: int = None, diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index cd3711d61..0b7209c5c 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -59,10 +59,10 @@ class OverlappedSpeechDetection(SegmentationTaskMixin, Task): parts, only the remaining central part of each chunk is used for computing the loss during training, and for aggregating scores during inference. Defaults to 0. (i.e. no warm-up). - balance: str, optional - When provided, training samples are sampled uniformly with respect to that key. - For instance, setting `balance` to "uri" will make sure that each file will be - equally represented in the training samples. + balance: Sequence[Text], optional + When provided, training samples are sampled uniformly with respect to these keys. + For instance, setting `balance` to ["database","subset"] will make sure that each + database & subset combination will be equally represented in the training samples. overlap: dict, optional Controls how artificial chunks with overlapping speech are generated: - "probability" key is the probability of artificial overlapping chunks. Setting @@ -98,7 +98,7 @@ def __init__( duration: float = 2.0, warm_up: Union[float, Tuple[float, float]] = 0.0, overlap: dict = OVERLAP_DEFAULTS, - balance: Text = None, + balance: Sequence[Text] = None, weight: Text = None, batch_size: int = 32, num_workers: int = None, diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index eac795a47..1094672ed 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -86,10 +86,10 @@ class SpeakerDiarization(SegmentationTaskMixin, Task): parts, only the remaining central part of each chunk is used for computing the loss during training, and for aggregating scores during inference. Defaults to 0. (i.e. no warm-up). - balance: str, optional - When provided, training samples are sampled uniformly with respect to that key. - For instance, setting `balance` to "database" will make sure that each database - will be equally represented in the training samples. + balance: Sequence[Text], optional + When provided, training samples are sampled uniformly with respect to these keys. + For instance, setting `balance` to ["database","subset"] will make sure that each + database & subset combination will be equally represented in the training samples. weight: str, optional When provided, use this key as frame-wise weight in loss function. batch_size : int, optional @@ -132,7 +132,7 @@ def __init__( max_speakers_per_frame: int = None, weigh_by_cardinality: bool = False, warm_up: Union[float, Tuple[float, float]] = 0.0, - balance: Text = None, + balance: Sequence[Text] = None, weight: Text = None, batch_size: int = 32, num_workers: int = None, diff --git a/pyannote/audio/tasks/segmentation/voice_activity_detection.py b/pyannote/audio/tasks/segmentation/voice_activity_detection.py index 967ea1f9b..fd9eb8e75 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -53,10 +53,10 @@ class VoiceActivityDetection(SegmentationTaskMixin, Task): parts, only the remaining central part of each chunk is used for computing the loss during training, and for aggregating scores during inference. Defaults to 0. (i.e. no warm-up). - balance: str, optional - When provided, training samples are sampled uniformly with respect to that key. - For instance, setting `balance` to "uri" will make sure that each file will be - equally represented in the training samples. + balance: Sequence[Text], optional + When provided, training samples are sampled uniformly with respect to these keys. + For instance, setting `balance` to ["database","subset"] will make sure that each + database & subset combination will be equally represented in the training samples. weight: str, optional When provided, use this key to as frame-wise weight in loss function. batch_size : int, optional @@ -81,7 +81,7 @@ def __init__( protocol: Protocol, duration: float = 2.0, warm_up: Union[float, Tuple[float, float]] = 0.0, - balance: Text = None, + balance: Sequence[Text] = None, weight: Text = None, batch_size: int = 32, num_workers: int = None, From 9297c0c8766879f92dd13582b6e4de3372aeb037 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 22 Sep 2023 17:45:40 +0200 Subject: [PATCH 108/112] feat: add support for WeSpeaker models on Huggingface (#1466) --- .../audio/pipelines/speaker_verification.py | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index b30ea2b21..594a4823c 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -22,6 +22,7 @@ import warnings from functools import cached_property +from pathlib import Path from typing import Text, Union import numpy as np @@ -29,6 +30,8 @@ import torch.nn.functional as F import torchaudio import torchaudio.compliance.kaldi as kaldi +from huggingface_hub import hf_hub_download +from huggingface_hub.utils import RepositoryNotFoundError from torch.nn.utils.rnn import pad_sequence from pyannote.audio import Inference, Model, Pipeline @@ -395,7 +398,7 @@ class WeSpeakerPretrainedSpeakerEmbedding(BaseInference): Usage ----- - >>> get_embedding = WeSpeakerPretrainedSpeakerEmbedding("wespeaker.xxxx.onnx") + >>> get_embedding = WeSpeakerPretrainedSpeakerEmbedding("hbredin/wespeaker-voxceleb-resnet34-LM") >>> assert waveforms.ndim == 3 >>> batch_size, num_channels, num_samples = waveforms.shape >>> assert num_channels == 1 @@ -410,7 +413,7 @@ class WeSpeakerPretrainedSpeakerEmbedding(BaseInference): def __init__( self, - embedding: Text = "speechbrain/spkrec-ecapa-voxceleb", + embedding: Text = "hbredin/wespeaker-voxceleb-resnet34-LM", device: torch.device = None, ): if not ONNX_IS_AVAILABLE: @@ -420,6 +423,17 @@ def __init__( super().__init__() + if not Path(embedding).exists(): + try: + embedding = hf_hub_download( + repo_id=embedding, + filename="speaker-embedding.onnx", + ) + except RepositoryNotFoundError: + raise ValueError( + f"Could not find '{embedding}' on huggingface.co nor on local disk." + ) + self.embedding = embedding self.to(device or torch.device("cpu")) From b7960890aefda70e9595609d52e61e7e61fb16d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 22 Sep 2023 18:50:48 +0200 Subject: [PATCH 109/112] feat: add support for powerset in VAD and OSD pipelines (#1467) --- .../pipelines/overlapped_speech_detection.py | 19 ++++++++++++++---- .../pipelines/voice_activity_detection.py | 20 ++++++++++++++----- 2 files changed, 30 insertions(+), 9 deletions(-) diff --git a/pyannote/audio/pipelines/overlapped_speech_detection.py b/pyannote/audio/pipelines/overlapped_speech_detection.py index 064cae1be..1c9790feb 100644 --- a/pyannote/audio/pipelines/overlapped_speech_detection.py +++ b/pyannote/audio/pipelines/overlapped_speech_detection.py @@ -134,9 +134,13 @@ def __init__( )[:, :, -2, np.newaxis] self._segmentation = Inference(model, **inference_kwargs) - #  hyper-parameters used for hysteresis thresholding - self.onset = Uniform(0.0, 1.0) - self.offset = Uniform(0.0, 1.0) + if model.specifications.powerset: + self.onset = self.offset = 0.5 + + else: + #  hyper-parameters used for hysteresis thresholding + self.onset = Uniform(0.0, 1.0) + self.offset = Uniform(0.0, 1.0) # hyper-parameters used for post-processing i.e. removing short overlapped regions # or filling short gaps between overlapped regions @@ -152,14 +156,21 @@ def __init__( self.recall = recall def default_parameters(self): - # parameters optimized on DIHARD 3 development set if self.segmentation == "pyannote/segmentation": + # parameters optimized on DIHARD 3 development set return { "onset": 0.430, "offset": 0.320, "min_duration_on": 0.091, "min_duration_off": 0.144, } + + elif self.segmentation == "pyannote/segmentation-3.0.0": + return { + "min_duration_on": 0.0, + "min_duration_off": 0.0, + } + raise NotImplementedError() def classes(self): diff --git a/pyannote/audio/pipelines/voice_activity_detection.py b/pyannote/audio/pipelines/voice_activity_detection.py index 0edbea42f..f67489b64 100644 --- a/pyannote/audio/pipelines/voice_activity_detection.py +++ b/pyannote/audio/pipelines/voice_activity_detection.py @@ -121,14 +121,18 @@ def __init__( # load model and send it to GPU (when available and not already on GPU) model = get_model(segmentation, use_auth_token=use_auth_token) + inference_kwargs["pre_aggregation_hook"] = lambda scores: np.max( scores, axis=-1, keepdims=True ) self._segmentation = Inference(model, **inference_kwargs) - #  hyper-parameters used for hysteresis thresholding - self.onset = Uniform(0.0, 1.0) - self.offset = Uniform(0.0, 1.0) + if model.specifications.powerset: + self.onset = self.offset = 0.5 + else: + #  hyper-parameters used for hysteresis thresholding + self.onset = Uniform(0.0, 1.0) + self.offset = Uniform(0.0, 1.0) # hyper-parameters used for post-processing i.e. removing short speech regions # or filling short gaps between speech regions @@ -136,14 +140,21 @@ def __init__( self.min_duration_off = Uniform(0.0, 1.0) def default_parameters(self): - # parameters optimized on DIHARD 3 development set if self.segmentation == "pyannote/segmentation": + # parameters optimized for DIHARD 3 development set return { "onset": 0.767, "offset": 0.377, "min_duration_on": 0.136, "min_duration_off": 0.067, } + + elif self.segmentation == "pyannote/segmentation-3.0.0": + return { + "min_duration_on": 0.0, + "min_duration_off": 0.0, + } + raise NotImplementedError() def classes(self): @@ -289,7 +300,6 @@ def __init__( self.learning_rate = LogUniform(1e-6, 1) def apply(self, file: AudioFile) -> Annotation: - # create a copy of file file = dict(file) From d169fd37708d5f913b71841f84e93dd8cbefd174 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 22 Sep 2023 22:19:36 +0200 Subject: [PATCH 110/112] setup: switch to pyannote-pipeline 3.0.1 --- CHANGELOG.md | 2 +- requirements.txt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8bfc4be3e..0da78ec6c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -57,7 +57,7 @@ ### Dependencies - setup: switch to torch 2.0+, torchaudio 2.0+, soundfile 0.12+, lightning 2.0+, torchmetrics 0.11+ - - setup: switch to pyannote.core 5.0+ and pyannote.database 5.0+ + - setup: switch to pyannote.core 5.0+, pyannote.database 5.0+, and pyannote.pipeline 3.0+ - setup: switch to speechbrain 0.5.14+ ## Version 2.1.1 (2022-10-27) diff --git a/requirements.txt b/requirements.txt index e4c72019f..7e71fe024 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,7 +6,7 @@ omegaconf >=2.1,<3.0 pyannote.core >= 5.0.0 pyannote.database >= 5.0.1 pyannote.metrics >= 3.2 -pyannote.pipeline >= 2.3 # 2.4 +pyannote.pipeline >= 3.0.1 pytorch_metric_learning >= 2.1.0 rich >= 12.0.0 semver >= 3.0.0 From 76d86fa97a20a8a67b55281cee498d376441d963 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 26 Sep 2023 10:09:28 +0200 Subject: [PATCH 111/112] chore: remove prodigy support (#1469) --- README.md | 1 - .../audio/interactive/common/commands.png | Bin 138093 -> 0 bytes .../audio/interactive/common/controller.js | 367 - .../interactive/common/instructions.html | 69 - pyannote/audio/interactive/common/regions.js | 1362 ---- .../audio/interactive/common/template.css | 41 - .../audio/interactive/common/template.html | 3 - pyannote/audio/interactive/common/utils.py | 169 - .../audio/interactive/common/wavesurfer.js | 6541 ----------------- pyannote/audio/interactive/diff/controller.js | 231 - pyannote/audio/interactive/diff/legend.html | 5 - pyannote/audio/interactive/diff/recipe.py | 258 - pyannote/audio/interactive/pipeline/recipe.py | 231 - .../audio/interactive/review/controller.js | 228 - pyannote/audio/interactive/review/recipe.py | 220 - setup.cfg | 6 - tutorials/prodigy.md | 151 - 17 files changed, 9883 deletions(-) delete mode 100755 pyannote/audio/interactive/common/commands.png delete mode 100644 pyannote/audio/interactive/common/controller.js delete mode 100644 pyannote/audio/interactive/common/instructions.html delete mode 100644 pyannote/audio/interactive/common/regions.js delete mode 100644 pyannote/audio/interactive/common/template.css delete mode 100644 pyannote/audio/interactive/common/template.html delete mode 100644 pyannote/audio/interactive/common/utils.py delete mode 100644 pyannote/audio/interactive/common/wavesurfer.js delete mode 100644 pyannote/audio/interactive/diff/controller.js delete mode 100644 pyannote/audio/interactive/diff/legend.html delete mode 100644 pyannote/audio/interactive/diff/recipe.py delete mode 100644 pyannote/audio/interactive/pipeline/recipe.py delete mode 100644 pyannote/audio/interactive/review/controller.js delete mode 100644 pyannote/audio/interactive/review/recipe.py delete mode 100644 tutorials/prodigy.md diff --git a/README.md b/README.md index 1d314cd92..721323b6d 100644 --- a/README.md +++ b/README.md @@ -74,7 +74,6 @@ pip install -qq https://github.com/pyannote/pyannote-audio/archive/refs/heads/de - 2021-08-05 > ["Streaming voice activity detection with pyannote.audio"](https://herve.niderb.fr/fastpages/2021/08/05/Streaming-voice-activity-detection-with-pyannote.html) - Miscellaneous - [Training with `pyannote-audio-train` command line tool](tutorials/training_with_cli.md) - - [Annotating your own data with Prodigy](tutorials/prodigy.md) - [Speaker verification](tutorials/speaker_verification.ipynb) - Visualization and debugging diff --git a/pyannote/audio/interactive/common/commands.png b/pyannote/audio/interactive/common/commands.png deleted file mode 100755 index 29517df5acf800edd10a213c3cd2562bd58546b7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 138093 zcmc%xXI#_S7C#CrQUwJ;L8L=MGk|~;0jVM-(nXAP2+~11Nbe{;H0dZH9W+v;i%JQ- zN(boz(u;KN4(d5G=ehU)dG4$GVjP(X$^PxV_FC&(R$izo%U!y7_db&N$Pf?wO!Q11;c)I8 zB^3M5c?EUI`nhwb*$Vfh9=huNOeILUDmxPV3zhcVRN2M!(Ssks^dT?PUMfaGIN7D% zpkii8P*V1t)bY>-*d5b&k~S1BCElZ`l-=Wb{p!2ho!{D((-srGch>eBoV9Y6ZjGK-!x$gAd@Ei#~*1@n1B5oKsJpR3;UlJ=}G>7_@aHU4wU#GyFzJnatJ{{}9-yCgBq@I^wHbfno_b}P`(Jzb7#H_t z`1faZ9{X9|rze|Wv1a~l0c3Y6*py?{vlWL+vTNM7EJ}o=$9z$N|2QAw^B{Nby->=SLzP$%OkcjEzLPyZ?g2buX;8>}7 zU+Ex}DdOKB5ahVnD~sno>2+vrEeTfRov&3=TwHBiw}0PVmwcM=Ux#T(m;{r4M@471 z?AH)LcKX4f0mo_FS0hK+yhKU5{eRwA?0CD6v%A`2fYbWcD>Cxy^zJ`-omQ-e(X#H= zx*wTUJL`~)H0pu$Q_Q4-tpJ{A4n$B_;X8d!H zx7;sem=W26cP65Xg?*(s`-nHM@Ip7p)|(l;**nuERQ@D|#ZT3K8> z7IT)?48H`KFR)C=V5G&)ZUiiZ>G3(-wg&$fX!k*>-@7UQ3T^80hIYuCJ?ncd69)%} zZV{zS>5mCfc{A|YcU)FeN^K|giWV47_k!DB@yaB3ksx(fM#=`n$heY)Y`@L3oEVN* zIc@gBdGa;|Tap9{V7gVYD5wvJ2$c*Z$OfT?9_B#_Oh@Z8=Uw^^aP#(^#D3=p$OCgV z&&c+dqSWf;HX_VyDrpbP5F|aHM_^O%cS*#euIm}IZ3!wx1(Lov_CLCrti}C7-fEeN zlqlXLr4zZW%kTL0bbEDNJI<+CrxMu~&y`=p)ch=k9f3mtCEmcrUXb_KpJM!iZ$3QK zuNRS0^!OP5I~2g(Vz1L?jeKyCBYBV^8f1{%k@fkfU)T|!V+?jNem7vb7{48-#oop| z;r+P;{n=2SI@Nu}IL_>>RBnb12CgTis&nJuRyj7${piVzg`E%h&jFMCy_kh^ALZj` znj;HF)-f1Nz96yR3oAaD7|~m#R66GmZM{vxHa9&US~Kr^i%HP;;!wG}6PrY8Kuss&81*HX)btg>Xpq>o zn~xqIRv|Iu`@5sID|7?KdRD>3w2lU&?_kE`5g9dnHzjBpX!}4tQ7E?>{<-z0@5o{x zA2U*B$xkbDA+`Y&nTLqi?e7?d7}_0XTdtJprQ8Gy9q42r`V%|nn~xgr)}hY3MzJjX zobyFb$#B_GeLyzsgNQ!6F!Fm8+$g+`yHj*HNPvEn51X*>Sfc_Bau@yg`_y+7Nsyo%#}7Fk_lVHL8V1D&%ZA zF7+$eFLWwlq(g`lDaoH1EdE*@ziHeYp{Xx@mGhzeg!|fEw_oEfnKxpk8vO7EsPK%N z!lLiG@3!P=M@ptiP?ibrila zq-Ry3=HDdDIwbMH`*5Wq?lIrI3?k#ftxE!WtV&5)yA;h7&BL!q!HL<^fafL)W4JQr zWB75yKmM+}v)j&q)?6T!UX*E?ThNds_&rrY_RI)6(R>EcSh`kKt@41sg~RABJ0c_} zKpK6H@PZ60MOu$ps#$`xkjzn1CDxx!j z9?dj`4~RW3F}A*T%e0dg8s1&e-V{zVApF%h%&zL>>9e8?3=fQIG{BnwZ6cJ|BI;Ee z;rBHLuRSTH;Fbmfv$WNVDp2BLyG+5$vzN<9#TXvfJ}(nHJ=)@otkenT`?Qe`wzkUc zQ-ePNRKL!{LL3~F4T!*_%QpAelv7k!w5OXaL*l?aK^&i!4eDtK8EsZ^62}s?Hj#0= zZOv;+L^S!oC=OF_{2R6*JL~t*BrBC#&s~O??~d5?_vXwzq8=8K5-qvOjwqDPg%EcV zhu{<*`jd*Q9+zZL;v0z(qLa6z?}L5$B!;s+Z~n9?lA$EtwD`^yc8vY^PvP}#aOCh9w*cItIQx3~t{niL1WEthUpeU5_VdVc4@@VRXwS6rt>U!!2> zlys$p4UW%ko-31}-3q@Upr|CrKv#Tl!}qbTfs~#MHV!214ctFG?cl_AqVpT^?GWOK zYmi7c`erfTc-U%2GSx=@8`;o&JK^Gpt?L;N)XG6~HU=7zy-Q-Rrh-Ts{4RH>)^2_w zm3W9gmzq2!b(xZO-*HQhg&lj4_?iN0&J3R0(VU`U9vMFwk&mDLZW6H7i$Qff=l?BGX_9D}BQ+43gYBvCf< zeD1K}HjAI~nq8gn{Ni|ZMN%4q;&D|*oha&4O0zBo=Y{{#E7Gmy&5y(fo#SPe2@ewa zWS0g@c!tp?8g0(32%RGSSQMW6wT`z_DNAFO9}cdM2$wh2%-@hKZoR=5PB%$`qF1Dx z7Fv%Iw4asV2mOv^0xq~O8l=yvjvy>#oUW3x!>>uyGVvsw*|l}O$W#A&ACEW?;-?=A zlJrgr3>R~C?NB6p=E2U1pQtc?9{%{36t$|)e-Cxh^#Vr}4Pl?fhJVBjE_S$wu8*^l)4qb^Ut9t%QV!A%{~qyy zeGeCfD+?l?OPe+BrdGN4&T2~(lT7K>mC5&hNTTK>7{6)f!+l<8f`x{4Xr(Q<3;o$vP>rth%x_nS%e8M4D;%|WxSd2OJ*4#wPb z{%^_t_C*nem+I%THlb@j+hR!CE0U>S@3lCg6>^v{784UQu<^-GD$09pq84r3e0jLW z?Zfukq<);8Fg*SR1zY}N+BU`r)|LplWqey{&Vq&(QRSFNPLil_&T;edi{3IzEo{Gb zv^NuJarYG|v-F@?5|birf^`@v0mg5>x0~%!>pAq?EGA}g{z8>ohbLNCl-|b^O@_Jx zVuat7{gaGjG_&k1NZ6`E=0l#kdeh=RGVuibRo?;(1oHWAZgLGb&kJsBs3z658I~~ z(!JwBTFf&L5m}S#8#lx8T>svnNNZT%?Sd!HEPJcYZl+1S!bUewEi)*8SfkFvjYBg( z_Ug??55!N89QJ>H=$egD5m%GOJ??+Qu`{UWuB7L&A?vm~Y&s`#x*sXF*}`Ifdi<+x z++~u>`*>NuY%Y%_1xnnywZD+Ab^aK1-j-YEVtL~IpZ3hm%nS(Avh@2jxW-n`h<$oo zS780@>sSThw}Q3{(T_o4k0X#iKZs{^YmcVP!Ex){tZdq|cvukZ^NFEE$JX^%kwv^b z#WX1k*MpxnJ&SynLVCR!g$j%s1-B@@A)G+Te~OrDo255PfnsMSs|`LzU=l*J4}dES ztRjKexG6VSUssP@_rI6!vnE258o^xFuL&>&^VULF0sty` z5ubam3LaQdi#X=y$Mt+LRT;R5Usr59kRSJw!QcejaK&+IW&s$hxak2}%%#u+9K4IU zjC@HDZ_t4ZRP*9gyQ+AtRxZrGU`ta?UCUexb6>5LJK3$MH?QE;+22Y(g}F?);`v3Y7 zRtr$PMGbdu@OFciv z&%RM0QY>QYP37}g;!YWzw)uUZg8$Z^bgA#B!3DLtJo&IMhmC#{yqL0et4RN2aybxXeC^Jy#y52xA_r94vhArJgeIUq3{-FN!P~zHS zIexVt#Mh29n9aiKgzNU_X|OG==E}=_%>qs))p{>ab8Mw+!|8Z_y4|PJTcE{5eapb- zqH-kt-6yOMUS$|DQMk3=P@kYSO8-!uRgTz@(5QeujZXkHBD}AIkd1*;M zV<+~lM8Cwsz_7~KO)n)`c#U^L=Q6u!Kc_VOW|K#R37I(vIxIjF_h(>v7~V)lNrtmG zWxrtP`w`zHgtIhPFAUu%!%)}MJqPWPWrxBSBP-e}(ybCu42wB2>ld0YHW#($jF$Bg zVN-$pGeS@ne1!di%*ru@@duwlAuaSPB9zQ5#{kMB1E)SW&~JpD@LA^D3l@19{kYFX)$c4NcaVGR_v99#Rc5B0hg#$lzFaPUMi8vIo<2`scbgI% zpulODK9}gNl|fu9kf;30)4ly99){>mrFq&Na3dmpriSb~2>ss93kuyu+Ct|2xzPus z6d0Umo!3W8GO<|T_`Vk*qfGmcPj~34s7%*b@TEIm38g?n3;6JI_XEWf7|Aw-Aj}c3 zc_l0gBt=9z32yNe>+fQu<)5D=eI|TOmvpyzYAEirn87)gG>4xrzb%aPj}_Ay$Ou2Juer5apkY((6V5YCJ|GbVmvDFpiRroy>&2sM}eT} z+HqF$AgXap=XwBMlJWDIa3MZijd8pVzQqackhRCM=rm|@CPcRfncr8}dda>=gws_AoB9Mvj=i-Npld2aGW8G~SV(c*?uYa#5d^_n z6L|FT?@%cGjb|AQxv=WoFlZy6z%kO2>=5|=(FR}PDDRz*zffaUvJFOMu|}du?;|gn zdF2Bo3$I#j0fx7to!G-+f;@BOL~zDk=dz~Zj{9iX+}BevBbcXdQ8)=Dp5PC2xx8KL z!y3>nk;|l!;#+div3B#Tw<&mh5gq;c%k*No7F8Mh?{m_gEAFgiY2VKREHsu5+9QF&zk~ZPB0Zop6g0Om z`>m)nC1INYn`=uLoQKu{nB#Y8l>jgwTI7u%o9HkoXy}7vL8Z9?E*5q0iD_U3 z9ziJRGjL*bucKfFefbXNQ_ooo-o|SG>FmgvkDv&T1}%)y)5YHGCHSx2Y`A3(1@-}7 zA{8-q73D)1JD5_g+e=C*m z-IiKK5(y1JgF)LvEXMe>z5oCI`iAany52JLHxFowsTdo4P>oN(29t~Y0dVQBkwmny zuzSH}5ctcnDmx8s{g2%B>6P53US%7jP72C(+*BoFsALWf^L?v3wi75zs=iHOlwcP_ zg3ZW$gL=3lyjZ`E$@|AVZ?wm5(9k0`jzQa&{SOCX&Q@;kt;>I!bI7XOj77n{vsS+# zM$4~{I!xIw?T#tGU6HDD5Sl&U8a*=Ccwd;TW!r++cTlWT5vMlNFUj_whv(L>Db013 zWF@(ickTbU{I*MXT-F2HY09-m9u9K|)D3YA)D1%~-B?K=Do}2FK`b=;^hsxd!h*^2 z-d**9_~vK}sI$VCphJ`HLJj*PqnBgvv_mBzh9`!LC5a1y)mduc_Yig>vc;-!a94Py(Djo67(02M7m63;|P=QcmcV~EJ69ID1Ph)d==jx%jf&1ll z_$a-0TK-Bz%gHQ_{ax$)7TG&>Q@JD>%OfT%QeG2I2tQ4^kl&;?#4+{+S&d~M@m=n) z+I^8`c>*9m-ak0v4Qj>sPas$vAIqS#_Z)`U z;v_el54!nY?vj+JNz7W#46)^t%ixKp#i`5Khs$TLR=O>|gjfs1E-bI14u*m~%B}a= zo!nc8%5x4}+_SB3o62akumg1ZPEhdb*pe z?!q_S|9QH;3oZ8hGuhUuxYR=H0gwD}Z=Br-a2YH-lZ1q;u55M0;>VJ1Z z8a-CSRN)0j5p}pImf?(MJ?u#>Cy15dd%9;wJ-F;sdb3QauA^3|_0bU9d-!Qo)=g?C z-2ZJe@`vPTTZVNSukK~};LXwO0P8ezS!cz`K#cu1ZGV^o+QTSW&mxlKhqumjcVg~~ zVT~^N>A3+x|vb0iL11V23ZT3)NahKg8; zY#DmZ1}UCoTGa3kj%~BnW-B+9Leq){9{`+qR!_d($+qhHFiDR8+P4$Id&T!?@{hXb4T%# zhV&_qyDdE4BAirV>|3Zg1^-)Zs*@;x_%3`#tUSR``{c$-MC;~wIlA6X!zM+7&3&FO z>SZ?4299^YoC_NfnQRGtmZJ+5MNl^XSLjOeU2-?yb(+ToBEct*1b9ZoG8B_&Lt_ z(Q3P>j*K?RxWH@&4b_uw;8qE1`+-SUK4 za{Zq%iOJlp!?B;>@v+)@smuCx&*3)ttgT}ze~x2HDp71S+pf`*FQZTG1gDx;^LptE#PF{78^5~HqA#KqOP#butBVIPI~tNX{Fs1qkAhE83nD^}4K-(Ujc zQCo6dEpN(4vu-EdYO96c=RT2%(7p5yS?Q)*oPMJDO+}cI#ao=^MUJgY-kS0otegTm zNK(~gyf@ja74BKuA7uFQf7umX-4Kd}ee**>T|vs1``?TYg|u}n+iwlB@MRd)c$~gi zfudWK^9Hvw!jgX_Lyn#bU0X!KG4{)EQikm1pAR?P#HbtA!-l-nP6%HiD_L`mMk^pqPcY^{K>SAw%lzufID zd{9#waTn^YZ2qg?{O{sutrV zul+{!w(O-sDY+ifhmfZ%=vFx@ROnc-l@Hp9yFiG`DNHu7;)w@)x|rK$uJsqerTK=s zOcGVfAsgev`lC(wi|}wK5eA~W{~P+`DCk^#mX0Wow%kh0H)uJ0cx*Ha`Pwy4%^`i8 zVK1~D@$88+n{Hg2P}qEhjy&Zkx|r>hyZY&B41W2>j|^ z&1C7L1|LhfEU|aOvFZDiZB({&Vr_5vGOv5x!_Jm88Lh_M=NxPmN6f|rG>2>Kh!kiH zvd5;2mwLdkS-ISA1N9ZR$P;61M>oIP3Y&(#YZ+``M_DWTBib$d-cP*%z{FmD}M8Y55=l239>dNw7H%}tXgGbzS= zbtWUFW24!t-H>5Va=!)$B1N@eo+;6p(aF6XCEG=x`0hu|(Gn?UniA|9+@4unVcta{ zmc!q(NGY*_QQWoi6ZT6wk|~0jhFjfgeIV?>-wXhh?>*K?_~5b%lgp?6K098r%Bg zaukhB@MX;{!(n&=x27LnAB~Vrp%JtReF=jTw(?m})P`cdd9ul)7}ECg+RdLh7X{3m zSI6?=gRL8#jSqQ?9_Fbpwz6?^D_dVc_5!_f_UG^i3$c^b+vX_U5y$0k9pa=!41f2v zfs_~uH^5>77z-lIan5D9nqBQ+aFioXe3aWnqPDjE;5f2vK2r-fsZkA`HIr$r4*C#| zR3W`q?@GD1D<3&?;`E2~gt4hEWC0Y*Py>bdM1Ir!omdz` z9fd;iJ(vU(3yRKc`l8?YnP(>t3mz$T1drShPM}=?!g%^@YaD!zHfSVcB&z;%SPjMvtF|;5R_-hhYRx?VwVG;3-(BzRJ@EBLl9?!=Bm_zSIs*P%_w2Ek zU#Hqp*Gol&hu|B19LLJ^3TkRpy4s|_#$mHfU=Wr4aAIZCvof{!{hHzM$2BxWUpYEC zKbtoOi7`&DaP})4aZ`(+tLMz=6+Rwysth@qqJzNWLN^eGHi;1Ryr(v+a>UKG7|Ypi2H(f;uUF`ZTn^;$-R*GKLO4X=uAXP zU83#(>UOffz~92iPsZ_z>M-#5i@4$BtuAONRR*Xj3GdK#Ks6^|3j&8@X!R+2a*C)+#k5`gRHtqaP+? zZ!T~ve%{nKS-tmjhI-gxJ4xrG>>ru?GtkW}ufQ;V4hDev+4WK-={6-yLh~KKdpa!f z-6Cl3yxGirN+9ASB+}@@ifEVq5>|q09JcpG zg+gAW)iU=xIo2Zd-FuTD$(;4aQ^e5FGLSvb3zG`kPQV5Vv?@Zc@MGC=VD&&o;rzJG zz|0CXJ?eR0iegk_3l$+?^HN{;9Ukp(S#D(p5hFvR(*sEVr}DBKK|@=@iM8g2!cx_@ zwyf1RL8_{rV@j-BtbyoPu`WcU#S4tjWE<&?+B?|BM6h(W?CNWHB)~w?ZIBxFng*M1 z4=+yo=*%T+^Cq141Je8z`;5?0GEt&t#t%X% zG5iU|ZE^em(nHaR!|5E;K|y5BCC9z#3~0I@+jqA`#UPgbIm@G3ABAUDU^ zI>T%2-Lt$Fb=5PUSzLNFpoV8h?3Xta5$@;_mHwiTRUD;5ZnPWg~kcgDcQ-|u0LjQgCr!-lp@vzLtA4{yu()>jJ(^p{e^j%-e8)9N zsQk;Uu_{i`$6}_Z4zsmu>C|g~ICGe2D`Qm36%vg$dNXAG9z1q@bUD3_TS)zg5s`xa z4U#j<0ZtUo{sWJZ(b|K>Z4AN6ZJQeeS=!@t>Sd}H9dW31o0yA@F7h#~hbHZ@lgNb^ zmiCKP)@*;1@O2q%OUr~n#l*x#Ne2G{{bkSm`3M1#`{6fCCIvGyUE~;{jBHUnL#S-v z$XgN<>N39Nb>te?3{wVqssD!*!Tvck=6X7H@MSs_NZxIuw)NI)I+IsSmmyO?T>PDF zfzJI{+-v(h{gI=aG*LNbNZhJ`JF)^xvVDt!nJ<15xa0jZ%u3f;{cWTOcjohBW|l+x zg!ePbEq*%~`^`w2H)8=@x)Lskh{C%}ELLux(7J=O?Q{L+oqgBtT=Rb7rJO9+W%q*S zxZvj@i)=AlYW)6;ZHY|VM-8;s8gvxZ*ISfqf4q$tuG-FeKo?&{nt8yGKs2M$+Evii z@?OHK&o+CmtRt@UuC@CCT|zX!GQ77j*`6P;C7KG#Vk~Vd%c9Wg2>lqixdy)y*yp*g z8hquGJbcE-3@FEwUDUY39}w4b37az>DN*+4etO>BKM0H&{11fS(G1>4YT^8l5TGS( zwT>lv0Vhxv;XxE{*9CG4ifn@hKTgst@^XrqR3cIx9v95OFsmr9N7S@N@ zL7}*Q%a=#|UHCx0X5ah<;QQWuQAY)G6q5hO%<{ne0fGRE=ytnnbosFs(0@!0cUP8l zDf(1dG8JN26>)2}d*QqDWnnkyUlDW!u1wbJr@~*^0&|8%3e#gr@Gw5x*MZ`f#4s9Y z&7<@2T@ro|&XiI6LjEHRNQNt(xfvdURzn%_!N-BIeg?d|Wx!PCY)3&wmDA+EyE0l} zNjgJUftNZ7Pz>L=h{BJ*b!?Vo6N5~(XV9vE;~Mpj99(oYtTQ@J%>j|eCfvRsMYc6g8D0?yh&>pgOD7L z3SZ?X`k#vW?Y(rP|E`EONH;b%jw`j(i9f$v0n8ywRebYpg<(E6+VZadC8vp@#6-aV z`(JwWM-X5%ajR$COX>aI7GV{OYTTB1uH+lR<`MgLClAuabp>+ph>T}TGz;RbCTb9= z+Ca^4Oo`khnkNoIHq-+}K1R@bWN5AhOB(|@yR?m-e|0<3uk%>c@kd6yzsI@5(Ofl_ z!xNECf0tb-JU(|Q{yiNT-w#s!j=aV4zyN~30icQor2ltm%;#C_Ke+aV4c58y4hn|= z*JssYz(=tDzg*#uHK=L)K4nD-aLzBe=4ME{_kiRb(k+?y7IH9NV#;Rp@B!Z5slH?Tee@8(%4?aX#H61#6+g z+HDtlGo<|g*lk0)aN+33zN!lGL6>M+ZN_7ps|nbx^TFxf0~a|3v8hesLrtl;KpO2zOFm) z8w}{B2fPB|D=vevPX-?dtgyK>^@+en3l>H`UO59|Z zPJ*@&BD0Z`NGU+K%2i``t&07E2z{I)AO-Wr4rU&lK@MhcHp|h#M!ORc>EhnZcne5E zV!K1eOCzK2je~bb&fLKpiIVX6@oJYg;G=_`KQQfC@vm_0Wow&m4ApdxUaLE_5gEo= z|DyWl9uc*e>pKVpVz$8cjp-^1FJo6G2cN)Xf9!+3*{R9?-1;@6^AQl8c4_25m=1#$?uVKVsKjLLKD_5u10MFD%MKR2=7@t zC*{!Vh~(8*W43?@i_@K-@V%A`s3YEYMh3Es82rgdv@cRdFrx%JmF`3;#3jR z4hfJ|Z>_rv$HUyHG0$J)ivh$VE*&v!kytMzR((!Q51@JtQp+v6GNvKBs96 z`o0(R;I0D(-&0gaBc1DbBQ_JvdsJ z&vrs=08v-WLv<7t%b{`qe%N)UGd4&?8qWULWAn8N;DH!mHOc?A12`ZPLPB7jho4#J zcN+*8%>MZ7&*Tta6znPJzLmbt3ZbE?T z1!$;%Q~?F4_+G|yIk^wtBcu$aL%cu9VeX4r_2;UMEJu@Jo#CdS_maB>31y)Xw2JCX z6@`P5h1m$v)pw^KeX3Wh;1{p5GlIMq2ly)x7rw!N?eNo=Kw8b#D$(0@*#bq)l<+cz zw8w>x0P4ZVpz@avGBI_6z8OS4xv(@7qW!zv({F`{d<%Q5y;edHf2bHx0Igu4Vs39^ zX2gW-^snELa04GSof@yD@eU7Nb#!#9&havRb?^T5($3m*6T>#L97(1H($LwK054Yr zt(dDS7DRyz7z>Q;V<#7oKGs&i0s(tcDlaOr0ov`~8$xCa@TGXV=WgOLU5#eJBWl0K z0J1L0qH8lrRlg?O%LeI~5&_SBc7OrNAYy=@1uOXP1B=p}iuXaxu^eX4@Ze~xOEYdB z$kJdpCcx{@E+Tf(@ht{J?+kZcY;W(31HA2|L+9TdK(_E8MOY1Zu}$jZH|IMFY9|Qo z2>xiSEMw5n#MxP7qKH#|e<4BxG>jIf(R?jHfqYo3gU~c@x=?FF{S|mke}4wkgd~Ri z&KYZHO0za*W{tBpw%2{7!)tB4T1ZAUG0JT2&wvV)Jz2mqp2=pQ%E@xY>3&G{-wk_& zf<=7ywfW?8UcK-!uiKB;!M(?>zP~2D^);=VB2#R`7g$Nheq1r^5LoDExeo|9R;t?MUvzTuMK~Y6P3W)<$ed{ zR~mK%GnM0*E^w)E=+%6jZBNty(-!YZ)+Pe(-2}_1ui2kZ-UJ?YMNkNkV;}8CmP5#F ze`il}VP*yNtA-1AlP(pgXTQX%$<$s)dY(I)So0OuY$zb}R{Q?#e+3dap0B5WpFWxs zK`Yg~SL^;O9@r~eK^91ms+#Rg)pmLp8L{iMB}enmSivs&2wOd{64w6Z# ztBmlarTj$%*_w|7sCXz*`M|4!u`@Z**q;;+IbV00BcPam0vq z`tcA{ncTba|M>e-7*sUaZuttE@hs36+5=Zq4h6UO;pim9cA};?PlF9n?^Wx3BJcCh zs|gk#a{71U*b#iD6E$wV?+j%y(JXQzQ#fg^(?p=$g@w`HQO82^)XA4%mwpFx&F_h% z4T(S5fdCq6Dw!pjD_JP{PFOJkB%GT}7kD$1CpmvW+KTCdkw1Nm|6H-@*h`j|HO}71 z3+q??E!%H|V{Kt?zjOy&Pa@|hPQa!WfjdEOo4aunZBCxavLS%5mfr#Y6Xy7!ie{aq zu_G|t@(1ZpORP`(bZ+!0h>Nrd5mWgn@AOoPiww(EF2`Tt{y!`o{#{;P9=I!mZ(pCB@4!Z)3jV5h5jG*om}iui5?g5s>Fb5ZA!)svP8*Mt|t!xsm3Mh{Ik20 z;lV%eCU*Ds82)3RfZm3%v9*EJp9P@P=2Ah)(SCp6+jZVMFZ;wEEw> zj!mckI+(aC>il>YTD z{)}tDgl3iiBiTKO1m=Fsa!Gx0>u&9@iA*FB1)~O|CZiT@ATfjlNs`q*QR`l|b$Icg zHx+vv*tG0{Pl`LW%Ug8WZ6M7TiVVrg9aim+HzXnx0Y41p45UR#|CGMppK}6A z)gB2>EqL-c&~&w6=~ZyU8{+a z`Y3j?H=_c3lO?v}Yy6d|k37tO`hx$DM z%Q!H&f*srtMJL36K4O-Q*?{n3a+p=!(d6!~kHBe@zg~ z8YVQ4BqDvI_~Qc|nkejKet*gfkKa-D=PZnJlv7clP!~Kc>JBDMl986ACbg(?3vp0= z3LO4X*ntJ~y+r39-BNM949{6Y|K<+tVA7zjOZIu7O0BEO8J_it?L|tq&R0Qg%1c_L-gFfs)+4jn)R*^;p*9opkFyB1{w{F!#tml7R@GQTPyQ&h?cFlmE zNxjRgYC*``f5*TRj3GuJAO5neXq)^;^js3lVtTwcpKP07hnN6^hd?{i6nNseuW(=0 z9}0Aeok`!f=@YIqm(JX+jc?jin5jZyflW;wECcITZDCYqG-5V>{2iqvW1}e#JU1e^aoxM?2Hho;RXc z_PO39@{YTChu~uD6zJSdfK7L4?)hY$=ZH1rEcyBx131BlHJhrDinCw*=D_{UKhhdI z+#tR?4ElgivcM1YH&!P<`BOvACtdV6@HLYPr}Qw4Jds^z3=S5a?dxC&&w#12veSqe z%viGa8%Pa<**}euQu9p6wYIQA{d&DrhFq@Q!TJ+{RLRQ2)oRTxqj|ed?96OgTNg=9 zn3UxAIa|=*+aGM3SGsMz#bp6AJMe*#hCxrVE4dvPrW{ts?yQtQ$BBRM{>!GU9Z>kK zz847ktJKxid%w{S1@HwxzH9{6d=`X2q2?8FXHmCD6@ph2Iwey<&Hq&1!=vWl6+u^e zgZyJs2!X{z<_cB$EG zdfJV1FM>q~6V32Ve9*7%IJ_;j8dk?5nAVFXK{sGzF!nY{aRUlVKi1FdW!l&Q!aJEU z9K}Al!(gnzdARdag7c432K_<2bp+ixy{9CL4fqZ$$sR0`pf$(ek+cNAKF((3h|mW9#pto5bK*# z3BrC3I6P9q5{x?ekBai+IEwe0B~D&<@{eyi0SflMK&sCZs@D$&OZ2sl(UPSZf}u9r zch94VesLbTgHtOl3t*j+rQ#VNud5t{>LZ5A@0B94L|waBq<~GwSKj<< zzsbqgqk@739fu~s$TAjZEy;W)|$q$u6EeDIUYw?3vU%w?P4#!e6;lM)c-v9g0CPSuoDQo8p7~7xa|-Hw#E;fx z_Cd3f1u#o~VnEtm_Yu(w7acZe=mOE^Re`z*_}cC1Q62LZcOuohxJHlG|F4!_e}z4 zz&F%Tp0boKT=E2{(Ujd(yx+r-Qq{d?+{An>lN^B2=N2*i#>Z;T--XC$o|Kv~Nq_;E zZi}*%dRIh5dMz_x%cDEw)Q26WU#1)!ztnlB)Yl=yOamO?N%)`)f#Epp+ydx66e+o$ zWMxeOn%HEvCAzo5Rv&6Swiwd|My0X+(BGJ{K;gZa`p_k=fi?k4MWv+t+#t>|zL<^V z(66i6{?Q`?O5ZAqh=Mhj%2uA*qemE98p)SA&n&htt^#fq5>6xZ$k*&Bbn^a@^GwBM zDGOW_@1-sRP)GZ?zvxS5qzDt|*=rgJ>BoE{E{1oQ3uVQJ?}iq)h3#3QXA&L`+i#$} zs3CkC_s|)S1jS!9d|>R<-S!PJU2jjb>2~=ga11`Wr0A1R!zQuK0kwnU2ol! zr8y8}B%c#ry7oBZ={@NoB~BudF(C4ufsSgPv9;tJ!12xC*q##i&l0I;isvz;UJ8HkSShZa>`@;#oYR+x1#UCx2{MPUE^o!tXUqc15 zKgbdln{tDMt;d%Qg|}b_I>{`vo;UfEciSW9?fBt<&B5|Kxn3{+cioy89Bh5W;dXVq zr_Tk#6yCOi0Gn+NBtLA|VqLfuFvD-&3mE_p5D(l+_eZWS{JBi;92S&!v?Ik^!zSHt zGXzCmCbPP4K-GXeDt~iFX}izw6Hl70W7}5z78Q3}xv^H(=Kz|`O%)EscVBP!JLtos zh1@4lO&@H*T#;iNOEeh91VPQAUT%eO(gUi&UF*VS+y*{}`3F1Emo0>O5NL??OYz@E z>ThT83KkRx4LyIrkq5v?7#M!nfs^t6Cn5mNp;E;U;SgGQ9c@I|?P4~T_ldPNS)~%QJT}H3& z!;Ncocpc;@qP40gPz+Q$36q_=@9#P+CMYozxIl^1DgoNyfGWnSc2&F*`Ve3$bvrI} zjtUH15BQjWD@=SI;rJ*s`3w>My{ODm=<6Qf+fJ}K=bBYRTal;|H)EhQ+Q9PyK1tMj z<7Q4b@{qIa2qAwZ=7uI`t9`zM0(@Ow5*K!KQh$?0^)6`12e!$@OF!9)BvAxDlgiMl z5VMse_+@so{Q4WmX2SjFd2cSfnLDi-k6ldmP6&{Zi(_PNxX@MVTHaVm7Uol54F&;+ zPCLDOb6Hevur{V;>d2=Dv?pGj+O z=h`t8p?bmO_;mrw`v=#441r(c_q4ZzP?y0OK9f#$@GUXXuqXHY@Wg9;J!CWrTssHo z^u4DQ(cfnnZaWcB`FQe-(X-e^1h&}6hl7vhfHlF&|}tltGBfyEs_Z7E_$ z9Xjd8d3ULbA;hyXppVy7Dgf+&wD{pqehk2iR{@U1T3@g*WucH;s`NX84)qj#MU8s3 zv-JQEF_O8-P+a$t&F_}+&w@X-sbqlyXgLn%iFTO7FWY^oth~h{gToFeu5tSA(;>_uNvNm4HEx|FFiITcCTCDaQkMNe6BW1_PhI0=>fE_Bl2p7x|rBI!D*{yb0GFUIGpEO@9!SFgqo zTxo-s8N`2<+Fo;zZvF+lN+^)ubDuWr{B9ur?sW(*#xG)R1BaT1#&Ye)x0tJ(7(X6c zwab7@R-~B`n;Ob6_O6L#2?;3SieH}X`{#nB%7_B+>3!6?1viYE4J zB_5;$R@Iq$0=?gIEl*@F=uz6owp68iPdciZ554ZBOW{U+@=sDR6NE7_Nx6p|2j0Z^ z1#|Jwa43twT!R^oD{#}GxK}!MqUht^YJp3GS z`DF4{FjT~Ia|6npB!U3vH1haQ4!rFz$t_Y{0%*%vZrvxxyE8&mWjGf7xvvilrDEV_ z(&oS_lmE@H-r_@{QVpkxk!K9-$GOvBb1joWHN|+tD0S|iK$euac?m=_IeMqm8eLVr~V1F>dxl>zE zpi#G6xo=qzeBb}X@Ww=UT9ZSl!3Cr4-K06}8HR#h&7ekzQN3>ZuzLNF7-YO&(A;Up zxU53N7N+lv=braB)pAM0`)!!}?+Wq!@buqdQM&anP?CG?-4gsb5Z&~@KwF&+z5oFG zZ4uCy-I48pOVjcDq=s#V&Il)fPTr7M^T-}@_TuvxQ?t5 zlUmyjueIaZzMk64E_JNGuYC8GS%Rw$M#MJ6250}|=HrFv4t{}MtqO!VO@G`iNS5Bp z1?+3w!>=D^Qtmj6E%imB8r{L*9y2d5Z{lW`_lXAf>oImxB1~;xLdliBd&m`#d@$|$ zrpy-L3g}{x_ecs9C~=j$NeD*_o8c)E>hB=LBGb(YvEbq2u`Cd4*E-M0zcDpaPwdb^( zf4K<2qwj1`&3?6wg*D)!rdpy|mZ&dvDPPYKZ94f(fiY4h;~=|+tpz}vDe!?>h-C6G zi~V{-E!J<)u=PEFh~i-pw+lHm^w-Cmh<3@38G>}X`V|kPnTd{efhG1)>Mxf2Vcqjg z|9vERO2U_z7`B2st#$Oz&O!Ipx4_1B`&v-2T8)@Ds8EWpGWJWbl3s08HL*q6_v*!;WoFvOk@=w8azx^WE z>#=G<m14n$3J6s)BFq{<4ISCa`c!l*z)DV`>Mf*mXC!1nSGUk8S@_rhx+5dVT9 z&=E7Thbdbfrvl$Y6l3T*Y7&g7L!WSJ=4aKp@+XPe5#U~YR`{ncdUH*T2RkK(?S`>m zuR|BUyjj^c5u=rL(oSQqr4cP5(A##E&bxf>SS5K`U1Bv0hN#p7a6-n9Fs%b91`luD zx_;hUA42?<%mSU!#E;8#58ja^5NEYGQCp2ASyuc(%iicd76-$3UG-Wns^}LJ_S$== zm=GBy5BT~2i>~jE=kjgew?}re_X^p2uL#kg>=f}_aC3}dP(p5y07ax&+|Bs<2a)l{#9CCis6WY^W36tIgh@41vlHW zO`P;^lr0a)es%FiO0N7s-*wk`Co1dut>B_g9){B>URp}z|*>)!zLq)&~YK_tSqy2iL{V{9$nV)Mh}O{2;?jt|K{83;MK zibU5c+jjbo>(70@a^iRuh18Npy_S@FAkIGLD&6J^d#JYUb_YffF~icWvh-`~zt6yc zD*r)C)LsjfiB8XFrCh0bT*z5<4oc*z;@?DSWVRB<`5B3*I)xa>A8v31_hgB420R_2 zU`H5v_09b@m~!h$k-9B*HTc-T7A|}pwbO{PK=ZqA)yZD9>1r`7oKcy0zUf)GPJ;@v zP28tCF@(e<&ugFuS1a36ml9yQ|n)G66TiTr|5 z&J%QhQ^3G|k^vPd@7?FuMjWqeyr|(mdlaAXif5{YpZk{i5>ev&t$cP4lYah46~@yj z-qUL@c_(J_P>nS@kkAau9&9b>&zYr0Y$|O%oA)iJ!5Z!NxzO1on?_ckmKILR60wD@ zj`aQ1Auj&TXduLxk0PC)^9PG1O(_0^XC)fMiD-nI83o%meuKM55{|a-R+mE}+Vved z0MltYzl;gnV}E!9K+EVHP5O_%oSd0juJ;HjNrt3Bbk-q-WUfC`jl{+fa~m7yQQ+A! zJHg>S{}G|t=WLP@MIVT|TrcoRiZ9j-kP1s{5$AF|Ozj=X241WI;41UZ$t8TbcOQ1E zfo^f?FBAY08R?Gmi+`bm{j_fj{9XQX`g3jA!&$Rc$(z5Xl4IUY@?EK8k;tVyMdl+x5%-NPJ}iI}e)tv8W~gy5UMMr*?zi`;-Wb8DDxUZn48oEoFMN>5m= zfp{lnm!iq*1l+a@2S{#d2!27M7wMBBFpmwxAvZp9MBk)YxC~f}1(-lt$^RxlWDhuQ zCge%6_jiZrh?AYo7lM7IuG;gmtap;9OG;N}c@C{N)Wi25nD@jBVG~>} zP{of6K$D(VYna3v#RUGmx7va40ib(X*_gG#l5tYIm|NhEko?PvHT@#?JkspZbuycG zM~k>$^JGPbu^lgyTY&yy=582&iLLD=Le>`QHBB1HCS#9Ws47QgM{eSAiTVT$VG0s& zDN&o&LEwJ$_@k);Gkp|pg=@HD%M+UG*>60xZp+Z zx7w8Tlrrwu7R3?xcKZolX54ZRDkc}RreA3B&io~M&D9zw^4}LZCdrLPaHcu712+cS ziQ2^7bJR&#WDYw^x)pN!hu10#Q%fFwyNE;wqX)TH2s(#G7{~ts8vW6Dllc9e6(=vf zxn`i?UxjyBW;bW*W=U@}uc0iu7|D8s`8{GQ%=ActYi*^1!&ri`2?<K4sNICIhjI88`Wfv^xUkR9XH+PtRexbL(-?8O=@XPglZxWkNM8f&1kyc192SW2Ztw zwp`*wv^>*PT+jp<6X!7)pz=bnJU>cRdAJ@&CBAb z`qFkeQaSNq-|fK`nNX+1`bMTRypqfYmQNquFFDzd|IkVJ7!(4V;G8uXJ-aKBhFeimmx!DvNx~H(tq^G$e`B&A@q=BZhNIiM%I*h(TJ%>vbU2 zYXC^GRsESbL_gzy06_d3%vES+ z8>&V!7W#Luif7Ie^>Y~#_Em=Tb635u6AVYIAe(xE>x4Fmmo7uFpser{Y)KGg|&C;_%}M4a)aA?bb)(jtD;L2K-0_ z1<_KcM57@CYOB?qsmGU`TZ4l)6a(V#4s0swZi4G&9+jz&_jqtTk4{anWn&oC&@-2% z4=s~ZS&XmO=;oGwD<%HvfMF41CAWpsWLjxvKFTtcTQHMzYgKKa@kbbh=u`~-yoMz{ zmJvO8_gta#`{{P#7B#xnH3{}$PHJ@Lhe}@NG69CM*wiNx3Gw$uv!30U>zSK+Oyh>} zMa|P1U~sV-G)xokgRG<=*&tL$fjggCcTbL#3?q)}N9@~Wl8kJw?f>(2y+Wb8ku_^F zOQ)(0E<+5)Ndd?l5vp)Omans7fjd1%Vi9^{p+8&^>Zw6#m$7L(tspKR5I^gj$<{oXTaDu>jyJwG!H?~Ok>NVbgQMLUW_liy^`UE?C_v!=It;zk!D zj6JTJrPmB5b5F*lqd12eC>q zFC-UHwV{|*?%{3w1qwX9ZzVp9PUP30Q2-9~nta}~F3wNHzDOUqBlv80)i%+f^Ve8S zL}nUyjZ`IKtI7=Me;Om{aM@PN&N~8wSSaZcCL9iM;NTG+yQuFDxCP?S`R6M6mtYOt z;E)Cd)@PryBa@Z#Zt(dt^|=E9bQ5#nfyCO;+pDp^E4cdtQ;LlHy6=2Rk(vYQNbJT; z+gKYeSRW3oH&h`$fT z3o$OpsGOg_av)js&DfTiItF_THIVHu8-Q|2=^ZJ8R9$ugD@C{PAFcbbTVc9h9q$QyOIwK6q01b-{PSH zRt=_4$XE&78Qo{ebYnjozBq5v*+B8Y{adNIT7?O91PZS+5P7_!K6!h!-_Nj?L3(W~~oF zZ>3G-y-g=?WT_mfL=|pA4%uZ-kVL`8#bGS@i%r3Erk=M2Z=VgIvfRe@Ml67IA773a z5P@!yDRf456+f7pGG0FfbLJb@op7wefsDp6E)0rjG?gG0BWKz5225d8dzACh&yapk z%FWE1l<(W^oByQmJ;qKdxN&(hLAl>!z%z427H3g$Qk&8A_2T0W-rL-nT1KCg3}w1=Z~4A zVzB>~b~czFun&MDo1HZIRV;H3FG5b*xXlx^u7mSJGf>vye5nAoN#5v%Ae7=1C=`q& zi{kLP1GB$H4M$-c;2cIY3YS`sd$vkDe4&|(1L_LG`{;3@DQo@_|ANO5-7}gOXE7eE zP;YG3pPk&C!<0+~^HuE%SNh_P?hoAWWhGMqwv7Q-(|nholQv@?9#y^|o&MvnZ6@?z zFKL35IK~1_72-KgF?-Twa?0v;xZOX`)~wI0*Y~g+ZqnR|WEc1FFS{%@;ohdm_C@}1 zv)LcC2wAaOmVuZou&3J<*aa76ukYoLV#S$QP8)Iu{gO1`^bgD{5na3{k@V&391y0v z|LEAl{>@np(z=RVQV79y#Xk!|(WqzOKDkruz1+ewaKm<~Gp9}BNCrYpj9|h<#pB`h z!Fkp|6~@1}$bUQsfS&TqtJTZ=6z$Le&jG3OBlt~N{y>uDYBa->SL?e*eOP|K9*8O? z|LZ%LYQzBt7U^5cCENuL`d~*DzW|FLR)t<)UR_bsG5o#xTP6}rEPqrA2)g#S@eBaH z1d#Z; z;O`G&|F0i>i~9c2DaRAI#!nhSGJt6#55Ix^>;L-VidW+RTSJ`t3THdPZ;k`@!{Fav z3ieaycT!|rZxGWO#^s6R3GdRZm>zN@t(`f>Q96>A}(DSUY6 z|B0(Bf=kj-eR6TAEfIAejQaoiIKE=mhn_u@Wft)~fDRT}kCZ4SMcjPgSrxqMfABM3S*IGT4q~+^K6+o*y-?=Dxied z{Bu>{VS>K@S^oE!moM4D0XuFAc&;%}CxN2<75wMB`KHy{ts4lf<*EJ9ibSbA$bJ6( znP3MjZ$hSj6La>Q{Ax0E;*h@)qX@s&X~szC@bXSQkX<3U~ZaEPKB6Q1@mdP`X^a^87+HFb#}$ zf*%{>HXEhqd6i=X44IOiHJwD3J^Q;N&S3b7j}L7m7CI)Twe2^;KN^(<>Mnhbl;6eu z+b`|WEP#xO{J%c25*@cYkUJS+DE;>9WR!b~YF7r7^)WhAA?t%cgJ>zOo2;0g>EV>7 zu;1IVcS8|Pt+pn-B3-77q6;4Nm8gm&Y{QFaTHB~(h z3^K+7V%BQ6A`0$Q@{c=TW+kdMpTYcbj^ff=g3j3XSx`;91iR$MiToF|DG zfcxnhvmx;Bc|7)3E6Pzc3f{HIW`D`6jrKntgaP!hd$v0f)>y2NwI=_39T=sKxi$=y zCt_m%mY_Md9Y?4U_GkwnL%ek4e>9DuV2c!@`{uvBj*Au-4g1cplD;afZy;8m*OEl9 z9^JSMtFq+-$(kcv04TiAGG@)uA!3T2gl*Scd3$PihVJB(FpeK6g~)(rD;H8y1B(B# zvq3O;qYjzL;L%VD291}}R=waWVyq1TbLth`GuZ^y$x64k79~#*7yKmx37^yBW>!zQ zcr>V$)5qafxbci28?;WU;{+}X_ zzngifdzc>tHXMT#AfqS@38as4)~1`KQ$V^t-Ya<YJc6N5Uc7|Xh@RonDr~rX8 z)ChyyFdVlS2*h1bb0KpCmhOvdk?;Uu39I{GN0K}?=NFunTSdlF9?Toycoz?D2s`pu zJEm!87?`|drWlw^8mR>C8H>qmLp#eb>Fi|9=T?>d{Xvr!*hB;Rr*6IB+gs=xNze_- zCMd#e4!!4nV38>ARV_WwF0AAf>fqq8*?>uclEm$^(@c~1(m9i8Q4VqD44P3xTR zNzMXC|D{hyU}vN6CC!{_S{raD5lLwWZ4aRf$A*Lhu=>69CeTS)|6(+nnRtcOpazvO z?%oflNKdeTr}5up-yErSdG{PwIu+AWxBxPxrRw3=GJ%M*owg=3dl=cVYC{dMUSinP zh<7kgemM1Bg;S4ANf6xY2-Gq|4e=6+Ijb)A^9Y0gC6_j>a%H$UO-gOK&*y?1{+ic*r~LasPs^|8(3PES6@aKE1{=XE+!dL@ zkmq`2Ny>{8@`|}A3Z}^be(lm=M)L***m-_{Q=6CC`=`K(EybO_iV}gVj&K1@(d0_i z&807|)v@c*Lj-<~<^or5DH*SDi`mwynYM|-n$3zfqoWCNSU-KT{s!H9()oxM4>{SO zx%WS?-+=zt2)}`8-Fs9=hIC{T(K!+hzo(X2s8D`;M(r{|=mY=#T+#omKMWquA?MHl zbQHC*K70w5FGUB*K <2v_NtmghF)owu226Me%pM0$XBVJ_LOE*jBK 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

?EiQeqGMpB~>gBg{ zY26n;&eCv8O(SCrS6uX<6Ij!4rTu_1vbpi|)BUfI`(doTtr>D*>&?;cJ&G_@P~OGj z(OG$C>3J~F(4`*EWWsAA=5ZJo@Bz8F;MtA1buSl!8j4uLvQ9ZL+Iq5+aSQJ(yI>tC zc7~xbRZx>3V_D2qn}W{5gW0!{_s!m$mmLZk?4K{Y)t{tRAcR zzgRzbgZ#+BbkK3>e77&#hfUo8{>`Q_n#MIzUJE2qKydJww}I|cC+q5)Pyt?xQIJfx zTfOdK-A5}ABqd6gRcl`y z>T-fF`zYl2-dpk&Z5qmwP{x3XqU*_MWaitc*IXdwdY>@t+~fDuSDiQH7!aHetM`C5Qq zIk*sbV*orL-tVh7nMILS=`XovR2J@s3^Id!t>aYH<87_zDkUOpo zU(KmL*zE_o)A=TG#Sz*43RpTn$Y^&pX6;HP8C9Ft9#lpx;BLjS<^IewNvxZa9VsTj zeacT(@2M~a*KIBmIE;tp51Vss@<%Y7k<;q*l^M`2j9X)E=Z|F?0*DVGVGD?mJ$GJy zYSJ&BuxSp2uJL28>uWyUw@vLyxAI+mY81q^lU;K+r@OU@vK&{EHYOZ2X8LelhhMKhQuq7l zCrEK7%%u~ZPS4Tt@^N#mE|yEzu(!fg^>aEE%N$7Nnc0GIE^zICCay` zrXQ^*+{!(k+;hNvhqqA$;PHxoKnJ&4s&@sT0BynRu$Ih{#u>MZuWri))-k+LM2`bi zFz1XoQx{hffKU}pW#&f)LCz@@fqt{|+bpyIE?VY%Hv$KP5cV;xA%*W5z?UX;RNg>R z>9w4>RixV>SQoJLS(;Rxo#A6LF-hIGDrw)-_S72v)@Iap9Hy@5jIWCQj9AD5Itw}( zGk#{sVnp_h&kenS((<`MN^uoY$r)5uEU0zyp2j->7qKvZ5?)n&)KtZ&gJv5by{wNB9qkd<#g26%MN{M z2DdX(ip>;_3C?|;ZGTKGmK4<)H^>oOr@`t4Dxu>gr*`wG8t&zh?;*YVv9BCm-&Ou` z+d~yBoe{xPHreJ+l*0>`UrcHqzHlK35K~+iPiwsOpya_$Na4hD5M^KgQ|v5dxD#I) zTWpcDylH77^uj6Y@x#J<*rUw?0IZ31m*_ynq62QYy10&Vq*FyuRK`PG#7yh~l; zLs3zjVDU_n7vckbG#v7 zAL=(g|Cbi%bMR;oin^LT|Hv8%fId#+c$sZ32ml7gc=Y+A*t;%synTX z>#kK#n{Ta`>q=4hTkWd4V+sEA`$I7mT`|DNtRDR_Yc@9yqw|VSJgg~GLdP@3X-qsU zIInM9!;%CsY^;+!t)kAejfG`=Rqt1lXSXNrc3Z?MRqJXqy>~^DHA!iKc+nNwbux_jS$N#e$=N?ebscO^42^0 zVQeO@%`@+l@`~CK>&rdv92-7c#W@tSS=XCV`52wm^-o75P6-c7{!tugy<$hS zH(@`FOV+I{ThsR`hsqhf_|MC1-B7o1jo$&Nk@u6g13@57tZb@ zaNk(5={qO0FFtrLo1D&5HnCk(LQ~^?+Fu%7{TT@o@v4%PYtSvqT!y-wdcx$WVXM)*PkozSb67fdoBae%N=~a*-DFgK6`_a4kh>7_T6O2QyB2}AYSEE9bSh5t zNpshFFbtL`tR)@=g2az;6c}hY{DY}N7`rCc_aUxze)lB{OrlYf9Lid$?dz_ir!%;) z9epe%4DjC`uWzrH?^J-uu%|hZ+XUaW!>uPFn^d2`M(&woH6-Duw8wxyb_WYi<+KZ# z&XEWkacS$(?8}qbZxU9Ou0`1|my0O*N_rf|;a(0HOTR-wVx#5U9rAk}b$I6CWamfQ zxI!oFHSy`aT@bgT#{9Hu6ihw4IOh#y-TOz$6Lyip-Zi^*JuH0w215lOGI$tChAIH;Xznp&}0{WOMWF_V)-!PIYF+mYvj{ z4H}-@4rbFWX-p;Ff@sXF8EKqFM`wloF@>;WUweCd-`gZCybQRm&B!KVG$=5f$=KC& zdC1**)h!TlhhN@9rN5MIf|1W8at=l4|LOEZXZ#@236+wwqV4ShdZ(Ef^!p^WX-p( zgv|IVq-9n8fa=m4tLZYwuV-D%_ob$9(+`cYUSny?D!+;KBpl>kxZh0vhL47Lkm##? zN)8V-!vdWk4&;wQe~3!{#wo&2%*{x$KXnDX_;Xq5nmUT@^&@yjBVJUePD!2?w_%Ui8gLxehAgaMLQwx@n`XmQ@55K5LZSt$vRqsjh<=)#t>Z*5wLZnVrNeQOnlnPUbfsBplHxbagO$@Y zOn9su;MIK%kvmb6!}fDv0uvg0lcOfT>Q@$w=c-4T?0jV(m*Oj%u3=8At?@P(cr3t$ zoiyQ6tR3krvDL&Dnq17*)yzu}EbtFaKSav3_A-zwf7Tr9B*S94%69ySZb=jTPxr6v z4TM2EukVK&?&X2oA@rOOYk%c|f?8@d%F2ZWnc=uXN&or~@Xobg$2ICJ0N%CyMEHsi z4yNY>mxM^8<$Niwqvh570sHb=nFq*I)nlbVx`O*+`AxHsV>)WB@V9=tzhYjM#~TD$a>O+{3H6H$Vn-?f ze~!O&#E(Tf;%TT>EwtOX{xyOgajx4;bST!faTJ`pEw6K2aO{uTuXTEG^3|(2NqpJ7 zQ0E1mg{L-MnAdhlWnz)-CloB3o`Xs07MhVF&ylo=s!P=rO<4+se(nd2IxLg96~|0- zv_ls-q(YkYgavlkGz=K$Z@A61V1eb!n%DAnD7L(!=s@l~A5-zyzvHpnj}m9j#Kf@7CsFflp`=Blc^Wxw%k~5$oXTn!^8rrhz=kk-&m?RTj(-KrICe|20DIK+j)S`2nq$`g{rfQ^=OE)Z5OdSoeG= z3eLbT3^y=k?8xg0L+SKrf4I z5oK2&`!VN5C;}ILH2}!uzpxPYn|rjut0vkX@%RkTZoc|fADKP12pN! za6l1WFnu+ny>sy%_jx|UZw74;Ew5Co;cDWSHdr%-8p`>8kEkuwqRu8M$$Si};W}^p z%8LRaAY~sZ89hwD^m)3e@z3%9OM*m#uvSlP@AM}^yx2{7$jC|xXV&!7T6gE(P;t~KE#=#PHCHumu z#k1*&WvsDsHE~tM$f(!Mc}S-yMKLw5cC{PuPzMCFHl=3Y!zr-wPV^;rKd)%U+O6mL z8dKK_na@&Q&_&6Sx^rn|wA|*xckZzwx~!vP(IE4f=&S{FNc-pWEdPmA?5}dG#0C*t z)YLZYK0V4ywn_6il-n2+U*1km!K9)p>fJal^dv)1ODmAl*oWBoq=gcV$jf(Ao|)B@ zI>Gi6(ZG@aHthJT!ytd3n1AZUZ>xAw*K8idzK{GuKWKYR=tTKJ^66>SceG>t)(=53 zP~vBNso1Q2=wC%_;feZ+>s7#javk>FX3*Kmy9tFAeshdPnHo>Q%AOwtoj&%5^yR8Y zO_Vq`sa9XnFN9RzMD%0xC`;RGPKnNwc|6mu2FZ9qVUU&##m1jjivSi>)244eAp$r1 zQmeV|D%V6Q07yKS|9tLS^&!fK%y@^j{ax|a&ePm>$8_7L#LCyand`|CKir6n_ z2L|#=azyDfH8tW(fKp^P!_3d*%dT`2V?fL)Rg(TwNeMT?#+VxQnC8$!J8rJ zxIq)_3g1;FzcFYz-;-*dgtMQ_Ig!_#0sf>u@^Dv8qDI4JM@cNLHQZ^lB#)yk=~yAw z#w+V6j2Rc)##3J`xSLw1n+&l_cOMq}PabG9qJ8~zc=vnT@xNt{G{10}L79Mk2u(`L zo~=SbV9$InIX#S;%bV0@vn5=CQ|coNci|Ba)9?kj!T%%cEd!$LzV+e9Kt;en>Fyd@ zKtMoBg#jsvp<{;bZj==1PC-&ShLRQ#7#O;{Lt47w-T3^@|D5xl`;%WB_Py`DS6u75 z*4jFS7<#*cR#72=J0hLRPdETtkiU9bR_487+USm-`dFnz!DE{Z2Jhsdem1*NB&+Oq z7K+Sl^d4q;PCEX5?vAHkt5lOyWBRwav$7Y}Anq@0(5TPpDXnp|$vcwBwaaf1@%YxT z|Jny)A>)3%MpfaF<1Lc2W7b=jK6Br6b|?9RwOqZ`9>@(MJcf=r{GF8Pp3OQ%{4aa8 z2U4|>u9E^LFoc}&X_jlKN`ac*4;7z#I9!^OZzZ>O;rwn#kZhR*Z!0j|BmHp?!F=1_ zI{6~S_0Rm`hA-Ont`$;8M@NK0t}n#I#app#q1s;nX5?{r7uB3uEqE1HBL8Xn0Y;FP zGLG_};#B67(`&{teBgf77u=?I4+kjGe0Uc}k{B#2EMsclf4o%EcfSQ|$ewHWQYz7` z5@FVCs(yt53mSTSGOPNh+;v9M4zEDyJj{p784@xEy& z;o(S+;@p7~hMb3Xld%)VIoAedknnE3Bn1d_J=$Fs2uwvx&nq0v7ORv+T|yrrbIdsP z3%q$8&g(~*Kn{B@zZ0>xPS{Y`&{8iT@hPC@5t=?Hb;mQ`)9|#&`zuHWyWyCy8kzs* z1iJ!_`4}xUL&)K9U77n1uyib(oc-2?H)=8`+F z;eZE2iY_b-KOQt`hzaTstH9gha(VwFFmsYxlVa;CitJ4}QenhLXc06DPl zRg-0Z$-)Q)W7q*iBp@nkn(e(G@o=Qx+!fzTVOskdq{_FZMu4>gL&4XJ^WTrAKZlU# z%*D;}e8OAlJWa0&6}hbN{`%>mw$f;ED{$pI4C^BjgLdmv?E9ml_(7M{LwUuysRcw2 zH-~2%4<(gEQr#3UkHdy}DAJ1>&x(#LYkVPEH=S|+KIV$R8UNNfIv5~1&T{ofmX+a* zt^;mM-28+vGiVHzc9PynpxQ&$;>!6LYrbtzP9y{nJ+M%=`zx}$`eyvItO{m2{{Oii zVnQ#!&7tTq2Cs_d7=ZgWI21n`gFQT2$~_NbI>~wcY2R+W!Ha1Oujne((xy&6>-MbY zdcX-gi*u)#2R>uYcp;@{q_-FGrk9Do_a=ex%rPXZZU3s}3-y(nOP>e%rDTYNC z{aS{S_Vvdnx9?(q`Ug|!z!#UYT>ds@J+b+n%2JyhGN;2Cy2(g$Xe^xua+$sZS)g5D zi3df>M7lM)UC-9NO+l0kM5-W`r-$7xF32YZ5k`haPDZ_gtE2#3Y!ShRxw2rx)cos= z+u)}=LTygF1<#gJ8%0FfTAX&---i>-@HS993t1zyLhNJi%_G`g7@WP@v1|w$lnY-D zOQqz~XfTj{93~)IDfyLB&x^0MOLIb|bz1d_+isF}*XvV{@AJ=i!W|clMCGS2-;b|UF0vEZN28aDr^Yq=W4#HeVMjcd*a1WT&>kY2|uM+ zjOSS#BQ92G*gcCO9Q_c|wvid?lh*CbiViW!0&L6-7lO&_J>@y|Ic-Dm4vr`(9$aOjt!vjRPzMP(Y!-yW0%8W zRm5Uj$iUFhQaP3;I5lBZLHi)8{2$-Vj|x4fi&}91|F05ZErx$Xv%Yof)?T~Fl|s*} zeVO6(Wd@Pcz`ETwlE}owJa7DI=)=SR6EBg1=GoL^VZ_dO2`rRP(&(fbetfVBi z9?pdyS2>=Nv17w>JLyJgM)nu5* z18411z#-IOVrGu?^}P$LvCj=A=8;Zu-;+8N@*05|nG`z}q)DrfF@ke^dvp`S!o zGHyA=wx99JE?x6rH+XG5F`2dA{PsxUwD;Dfuxp-*NW^vSFooCpxR)wnyLH7b-LUQE z643=XPu!bMc6Mc(vyD2_A8gLIs`88K97b;~oyoUz>i>FBy-`#W)6?9}uOgRga(T$_1qCvK*Z=i`df>5X@fIWm1#TMfZ!Uv2 z>{B2{VLG1mYSi>RU7pxTNRf%>m>*MzsogwNRp6k0^k{VuGc?QwOv&r;o6Krr$IDhH zr%_an%Ah?|xtQBiaH9u|POc z(Aak-Cb^EMX}(SU-4?Yw4d0*Mjx?o(!2^H3yH$JQSpVmf)4HacQ;rNXzebmAg zA+iKKFSXmkD2nSH*Mh)Oug50-u1;;L7A)^X$d9e5FXNZPsMhz(ZHC@Yu3=_H)o)aa zwF`TkrujuBUdUs^uz!^NjN3p(&{Rz7J=PMa-|rDr)YL4{N)^&9$;`^i6{J)k%1ioQ z><>lR&i(wPy~9ZK6STNR^($O8p^{q&>L&9zuE8S$q` zY+%&Dy~hF%boOD*!$B>PgO&cb0nXOu_ zGYUNxP^U5${poL~?G*at>EUR}BUs3JX9{QMoX-T%p0?p*4K zT28j>DP{HfLnkcUFj%LOuTqHYMu%tZbcJJl`e^CawK~cw7*B`{X8~RVJOjsjgQ-_T zj?;4wrp)&N^LS%y;NQ(jQSi4zDQao40u9ut=T1u?Lkc6qSNq6h#|e|XnfqEYLV&Wq zbdO_&eBJcMI31qNI}FvgS&t*)as{5;W0iOj?{9(fUP%jkwfA|enqx&84$nLbAMUmS zjJHhn(s(qrE+ZpjUk^GQp$jY#u&MuVo6rlbK^CJp_0@psnw6csG8XxtH7WUeV#8)haZ3J!LF{Bnb(YP}aa{D7CdroF>b zT&FmEYrO}LI{k_;mI{lF8jOQ8a!Z*}&-nc<(&N|XrrY#WX$&V#^$r^&2GGA3 zuf$oKD3l88=yBsbd)=RAHn0|<;4@M)p*t>*G)Hf=ew%wWcU;Q@KY#8^;ZAwDV?!EO zQzO6xfkaPDX?ApU*pQ5A57q0Rmr|sVVn>}5IZ|OYXciW#)nL6P1t47dy|!y$E|h=k z-D5l<`Sis>XLI~MjamRd&PH=4M6eCN{VkKOl&ko})i=LV}Z zPgu8`tW){PGwF{*Vm_)OU}Iy`9&7mThIVn0isKKR{=QfHR#ow4b{KrV+3)K*5z6ib zA0HG50c#@Kt`4u~AA2zZvs84Hy!#H-mdHTXJwBpjBSQ{7F!0zRo3emwk zdU{kurR7SlX2kHPZBR!P$8H0s z==HsH-?IKtWq7p`2F{N8V8I`)zo)2qVGZ%pA98Yep09J6hjzLKJ5Nq_DWM+1@BQcbYp8k#C>}yIX$^2(ioPiHr_NzILu+)3zcH?wBVOnGHXf^Rz zP<|@5Z6h+u@iK6M_#kXn=@Q%YJmoN9;jcGFjEbwmv-lp1T$CK0lKJhoUECH^wKG=y zf~7EBSM*4yXe^b)s;>VC!|&6j{eGmG{=e6wV(#q-fb#?=okYCx-5b|BzdFr~uLc*Qm?#vW^wJLcjKp(^dzvasec(Zx8@dj_2fUfxhEBb&tZy#Dja&j$WMCR2q$CH+$r zQ{CS*{57Bb`@we}76n?f!nKt&UDvYm@=H>_9J;Q6bqX9Y-dKFBpw+l}e5CHIe3icE zj>hFtRpXY^@$Ql~C;i7Uh zK!;VK#UB4&aO;K3(YR6V5LLL*M6FZtt34ErR*w&wy-`znW}}Bp&Rc+@{GO=L6Ls%b z*BASdv9Z}R6wcSRSVJDVI!~VHiIj*u=;Y`L{;yXn&})#J`~5ppZvPas6T zG%OLr_kCtu?>$2C4h^=+-eDA-WYxd~sB_^!u9s(HuZdUr*lC@5{_O@iwxxf`@4EdS zC9O#+^Pw%iYI^@0KhjdI`--m|&QnYU6g(6;JJrDJ>9ns{7wFdU{PoDO^D6!tC`FKU za2xfMYw^WfzZKcutST0#?Db92D;N#SzKN@l?x(g};M4W7lCPIOk(q0wrJ$g|E1B~s zPMTHLbK4!S0J^Eu{xHwXqxJ0mQwmOx&ic+$#N79{p+YW@a* z_8D;_h^aKYe{wJ=r;PFR?}xz(GVlZCD}P7}+WIl94?%88_(rRb-Rl&}Ba9UqbYr-- zLPJ874a#-BN^~|x3I}_jFQN&NKXg%h+qFB=N=i|V!r*wfW2>ONgJgpPeCR))=(p)= zth_!kG@fTGnZB_|rp&c^E%zK0wgL$TQ-W{88?-gEvFsUeZ<9qt|HM!)FE6*R=>9e5 zdN$=C^7|Q%a0VG2C)?BYlD>NUb?-kZqum?pe_VkCTE$N?XR+Cn6HcYdu_=ac_WP4% z6vs)FWkb_IYB_B0s?fiAJ+2Gq?IbG8pr#f+Mj+)IDAu-K(ZNo z=l-J{EYoSvNHEh47+)^Zhr+AC&3|ub?Aq|VF@l%x{&g{WYdT;tpQzA(n!{VU#ql>E z9|ciiReJ+l`i(-&?(#%;yxy(Kv7reB_(nAjYjbG%Dxn9R_WP401>t@uJdh3o$A7@( zab`cG=6i$3FZ$uK2N^@PU&BF%-z^2$4_tCvOY`#yK#d<0*fA92VnrU42J) zcTAFHO-E&s$zZlaLI4%|CoMgF-r+Gm@^>uV-iN=Z>Q$k$i%Z9_s*c6EcH?5GAT1l) z_W%1cP0au2m3{*Dl6mhZYar2oEvRD^3xVlt^nQLyL(9WcfqwNjbiqN%sZ}LrGrIA9tba9&0ySuv+E)LdDxl9IVC-;n!ZTuzPzBOA# zptv{yE>!c^$t@Hi(6Ow*q=k(&GQ_xWCf&V%-z<)Q1{gdMc+(j%F)5KpM8K$x>Kx&+N24pDHdtKbU zV+~abrJRV)=ciuRJJ-2u|Kp|Homjb^Q(-Y5rvewv);s$(g66F>Ahi@bD7CY|o2+^j zGTw}@l*NUI>n0JbDyyp}f^0NxvZf@>woW`2Bqw6SNr!j$f5(zx_h7@i&M@mn`?lD7 zoPvu#FNPF-+J$k)r?NW>5rJ%kxRMHsmX6M0ofrF$-nUw}f3Dy9UHd#19y9Tr3V|sq z4wz`Om=StE?%rjQ7-?qGaO+ohJO(69m{;wJ54e*BnW&f+o7Tgc&EUipbh&$ zPIcrr;ol(FQ$9rePNCROTMi{+JG5`vmFJ(K!U~PJw41b3sV9EP4d=Xr4~+gW*&mqE zSGpTI^sw6|Ac#kN{P>SXU%Ey^@gG+%VAEa{h~vM`^V}$`a&)mQ%cW^x{8M!Z{dE9t zXf8fy&0!)JH}`U0ei4$@hkXp>ml`P^N3g>zgP!(q$zA~EW@wBMSw}>rrWUJnPrL7T z+pZ)SnO3zce+9YNI+gXa&mL^fUd<6OePs+t6s}aGVcwTQ36p_w&m;6dyiygWh({l znepl8_^5*_l&eL-1`kNTXSX+WZ!Y0j07PCzB|A|t(L?I!o@hrf5jW{s z1d|M1^ z`KnuMQzUZGC%)c8e3v!FnRBb-U+bVK`qSHb8GM+kJk(DfyaubT9g}i6$aDHVQ~qv% zK5C#TfeNeb)=i6pt!nFiO8^QvYO~zMA1U2-7 z%*PC+-)ON-jMQ}*`o3^7zXBYvh}Qd8yAqS77#9>_8BWB>&wvZOSUnAs^0eUa5VohT&CTi-v@222c)LXkz3eX{> z^5^YURG8-h4PK3=brS{~)?~oeFRi;Pm8q`lxqDzlT>h<&{}~o&X2sva5)SK|t*r1{ z1#4m@A|jgT<)o&j77zwz%Gwa+{qR!5vRYE;@j5nu;VSmmzF`DcXqrvN^WnkPoiHDedXd4k9UOw-h%JfU{ksXzXp16VHa9b5=?Pom_66+HCQ!({HV zu6}h&aX(x8zP^2D+B53kbYkHl#$qw0uIMqoahjR-Gs>T{><|3it?Zly@&?@*oyIM81W6?hU+v zfbUq_WjV$c#HjhJVvm^#g>Ug)q+emOs>_E}0_O_A!u8`-oKT`0(|Q9%-e3*8P>zqI z9So@j4WxZjeALuphfIM%luin&s^8T`g+TioQ%bHW<&X5J9}oUJz-+JmhJi*R&`Tgy zuF}GqbK?Se*?F}jFhE70Kxk&<4;e{$+n0`kcTsa%;?Qb#?vz5@&^C-^I^t-kkR`_$!~>#-EB0Znq)V7w!uChS;8}X3klY3&Q`eQz@T{ zJsOTdfc0+qsm!;-8&Qk7k7G63kFoOEWKfWah=@q_pJuFK0$jEkP<*aHhyVMLY+pfj zb-%5@8LqqcS}m;IK2;UG+>-i#PFPW!LWG5|svN8E8Cn?LWG4)uqRMuAj{5JVdcdcJ z)doNeJtB!pE#3l>?7cztj!DY&T@R)c$BPIrOuj(kyBpR zm+RRC``5-&A7}Xb^nY$vb{&ivgyn8GJ8WzM!#7%@HaqP!YhgxpCr6@v@#6>=q1+0P z$0%J_&4l|PN+9H3r^|7}r$!z#X>(oSt+TU@XxG|7CDg(L`--ed{~7ET@Ft_XH7AL} z9yL?eEja6SVp;=;IIZlOZ*Nfnf6QCI;Mq<)jOMPMbz6C6^w10`&rRJZ+HcZLQ+~)z z{Frx4-{!amy(IqMC%0*ScOK`5+UKAkC7_ut&Tk=D18selLj||xbu52hb&Zay3bOwv zBNB&!D)myB*G0ybAcaVD|NXMz16H< zEIl@j@ucXdR^W=0Pz_pwuJsz|?NB!)+^tn5)wh|2Sz<>L=hET5#E0T&dJZwM$|b1V z7Ms)qoaoP)q#gO@5mt|5-gSh&+{Jkq72-E5ZI^`b2>6m|>}I}t$S8{B<$*p-g6yl4 zvh~JJlX$;Ci++=^>Wsb{Y~oJ&WNIA64H1$*fP|h zrt>(;N;l_B)2w+_eOh?Dfm8b8_Gsssg{1A+Hh-R7#z=9*qwHXOy?%N?(M-+al3D%w*= z*QhUBdqix)C>U?8^I%1yqDlGXUB)U4lra+N|GHUhk#6y)DF4vaH1e%_Vix1Lsu=HfjM(DT zStYOBQP!LB!uFG?2SHJ?g8NwoGZDR8DkdU|j3!NOW>$i+pKud?XxR=QOVyTkBalW0 znZBobvn{mrE>)YwrBj6-j5>~%Ut;A&tacS=i6-faXEYm!pYm&JK+Yro2y+T&cwEq$ zw~%+_bA(F8xwrx6>E^?5Z1R zV%yC)&3dRNCIF;%tq~Al|wDI-@qv5*=K}5 z;S!TlUU|+S`^Ld7$uOV4+WD*0jxIY#@)7LL+bmIHQ$_gjTLZ+5t%xi+jPz8sKa+8%cL36K+=uMfJ&1UA@?G+&t0o$Apd)y<^Kl5T1p5dA%?_42W z9X|fbT9#JuXs>W|Gm9D`FppaLOvkktWU^4ESG`@-s) za#v?R1fsRZuFaXCh@5nuZvG=s5MKSPF}&Y^0bTB=z3veB8J6E%+|p*$l~&)s(5PGI zezEpEVXH!6Z!1)}-%w;X@ia>&{wm~zIQ15lXamxH`vdF;{ToGFJNV9aA+kx$sH8Ej zAd&x#@R@b6%z4`wdGh`KBsvSLgcqQ(?4UYhZBz?l{D5x3Y117OCnWB`+cZ~sRjsz1 z_k;9q=-og~Zml*Cq|C^2tkhxYvW?}+_qU%%_lDbyN_NMeFVW${dVGZ{!Z64;sa0BA?rUvnly!zaUF36!VxxhDxD8S>?UdGc!gz= z`AP8ay@Uw|%cIDbuVjzZZhx-Kb{${lk)|(@iSD`(IIT3#&%FCSPOdF9Di>`tL$tx! z(@1$e+_phP&B+8)wBEefP;rYYAGV6%Q6l&f7ngcB*CH^&m(?xv+xQO^E3vC-FfLqT2$0HYY&;(IsaD;5Bn&gClhd!-jB570y91D$mxAzHq^d(?-!ObG_cx|M1-8v-&h(IYZNvzH z!}%tdFipMv_X@Y4FA(T^&3(E*#IGyzSUmQM=n)l`tB5ElDcBzZ?YsI7o_710yJvhV ziI5*;rH11gG{PIc(iJQbwioed8!brUlR=k9;aX%1~nM6gLb4@c3x;i5vsO zc6{yp@+J|8;TYKiegEE`k7pWT!Wte$hQO8wjK9vzKxS16cI;4l<0ni=*W;=I}1O zH{Z<7UQt^d)*|XttA1H_#N6Kc+BqwV!rkH4z_*kb#dO~MOv*Mv8-Z3u<^81XApcT( zlCMPToL1~hzZt2&UrHm}wo&mOUrvo?;}{>B<#4sQUILe7!@KUQKyp@zhL)2@PAq)I zeHssGl?~8>z)d2)bPF$RkkCg=KFn&^DtQsT6OoChgWmk(p(sB{z13z@^ppQdxf-bA z(M7c%JV$1B=7nXyJD6eSH})ug`A;FIG@o0bjv5lar0QfM)i3fxm@RIJ?%6M=OY(80 ztfclK`onW2S|(#Z$OCkACrwU#QRMVfDBMBU+Z%01iLhJV=*|9O zwXll=3*}Xo)@m~);xqLw7>j4{b0{28tASR2w~VYqX;rb>3itvhBM%McYu!5(#J zh_Wr0%saM<`lW1#u$&Uk6)@Kf;>COCdh&1=GdSv3UCUQ>gNkU&=)U2$tK#nHI#+|4 z3H^@A62*o@BBt6-;>>FHPo;G5geu3z&HS}jm+zoan@40cQEheX6mr^hpOTKG{C3BK zOs4%H2H)AjKNeVJk)@Ws4MU|}u;SJl7InckS<@z2GE2XY@LC)Ws6VH(i=&lRkn0xF^>vL!!)%hZJzMtCa+b98AKL^1r1&Fp&dRDn^&<)PD4tszw4PQLsdp4XKI=~n z=bV3;!M5B=pc8G^!~Y#!IVN7E|3IT8+0sK7hm+jvVpm(E84ib|mg97aR(34^xB&jq zVh5lx3EyP~Dw5cnrdfGz>}FW_b`79f`4ePINTXhIo{`6GzndBm2n2tf&`WY`7z*!S zS`}bOg^K)p9bo`m9C{r+vg6>(nw6E+zH(CZ7azO;0{an9-nD8y6f#3Lk7V+LpVDN6 zqe<0;^Q#F<&ByaLttU?B3d(6?JaEnx5p}lnL4#jr6Q<+xr-kJUWs@gUZD%Fe>QBol zI7bl<63j>RlYS7jSY4XWR;xLj8Vee~=?ELFVX6#bdmHlzi ze3Gs~C<VOe2b%bDtM*&a%^QX!;5 zM|5RI%Vv`VAKqYj5SDl7=&4=C^<&?xf49aFV&oNE*gM|hnb=Not_QPfKM<2rFO_c| zF+$Bu7;KmpMXY?i;xduW$s`zkH<(5`UZYnp@rw@CQ-Fgs?a~a~utMouVjYR^yXIcD zxD;G@ZBB6>uZ{8MFJ^{DICzCzYlQj2Zmp*0gaxOH}&rguQWweOl&P%}13ERiWf!u{3UUmL2v971j}5uph7SWfK{K7SIBP z-<445u_iG`)52Wm8>L))=1GNFimBqUNDCxC=bP9f5#3`~dl{?Zo|t4-P9!z0etk&qvA~SFCNjS}Ux(bSKxGek8O*ENZt$ zceY=OoPDH%2Bcxb3i@OT?%irXaReimjl-q`_0InYtc@7paLza{;y4I>PwMrR-ZCq$ zSLyBzUlzoM9qen&+oe@k!)$GBX}P(Ta6W|f;+&t7V!~w9$TynKKnnf+YUlUrp@1U!~nu6zxv*3IsU=hZS~ zJBmULc_><%`xMck=aDi}A$w7$EWFZbyDrmL7DeW2WGouMHx2h2=CV#ub%+LqILOB2 zDzRo4MlbK+Htc%UA^UeKrD962 zXzG0-qEBZQwrb@KJ1Qf3PGGRcg@gk)UW7LDp;nEXS%i-p@4JH0R|&!%iCyuv60re> z(o%LwD__5Rp4|o ztDm9qzziiTPX}@x%Sx)JI69GrbzsQ)-8!eR!puM5zINM|GfQ6FQKWS+@bx`qiyY@( z>BLQaDaAPw5DVea2pM&@3tjp^xZ_u;&eS`@s0TG9T%EU1D5ZQCxo4U=@?#{2eTqt> zSp}uJNGQv#y??5`fp}ZJn>c5AUTMlSg9kd3ekW_cp!5I*t+MKtp3 z#xJ9WQtic8Nt{mAzM0EV8`+diO$xeC=+Vyi8wi?!n&n4+V7**%HmLbqEg7l)0}eR;^mni#!{hSQSlX2$mW+KMqM!d zy4n4+DU0F$73SR8(l>1(#H`O610!U|@f1hX^K;gP;rx-$=z+d7=CtjU!oXY!H5JHZ zVw3({f1=c-rW|fk6e~nExU>-%MEjCQwKMGNV-Fk{@iCpW`%leN(-HSY592z+ve?g7 zwx6Pt7Q+cwb)bt>i}9+`P?O}Y>tN{D$|WIIwI;q-0rREWgrslxFJP zj)E->)PPDn1XFtueo=sj8#Q~%Ul96&G3I-23tg#_pb^ zCeiC(1WZg@R~t*a`lb298??m;&d@790hx?#V-0^~#x+dci}D=EV^)0Hc5#xJlt##- z*9{7-8-x@Y-EcGLbWMUcOB&?Vk5F$KIRZb+#JQu71igVVTf{?-iT_3#v_CpM+bC9E zuDW!5pZG$m{>>2@CXVe(b2PXGNGBb*&7HLj zpEZuB?eJ@{Rk%dKG&R2iILZ`M=(ibf(5hG-h!DP!WtP&(J=(^e6L<51=+1gfT*4=8 zxvi`N-!S!DAHveJLt$R^^(}OsgN9O4vN6$z zPjR1CiH__Pm4|e2>8;?N8fI0M$_gV5$GKqD0&2~JL0PAhG`0tm)3}_2I=I|>ndxkD zN7-$thpE<5Tt%FUN(&$axeF^{mT1Oxlrq(fmw=G5==7+kHDq{r)FTcTT9I6g+PteO z(m|#5A;WI)t>ze9{8UJiVk8|et=fpi6n%9Jo?Mx9cXYG;fs?*$HOFjJC-fl&rbE-pB1vm2rahmw&SjTa`D(xB)xk*t>tuf zsQ8c6Vo1;wi^En3(n~yCqP>8pl1{QRlODP-@iOp%HoM!#WLBYVKmpF9=sDC&sj*~g zCK7!*wlTTb``h8j5gH_)zCT2x;*EQHWQbX@%y_j~YP8B`_}tnct^HfSXddzyD-ARq z1FNW*hXJCh(EBK7X!UzXn>7Wj+C8QK6FcsACU!@WxiTxB`WHny6OVG=cG`D)u^+~f zCO))x3nS*X?q}tdzH=-Lip}}P7zlkIA&a>|JA{@~LhSPIR>YVQ+oOdL+KR@ zqH^aE6YC^nLzxGiVNj{niVcr;Z)~>30=MI*f@vjsyvqH`H_VR?08L6Jmb1;xEUVzp zy0ggLLfMFN_r-eqOoh$EWyaP{i6^KVy5D`+G|Tg0=oECd^9 z4M1eG5|BbOIx6?+h*zBx&Bv4J`SEZRmCBVAM{wmNfejH z2Y%`=mTSfwg?*j1P&VN#$B-@Mx_)n*kbpAC@Kjn|D&xfgf;5|^dqDq{>gGTo*L;31 zmq8O3Y>R?wqY^IFL}lg|1Ii5;j%7=d-4O{o?9Wp}+~}OVYRq?&s8YS^#TLRsM!j7G zf!Ig0A-V3g3UTTkVeNeQ?uF#Svm`3mGEU|8v^^ENf5Lsd(V@_$$11u@T2nA_@}TfV z%(C=$4=a+NMrojmR!Vw`7*^LOx8M{fmBsVT#4McVhzdGP-l0jsI2iZ+o!_pP#!KZY zC0;-OFLBrSc+VX+jlP=iCsJQ+IHG#K80-_NlbF)l4ZlU&PkVOcBe8GKl0Z>=t-*9i zXGHrcc_kaHl4PUG4>IUMtA8o5Shhm4c&J6mqR*Z6tw`HZfDq}fVUfI}hXwz#OG@RI zxcp8uQo`T2GrQm+zp)@i$g1EJrE+cXac8K^xM5w@0B#H2gJPu<{EiXdw*hFU&Ps1Bzqaf-Ee)@x3cD5q?CT6eHFA7b zN9=YKJPc7w+63@d(CkMKk|owNY9~K0<{NP`seZa)dO6%3LWs6Ob5_4laDIS0Bb+j!$PQ4J^(Tz zebCgh2kD9*O|!woVto>j4q7E$yR-De7Hv)*W@+YXTpHed+cC)#JNFtW_?%?h zYp`!MG~hnLr3;+2%PLQUC7RkHGE_?npwbbt9f7zt`YF!$TTv@_fPrPv%uZ*?NH)#2 zG>MBHcmbmzq|LuwMcke%BR$$171$uS^cqoC&a=`v@<$hQPmA5HKivbNyOU{Pfn?@MyD9|ZQi)HoJUn!drSt5Z&5mm=9MyV z@z11}2r9Oj+UVZ$u5@KWkJC$WHZAOI&}q-iEZ~)PzdT}9taGVwE>vTNUZ&I8C`FoU z641><8zM2O#uYy()54@kXoX$B(q_^^#q3K8QaBYZj!9$l3eCJ7*Jg(Bhb*o_=Tz5-G^3){s#7x=x=@ z%GNg0Tz!WDn#~r|SCNKGichaC6!@hY1bnKS(_UC@H)vlg-# z?UkR$i{DuzW3K-fuBTw(p90thbQ7@LZPYJ4Bec^=vRl)%l6t+SAEIlC0cP zg~X>Tu#f7l=T;Hahibi4=ul;f4!(_Z3Zy%~ zSv6#T{pD;1ZWXG>XC$2NHLl~Tl&4C%1ZxtLj+_pisKzn6ayS*`8~_3au5oPG7e!iL zYDL~v(r9V4i}&_wqFH`c>F^1JJ62>u4N^OL8gwj85!iLf_VUw6jef^CE<=BW8J(w9 zMfrjS^C% zb+H{@isP=sGQLqq`-@MFx@tSFprm7OH%oB1sr8_$@46~qF_{nGxLXwzQ^{5Ovl6iH za0JfILRc$Wkt|H=Vs#A>lKZQu4~v97uxC`5{10I1@QECrNR`CC0_`$U zBneBFX?|Rn8a@M40)J#u6lB9&jP8|w{&O{!T{5zhhTPY-px!V8*BQ5g*E)x#G7dKI zhDNyrV`Ig+NoiUJJugmW!D^}M2yON^=pCfwXac@x|9I2NaNk4}*FJ#Kmit*g$ev`o?wzDZG6gqE2qI$G|#^wO2d9t9;?x^Bvi!U)DOX3j2nxWL_A(+=*uFcZ%4&JuM`YeF#JcDec~j zOY35k@?3c|U-wTE|9oV!mLZmFB1`b-3v+*&P?osFbesjg_P5lLWdh#Ou|BrePUSL} z&RLntmJvTOW^fH;Hiop+93l%&nl*S=Riz6HsfWP?sqfp(p?;7>6{x#oN2v|Tdgcoj zDe4v0s6&K>Vlt383}~0>Afs->`@OS}T*me0W0h|oGLz6TcveVAwn{Ht8H_f(4Y8}E zll9I%d#AthCNT7Kw0t9NhvH;_3*^r1s!>N}yfPPJQ}t_4AgoN~-O0)!E}7qU^8)Q) z%~p3Ut*8S*rT9aO_VnZMEYp217?;r(nfO;NdjjmyFl~*@k_NSbi&d%DC-hRvi;bkQ zZFxete5W+9uj({e?e`*f%6Jz^duG{4`VVJS+guu7h&~K%7i?2mBSw;1m_?7IKY+dT zEO+M=`H-%3BrPhMok@3sDv)ao55uRGQn=I`MvOU4`&q;-B;M}$L&lyO_LYHZ5-Y3j zw04%tgFH&oz^YFIhM&MpB-wV}?XF3HB%NS)i=sx%FGw(PX_IinO+k?x!3v5c8yP+NV>v!YLO&m|rl>pa`4;fB z=L*6xSdX^rkF^~N{W$IvKDXaLyjzUcu&PH)s%U)%d}u2`!P1?@efG@F*Cu$^9Tb7$ z-&Pgi_25kN9{5vXMeKt}$Xk$cH@nYeEi10Z{h$8bPro#eiElOkGi|oPg0v41(2dGw_U_Q-6LveBAl`H0h2QPUmybwS9A^bL2 z2z~SFAzp_|;gLt~Ryjc47BZuRa1={;QMG->2K;3SX_r(iia)ipox+Qf!u_CBW?w2! zC@aLY&sYm}n=ZErmwb-yR?-ow$-Be$AT$HzU5S>;(#o3cr(w0_P|WYTM;^<27tl(81Dh zgmf4cnpr9z9q}Uui_Tojf0KtLFeyKae^8G8J>~}C$<>$u2heb;)uIOhi2oV4?iwRz3w=I$}Hi z|0C_a1F`!5|NkUqi?UZpWfNtSQ9?$tw~)PeR(2wZtjH?adtXG7y|Xu&*&}=OeH^{s z@6YQyet-S`^oQ#@*E!Gg*pJ)&@zz0+T#<0?#O|0MVbKb9!maG5+}DeLS9Nh%HQQTG z9o^~mHO{uHDW!H#;$3|m!8ybItRv84H1@XQ`-+FE{x@1bC!oTb!tTl#I-xFjh)9dO zsK``uU##JkAQ4iHWZ_?4XftUn^!g)Fp9()=>-WPu8z;XRxr(aZOmZ0u4#-%3wci{+ z9p_gs6;>R`!H&*&CzQ#ZlwK-5QpO&WnSDi&z(cPeZj_0i#=^u8Q#we>rMl5vR#u%iy18{!GUKw<)H8A$O_z_2|vE{v5Y zbTNvPxWXiVKc$4p`otF<5r0!tSdBE*qqLnT^~r{Taz;^6J(1%LiOR*)kUstI3{qjr zVmR#hn+fP&HvT7pP$eQFnuVd`LQl1sCK1$avQSu_i>?q(Qz{(SgQM`)igD+M>-T*s z>x}T$EqkUs^Zr2ARk^u{7^2TMEkCrc4QtUGAB^?G9LxPOV`FJ+yAM1(hASkVV9}Fq znx(WEzgCOQ8L!d9CW>hpN@Ic^CTq}ZGhkjDmFA<LpGI~rZ0>@3Z*(^l>UE0>o_%gPt9YEoT$tVQt9 zxQ);(yDer+4(;|hAFuPBlGaXJoo3(VMAb~0&4~WV_K22AN$K_hC4NghyZ5`TpI??1 z*^PQJS((Rt49fmwuaLt^C8$RfLLja2ApF8%khHo?P2Y5>h1ENWH2w%ZH%asIOTllv zKS`z$x2AkHXX<)I3Rsf1SE2PvDjGMU`gfEJshSSaN3S#5mp;Pmh%Sq^3{K!yJ07H1 z2;V%UHOqY)F}_K}X%gtVey1j;ty?FS-AIGY%&D}9qeZK_+Lw{O^xl#tfvm)^^>Bq{ zM0?m6M?h)rq*EP_DP7xBEV-^2qM2CQydehi9oKhEY8^nbk+2(B4a70BMGB~48Qr5P-XEv_tx)ArfpK4RC^>HrDReR!SXuj@3 zS+dJEAP^Rjl`6_)9^s2`Rm3BNv#?^{dk7fKhkzTOMjtl`s+ zV$}K;y4UiaY*^ERYLtOZshIl_3}3A5TU9Cz=vVW$&%G&Y?HO^z(k{4nJh=KUfq6zS z^;xYEh^U!nR<{b-3oE-6h7FCl`xxRhqYYZYH&;g`j^Q<+xW` zgY}a0^UVg?kwTyKn-sks?Ph3%5wSH2ud-Oum@Pi~2TJZ(Jc?cuk9Mk*`=MN@cK4!N zaDGzKK4lj<85MJ3yoWS8y@mg?iay9Y|Pys_$$#!qw2QOL--ZKg{q?2{dXxCn3LldJTq9LKL^MQG+a_O>_{76-Ya~mQ- ztaU}(i-b&*lpKWyjk|{jvikRuF9hUA?qs?tIUr+V%;CRxrioV8S!zxj3pcm#p5jML zy*^Ot9bnfWM1`l-ziqvar6r^njbR;OWz6+kp3b`W+AU*bY;;~VKZ6E4ht|6@B!^Wdn0FeOh=S}4Yc$xr>IjLb zh?ogkZnVmj7%>gA{0inGdb$!+%d30Di8cJhqB_aL>~GRAcnU=sWqk@p{-E zej_vXXo1$Q8c*}Igt7fK!w(m7HQBRY?;Kv*Z*El)E3(!~d`GoZF<@<$5q)grjfJI2 z-`f-hLo3nEMN_Yf+|+!ic*^)4bSiSXvSI>9=!YY(GEAe@{Pc6U#`#b@bx>BO&cKXj z7P1QWSdZdaN+>~4U76uF=x9|by1}VRZmvnx3*N z3M$>TwR2V2r#z~Cpn5=-U#B`#oSV|3epgoM8-uZhT|Cd7 zce2(pCH@C)EzC9^>=f(7GqC}dEN_?Q@5&}Go`a(7T#oV9>ln8h$^{4QS1Y;J5s#8O z>2SnH%H}DU+Cn3uu82l-MLR=VpL{#*k*;~(O~qpm)nFI>iX6GNxAY0#R%DUJ#ozs< zn&&N-V_BurN((iyBhVS|ebEcu^G~v?79VI0T)nU4S@Bp?Mv2jNQ<9w5;C;IeO2(tl z;le|8OW#fM0rpiX^E5y$KG)0TnxOO&X*3DVx9hyIAe*}>P!eSoGrP~z(wrM^KEp?1 zsmCG45;Ht;Gh6i%`Dh$V!;a@4xmILeR-A;Y4Yo^05-%BM>xUALSC0>uTEwtjM$j=v zz~9lChviD%zq^s~ZT_tKUW<;GXkRXBwx6O0Colk)xtE$uz|`lHJDYHaVjycpbHn|9 z;C^JS35fu*LAl!=Hn&=NCp`?S$bPUbBlxE?pht+OSoS2cPG7cea(wL%wB^p0rVIHm z=Klt_lEvYBHtxFvPl(|0? zqi$9W+<$1_^Vm#j`cdS&)nR&avtLE&TUur|7SR$IW)YVOuZv|A;D#$qxZ!)YnYV57Wo=3$H|B|F=4qZj+SDABo%5<$C8?^xpJbpbjZ`|_sdd3wXR z_u|9xMe_81p=M%liK@(EuJSmoG?mMx6>(U7`0l??neX({9~xZ0zZphh;vE?+A1b%B zvqfqi*RFC`)GW>jq!&q%QkwtJN~qb4~$O*9~*W z`7a0WDOO%JN|QGK@oZRAoh68JukD#(l5fs7`L~~UWl(HJ8q5=o&KK`rlu0h6wcuTU z>nqXdRYLn#Vi+r;y6WL83$3|_5^+~o$F9BQdvk)$sBeX$$}oQyy?fUzYX~YBhOcKV zsBl)+4{?X}3=@Jf-r2Cn{1lcZx?)PDRsDHX<~qwA?Xo$Fbz^^0s~sh+Sf-Z8887b+ zP?H(2*wnlmNa?R9oY7`i9S_8~W{Zs(oiR(rlp!#%)X;68p@~nno_}qov~<4N-86I8 zX@+*aALl}2?pwxGrS7%%2!y-Gp!Ku<`qhO%y%!hmUvHit4^Zl78e)t2BE5W_`L0UY zYCbG<3`!eLJj3EDqs=AAiqDA}&b8lHd~5XJKz3t9M@f17dQ_!Z5hI=MU87jPUzAA< zx%Z1aJ>U6DrMK=@huvFv_#{{PS>r=R{ZLDmyhs5<%CLdCwo|KR#@p7Qjdit%tf`kT zf6q#XgV6N@dZ+{a(~m2xRy>`e4(^(>iU%SsFH5LwI6H&d&pRF&TUvMq8{G_aN+9r= zCW?=?sD2it;-bGp?9Rx~qx~av@3M&BsQH%BdNkk6ojP|8rPRA??;`4@taM)U=fFn8 z)f>{T5A_#Tw{W62Vmpck`GRnsNL**OjyHiJQ=z-WhTdLYo*JN)mBTBte14Okih_l5 z^Fz03wLF=7I*%N^-zL9l4rQ3I!b8XEPf^Yu^PZ!Mx7_dM3-6K}dNkf#eFsh3%mKY< z_V|G`nZp|UObA!%ozjX#8I^=%o+n*5miC%+S&ys%>|UJ)9gdN)aV8~W#{%l-D;8x& zUau;kag3DPBnfSNMK3dk&11Kn_rw1z^&yM&cVnN)u{l-EB1lc!jKQmmR5{5keOS8;{u9ItJ$% zU z%q#^{QHh1l2M))jvb~*(oA{Hg@x|?%I2mdqTpBM;D-8dxq9&JhO{j`~l(5mS+FVYPLsoqBoc3;6WZhrcW^f4@MSMN=@ zFNM(R1Wk)?00cr+r-aV*SJz!&-2oaAXcLNJzI73~lWhoXCyU3<*`WD0CjOl4?gQGm zlewE)AYx4Zpe5EUAKv0;~v@{LOt6s+iMRqq+>7xgoh2YIE7pCwQ) zHTF0kl$8#+<`T&0ILIblYPvxWc#yMgpexLKdLEk%?75mKzXMLu=-%9}*(Exh&TKBj z#-aH;2G#fa>=vW#KF`3N`%H1PP!=?(Q@)~4hBU0NEHc{w%ntzdhb>=Ls)c<-QI2*5QH{02cNYad+ujF zU4?~pm2ngu71VE+ddvQEIs*01XnRh6=*$<|*JmMe(tJIAr!U})x_AUD)&?0cl)TBt z&aTQUlbZUcY}9)BDk{0Z718z8DA4yo9h~0=hSePWsHx*`u~aT&c0pF;_be`rA9p$e zN?^w7mNMUHgjjZA{`%RzMfv|;>VC${8MHG=3^8XFD1A!=j%zB`r^)s+enk&%o* zL4>xPac2VmS&)hBIbI|ZL<}2(By?;X%kj8nsHUA_5W^i3^-hA=f{rZ|9PZc0`g5O+j90HA_EmL+ z!}#?Vy>b_@BKTwvWl2KQ5yOr^<<2;o+OE?9C(d;kq#4-fFEH%Wi%t3F)dPOZdAP!k zK_c1!X5(-|Oo$!vg1O4tY2ATkU&yLivN)tX2x#4AYJ&oUZDCae;}i7KGy_BiWJ<61 z$T^VsvjXX0$%PqNoU6z93pIhe)rg@9|r~5E3G7BKVNMr;V zg9Wak+#p8BISyIl12Np6-7(kUUIz_!<7#gBVTy(`Gc#L~hD*-UY>aR1&%7D+noVh# z0S$@%BTe4g?0d$SnT=nL1>b4@ekabFhCVeVFfZB8Fu?kKaWZiTc@ePFvg6A(PC#x~ z2)5i2+RE95o!|lQHmgD~qq`1`NC>Op!GG`?IzhmgpkTUsEXl(MNWZ>co|nwb%tqXTUj||~uJVXR za^4NGPOS5vyau z5@Jx15asJ8wuWtCNa0-%PtUXX1Vj#=jBg$Th(jCkGAd#(T6b#3e1O2otu8@w%qiae z)Op&ER_+D+xttBZS1$u;G`UjKUL6?X>puU**pK~~SCkMh4_-0n=YP;p2K^nfl03=~ z_y~=f5TSwwI=Cro9fL#%W;&74%Kq>Dpn0bj}qOM3is^x#bMNToEj@I*{y#h zDSz22xz4IxQP8`2@%QD;^4gOQXR7AnlsSYUF+3;qwc=rYipX^! z>-RIJ$m8tDU^)Z-$7;N@3dfQI)hAVckkREE!j5`)*JdJT+$J>zR>qsrB*0C!p`*## z+7=)S{#m~GdNiV^n{QN#?UlRZ^a4?H?!LxkMXndO#p`i3zv61Oe+_sU_J--n=jMZj zB%33&Jp{Y)>;UB!-0UU-EHC*eCe`J^{6TgJ$;rC$E>x45ej*r4_9W@T!om@^OCbl8 zXpU&I-dKYEU*od%T{9(Jz<)xOwc)N^p^v%isPQG_83SWXnc--p@pa!-a z0(;N7r`_z1Onx|G+AkQ=yw@rhjCw!IEwO*{(Y|1)5y+a@aBN^ybZQDlunjDMmZ0qvlV_pVcT*EF`{WK)FH|9{$rsE+?69SVLN*&ngJIDf$+JMItGadprB z9Et5w)<**EIGY4#w}~ohZBYidws4hYuEpWn(Dzb-#cm2^RD=C5F z5}?KM#PR(3^CfLWJ qCb_t{Mt=2)5(xiRjOn7ka-MAbc4z95+;lK!pr3WO!`BZR zi@wb@PZNdEHEmai3MC-wuVK#@W?t%{u37`0CZ^_PzUj}pCA-3_CB4eRq)P$X)MZx; zcp7`$0NA1;JOElqrAN|^LT45as%8xh4Y%!nN;(y~v@phGgoxoP-Bs_Pwc`R5FZb{t zQ+oOZpesF*TkfDW+kfku_swyesHaRmPVs|UdNHW4t(vtkcWpeo(W#qyn~>o_^C#)ZPkDJ^Izevd zN_52r-CaBMJa<%9EyD7?A-GT`VBscmNJ@GFWgBc1dC|2Cbr@*xg;Q->d~oga>j5{O zv5s(}Anz$X;jGtrqvv(NcuC{B{bRs&+NQU@OKeXP)vLl!oz4Q@X4}zq0Rc@xjvc&4 z?*h@XT?ELi6MgZbkAQWkSj-q|2AKOGz%wZgsF}Wj0U2%3QULa_huX;Hpc`@{P$Ij#%V79UAO{ z-H|pnPILC67dYjt`LH8A8ZWq3AyGw>I*mOeF;c5w%UfZsYp?C>>>M+bwcVz7s#GO} zr>(1-xI}?l>*Lf!bGa;ebWQYlnqcdPEC=9sJjAWf4K7qXlX9t9yx8s)?w$>h6|D)c zqgAoml&F`1yk{ZaQg}lg@b3tB@cqOQ_Spxo@H1zBeCz=(ZC2n}du-3IFUy#YOsQI= zJ+_Vj2y=FOgDh~3xV6{;LUPewyULG?-)TA7r>(hJaV9DCj^El)q>01_1ftoHCmw9t z4QZp<-daV4gq)gI+m41yyEdW>%?;i%!tn1+k34K}wz76qUHO>TC2AP-B+F z2Tqpc?7D z$ctda9iTI%ZHnu*!YP8E$Il4rQ{yP7o~f@d7GRtPm0;h>WZD07T5-V+;*re3s?VPv zxQkpS!~={i{Uvyz>9@3j2O1f|Q8TnFv2uE}9)pAh)snM`?S+@~Dt=GgI~Auvgp@{D4SXz`7#+C4`;+EFF{43z%@(RmobK zn#$Ri$B*-{M?=uA+PPdkWNbK1)?nL}f_U@o&3g?!K;SdYzJ@{wP#=Pkc!wK~|I#p^ z6U~njSMb(|26O!m=RuQv$@O$mO7w^PO(aV`GZArdarQ9%m9bi=RKH~>>G6w|B z=$6Qv*=SqcT{qdob*RgV3knp0QJH$4!SPDq*TuI|G;co$x|r|5ms6+Q-m&pMiqE}` znY$};^7~0uDy*Mx0w_d$159E1wVEAsU)gDG+ziLNY=ct?|(x`SVgv9CWn?E2# zQy8!7&!k^mEuV~zh#*386A$F6P9Q32@{=FJFtM?JFMQ%&B5|k<_CEoZmszt zVLGR}5Ni1SZR1xIkr-$=K>oWxn%C;3)kA#_g>?jJqRKLf^9KpZHCz|pR7xrTre||q zK;>oS=jR_e2sYh^N#9T9K=I$H`P!kz@E}xCM=d3-6$CMij^z81FeFQdmOn2gMT}b3 zaV97Jzu)V}`59|1Fp=9N>=-oLW8lH)$%`Bq0l};4-jpw`JhGLJWRMXtG3mRq<+VUR z!=HIHU5xAU;(e5e_d%Q9bp{3ru$g#}IlVl*!OySp#l*UDj)dQFF?`9Z0>GaD#qXEH zt#V%d`C1d*ztGk;w5Rul^?x6@=L=dQ(}6E$y*FUv6Xmf#9kewcZ-aUb#Y_dr?5@Kc zLnH`&sEB2bD$vub@glEXQ!aU)5P}LU*5KtJ1Y})mjr7BZitBNRyBYb#W4jnZ(M0wI zck%NT&B&>gt}-+uh|qF@P4ib zgO(@+HaQExz02?!ZQHxM(Vzm+Ns<>z#jkW89UXa5*gj z=LJOQU7d$J%PORd&*thCybqtmiF(&ST%S6DoGVHW4vrlpNil)Twmly7K8X?NTwPrq zIlFM0e=hu?oLrPBf`PW3gUVkNWI)L8wg)efTBA|pQTe>98kAVzrt#H4a*#bUHZbt{ z@456rYJY^(E=c0AkmNl7sAQ~ShxRDa2vjAQgSPvEI zh57ks;GgK}?FkUi^3t?fMOC#GDtV?js#8$pk3sA+d;mJwsSFzgb~(X~Aor0EKq!vX z3xR)h=L;PL(I!&BwX6*0LotS1h;8GRy-Uc%juB9CC4+f zCJZNqo<3EK`0CZ`yyK3MY}%E(BNoV{5qRbv#j^)!^JORcc~^TJw-oZ_@O<;b9PZx_ z`1hCd+Kv@&R55ns-JU)I$D!5O>-T_T8`a zq_O}OBoPax71h<$)GXP)LWoG=z)ggxT4kNwdGD7tQs)!sgr?BH--X9XR$~=CaEc*w zhjL@mL*xd-%QW*Ed4fptvLt-v^5taY2*8TP<0gKX-Tc=Put&l4=0iC8mZN2IB8Q6% zcdVO`SuCU&IsOe$JU8K7y+O);5m8Z$K?JnXp!jFKx6_>>QRKG$%ngcZbD(DNWps7f zb8q}6f;&Gs+ROG7e*QbdS?>=BJ2XSw*;2(3+&p(?mZWIhB)^ydU-|6)K3))2YvSkN zQ26&HG5Zr{Wat$?dwmT5{tkhSZk?<{JF>T2;eb8D8Pm_&l zjZ)KPO8?;e9yu@{rM7Ph{p!h&UN_sOlH+Muav!J#izaFxljcmcqoM-clBH}I_nPgX0c0sq zy>uB-D;cOeR|rnZw$1bYEyq@-^ya;qJ>k+-$PtRn$9X9n)=lhv`xCtf?*dYRp5KJ^%++SicA1EK*H=?xK5Ruz+4 zpp^$`ddx;^S-%A|ixkFXOu04GGCL4tf0g8uVV*+3s&s^nsii2r2^H@Qr!PALTI_g7 zhk&O=wys$br_x_T?;#dLw%2t;Vr4+-)(6{4NE>-Ct~KCM@$m*j5l%wSdDs|XXSU^N6n`ozQgS~9 z^W;YV_lm&X=9|~~MpN(euJuXsYLPt}|ByV&eSt0Gve?FpbLVsIa*kdNun(ynH+!rU zHW|URbD7V~I2KA+RvLCI{0;RGlD`{#yx=Me;afq37o`P81jRq&QhTHm(`q)B?BlQv z=U@2kXeHeLS@1@y_PTmdz+bv}eM~#eT>%`e8!WOTHwe5*uKBRft3&9GNa0fpd}7{m z+D6^B1a+j&L3pI(wTDO+OWg>@|gAQ?^G1!9VRx?A^sG8$0`7L9&< zlGeG{=t4TA=J<9O;@6Sg9b{7aZ_%{#>a~h@0OoOK>R^j}Z&8c&r=WTj@g%@HupVJ~z<=r)E zNK!$KcsG0IK-Ld~)1Yf``Rz@3bP}sIM{7?O#sJ~mM`nd;HA$U5KNtngxsT5krg(kU zgeBl1bs`bQ+b1yUT8-}le)y#jys#89&q$@o-0!PRKjP6gV5P6-MZoW??m_TNbik_7 z)2Bl-(T#cyxwpvE=25;OpODd6y6(B|Zoe@lW_6#t$2PDqc!Nf4D%G6;37;7Lo(U-3 z=hy2X{!9T<&OmXnCjwpin?D;yu%D$)=Rv4hy7leoLM@)-I;@`1yCCJ3mkF=vWEY$& zkoRs@8t%U0*S#B^#Yp8*nvZoJ90|JUYpo~w9FX* zJkNV~eKOygr-uz^XJ;p?;T}>FLUB`fEjS0hrsU0<@t*YDlSX0%8W;QO-AlY!({6Mu zEV4&6Na#lT_xvUh7R9phU*@TXa!!`$LUE^nEYhJ14h!4e566hQ1v3)SlgIPC=C#P0 zkV+krYj~C5KiD&X|8I_j2W}$n`eJ+e-4pp=N^gY}_dAE^RzL!WN{pc(3s^dN@v7O8cd<XqT=^t(&bAc*qjEe$RoTx_->;JuTyQbnP zP{=6Vo_>x#jXh7v_0%62z>e=bK?#w|h+GK9E1z_ofH^gr)B>}2_G*IJ(+_0DROj5q zY}6OKPwtCxfwg?hJ_HH;PB=!T=lE<$2p*?CRhxO^lt>vL}~1MxMQyv*O6 zwqrLuMZv;5g?%iwk&y7q;*@IOk1j7a@6VEN``C}Gd0}Q`9<A1VYq) zyZ_r!d(iAlYe3dVEqX0?+>lN`4zhnLKHGa8AGMr0D>a*aH?U@ULDMYjRaAB!s&yb0 z!>^rPyFzhia3YBW6jA1?!T!5j!&t^w5hNzKKn+s&>XWnY|Q780;J-J~9q15`TlN9t{ z%T%Nlo||XBP|XLEQt&=({duT+(3%Dpo=*7m^F~~LPLc#C4Q`OIItTL*<{GR)FEF=p zKSlXhdX)^R1Has=*3L7)&IDQ3yhA(2 zUK+WV{!3+vWX|;O0#We`4L(w>i70E2j-Hij0uI#w)03p z`sG73T29-Fa}LLm|KMT(sjgyM%G{f^JN27Q%P-tEP_b{cB%+a`URx30U9vX{<#L@P zNl4uqYSxIQqPNdFg{h$FfU0Zh@*lDe-#@^KK8r_?%DUiwcRtS=W_xqJr(F%SIt7+lcj}!Wr$xe=pnut) zNZ2C0mnNY3Ha3@dB_$2ZHx`fbZpJd!(VRQB0QhP~WZ@o3Zz+vlkbfTHun`F>I6tU1 zVEhQCJi1$Fz)35Qr_mX8clhlXd{GxIYw#EY6^j)jZFkKW^zou0Z%2i|CeDeFJomE1 z^RE*@ST3vJW4a;6;sow;*+tC(2q;xoV$inv3`MqG`5nA3B11j&Tfn+Q;>|Rf z7cN#*;j^hDau}sFza?H<7bHGkVnV7-vyf-679+lK3j(LMu}TLOS#l}AOC|xV`)`Bo zRJs{Qkkq3rU$np`Bm66uMDtS`ZsnR|5Kw%FRNBzB%JFvp8%NEqgg5vvV}~aBqP2C1 z^{&DYPL`}}(CJ0$&w#;ntn438UPkv^OVsyN=NOoTZNlzvs8DMf2Muj^5y-cfxW*Em z)`l`c;Za9x$2bWk7`WR$6JXo2V&4I(E7+#(ZaH)zaOeyEedv*Csf#FY$W~O^i2X74 z(Jt=uYL+B#{Q-ftwQ?klHlI4~?p6${zYM<$Q{?hKG9SWB)nk?avA~K?WVZ>|r8YI> z&avx&m7nlGv1K?no=WpmfY2H;_fPrp2kDZ8Qu4}U;AG(1@?0ms1@91gz=@5uwJIo4 zJ!P-ie_BeN5&M-o5mAT`eecxf4F2`)5z6ff{0?v5~6kbF1F7Xo7u9i^e#)H=;YbSRr?tEHg zH>$&9Bb&k4{(aNv*IK2!p>uve*h-7DAyzkiPH~cZ7Bn7#^tc*T&Q|Hh=L{#2*?jZL z8h;{Fu3dx`I9H%xs$(horcz;%9)D1Oen$)Zu)+hFz*ZqkDTd>F z;djStPIMh_x==gk?w{tMTT9yIBdCU~xE?fcc%`iAOJN4I;&SW%>av5hc$S9q7SBX_ z#wT%Jp7^^~OG?4_`{EN4sNA5Y)aP~q^786k4+dd4Fqdg*^O;);y&TaFK_xJIfDRDI zS>jZ5&Cn>GeQ%NXcw1jrIY(>IK=td#RN=dKRdu+h?Lv=`k;?43%RiF?F!ES9@lwt; z<`v`fO(un>RV}RHp#wv&A=Xn{$f(reRHq9ecbu}LYKvk~%W~^!#TnEZ z*pt?iz*@ElUe1EK$Bdnyu~P!1T_Gn8zd_-5I84O_?UjnlHu5^0H3$CVIWIC8i9LKl z``)zYw$%s^ah`rVp+6g@&c=`r`lWwTlzwrN98rMMBHc+4nvA`sUw5u-@n|$Byqj&5 z5-fTiLGDm{Ya#TSow6$Emk5+s-Y;C$3|ZyJ@jN^>}$o^HOfSqT8EmO(X9c5!}nd8kXkISi>KS*KEaIiYi(z{GkWb6xze}hqb4N7CQ&l?7ZRO7zw4KNQ(q2bJ%C@ zMj6S&HfFBsm`pXL4}ZZDKX-wx*rZDpy-84@z}>q-ruk{0JlS}VCqb`A^+*%7>uB_GDpIt%Z;FIKo2U)FN79lZ^>W>OgV`(HK zKYI7lOlwM1VkN7{9%tu67)p8HWVz`}LO$QYD2#FI^TfQE>>E&AZb5uVBISmSP~d@RqQSBXPDbs_h8_X+x%(Dz+<4oSaoNZFN7JPZ?k zsF2Q1o)wZWKE>8SA5qhU@eNIisbldr3}x-*PO-yIMSoVwM5w|4>j97##oF@H9KMk< zZUoioG!&kMnnp!0;mJF}>^mV)`l+brg24-9FeuZiZu})uwOhLT@zW>C6VraSL8K_7 zP0IY`F_RM%QXOzf>?uNfe70BW2}Ju6gML%P6`h<_&i;vvnN9pzpSfr(l6oLY%lB~( z=Nk!1Vq;?s2#Z|Z-Ls=vhHM-^_=wqTLz|aipw6@f{<+yH1?Q%+Oo|}w5jIO|-EHqv z52wTvi2wdSzu|LqGzoEuzL0MW=zEsVem%FJIH5!4_3mkHj}F=470CJ*#qroY9Jlw7 zA&9{p$m=s?G9gtfkqsd3(TCpBc|l$_=VWoLnLAQ@0kTxa89(F^P!2eGoZ>F zG;-CyLaE@M1qtr&H`cxFT_&dujB$kxr*ilLu2|vJ#;YCASv$v!z`{+?$ zVn`p-Z~XJ`Sk(NMcy!878M=^SD399f;A)s=z)}Vxk9m4lNBpM>O)L@JxorFQ=|Pzl zWIU%H9Ynz<_B%cDx zsa*fp{rYdE_5a`HI05w_Tjmfc_%()-&y)eR;iFU<^i_4C(_}3XjZF0ldqIwcOx1j< ztgP&Hbn)?o_EQw%qR-mVp3jl?HZo-h)f;3#%24}`QC$Zei2A-;&ac(AnuKW%I*1{| zP>DSqHqa!#0bNq1-i)X>NjzYe_!*nopx1P|a3yA@&Ro=go_ zqx-#cU&dqesvKA&V6n2Y8ZmwZ>go0k#A+GXu7Rw1Fcku&Rk0vZo~?>(Y}+tw7uYqyYju2q&b4^Jpc2|%xgS`;D;#g@RG-GI^}1+@e7-0ze*uj(dZqtabF zA!%+%soL$Za!JP?Oo3r{t~|1$t0W{Ny0yQ0(?`D%Y5NU#S#%w<>No!cl| z6EGMVmGwyqhagnNmrJh9YV-z-NoW0R1L+b(LL3>q$-0m48-&AAtw_SIJ!GcWLrwA7 zP){n9jE>f0!v{NR%uFvkD@z%p6`Eh{$T}Ew4!aT5UAiY@>I|Uox^h54)EmmyCEFTY zMm>gqZ*2Qs-JL;g2AEnH=?ZhdAj|q*FKt zGd@qo6)SIB&LCbvvmm($KL!0;5Hd55PsP`5rdM24q-=aqvshoRi+_RY01@Rb7mzRBMH%W&N^Sp>*VBAHV5qw9}w@A_7qv3zw@8# z#n(7=kmokC13_qH+yk*f(2eVzxmsrQ|;OOYAAM|Eu@QFPCeZ&XJ!sbZ~a+{il>Du&F1yJJ6=aKn{rCr!V z;QV{9AbI0+v18joqCZN$4Q;aaQ>eN|LQmS|{h&~c({r2$j_cG{20|c%mUVNhgtBED zOcR=p<{^`y^BwW&noT45lm2G1(X5YkT7O<7k&0Qy%j4%t3_Y=<;I&RbX?z#Rugsr! zr)k;*g}o?Q_R8;NW3cLymXi|{=Sg(#9OYwaNipS|Ui+!$g@7GCjW?ACd?KWU`4x@! zzxQ{p7D0bR7Na#5#`^MQ;T?%_ThS0r+C0d2ry31eO%ir5vpV5>;0=tiK8wlGeGvqB z_}{i2apV3y3{Ti!I#VbVr6;_HH2$s8Q_#;}a&$pfNZU|O%b!Y1RaWCqYEtQqKr#Nd z{p>?zBX!(a4?UCGB7bL5uK>P@(KnMnRa-Y?fv}xO1J$OqCVHd z1X2@V7@1%>j!mx6i&|TaO{?q?25#&m+{TOCMs<9Sn2hb=-)Sb?Q7`Br`a_b@)!Q%3 zVw=1wC#EW&3&@i-i_+26-K~ZGUF9Akz%7pNK9sn!vLfF#2ls|w0eXJ$swAW0R@*k0 zfg>y{TvE`;6Dr}fF;yquTQ&2rxk$gx*IJK*id#=_Qhs@bO=@M z1yu(n=C^lt-3&gYg9Mvx!UhGDAsp$T6CNxCTbfID2`u}yPH~CqqDfUa8s~WN?@LK# z&-l*xc_LlkJ|1lbQet8!O&h&`#Q~6VzIIh={ux>|k{gvi^f@#X7g?0;`y=(5!nkT? zGAmu?iE?YI_|Vu5YR8X$YtM7q;+7?2#NcI|b4V9#U~VSn7axbMmp+Zfi*xfw$)f8fQW7NNM_7NF zW_H^cKHXFIX(Gg4{PqG0$#))5&DXtV8|cosxk!(@AS6zBA!fI?hoTu5qkZbzA-~VU zcL%MQItPZ0ufNxPBND@M`4toZp~lrqU5j+tQG7 z<Sf&{b z!JY(_%dB4+`sEkpVntvA=?>ob4z!Ra%XE*dzIh31KF+NN7Y95%&d-4wJ`+!-UXYZ{ ztCO308i-ie5FBoMIbS!bb7ul!^j@ATW$4@LqBt8~wR6#0eKWADp%cwzK=HpiyYfJ& z^Y>38%DIvw#z?DDWW>70QM8pVm1}53L*+=(I3~&&wbe{E$54tCkxA|v<;XEY?huA* za$l82vFz`8k9OPbyZg`Y^T+%(GoS1Ie%{aXI-Ym`*4m%0e7SRjwfyZ%5VYKh-TL6+ zc*JgJS!UqTLmhykh zNj?fzR=PYtkRa4`VJ!DZLDt`LJwX0`#w$5{^%KY1Y7TiwVsd?p!VNmTju-jFkE`yL z$Vk#$3BY58Z5*$MBvZRQhi#P_I!+DRqho)^v8yhrB7FHVODz%;fTl68rRp7+P42zh zqlJibj{2&-2ZT-;vkyRq$pJ)-6O1-Bb$iy9Z8n;`L|*DGU99XT#fUx;w(#^e6kMl0 zJH%8@8Plc=o7e$$x1O*CF+LM|0k2-Y;@09mn~xM9HlR_J8(P>nvhxu#t8~`?2u+c$ zR0~V%x>F_d1+zL;(OdnVw)H9W?W_*P5i)BB!I}t>9IRfjC|;~)0Quk*{?Pk?4X%S& z{Vubpvn*4l(z`=t@*@P=4m53J zd{6f!8mqB}m!XhZOV4Cr1rGAoEWT-rk2D^W8He2C*2SDaT*INs-@TnF0sY5Ae9oz` z=elos-YO0(ra!{W`E;4a5oDw*n!fC%%HJOE$IWD=xfB`fV;g$DV&nTqJjB$xro7EQt*4;WCb(eP)Y1 z8{r9~MU}J@+LLH`F6NT{llApTDlmN-LtsQ%*9!U90ekd&fkldx^V? zdTfpNXKvl)N3++{q$z(lz`(|zG$%{Gexc^sc#``@;*5=Lj~(s=<6>^alKPC({JBRh z3x%0KZeeZ9_HAu&n#yGAzv8#?_kX-x;~~)bV=(Zd6F$hK4i!j}S@p~-DUU=m zSCH5p#yen#XWa-jf_}?O(!<=ezF9t^XZ%3=__6_YS=wFNm8|GdI1|CCpc?U9Yuma^73%(OQY**RqUjnCD=_M>NGVCwj zfYh@XmY*ps{3q>BW!}cMHC!LZ6nZ;jpd&5leir#g?lQOS>m25(oXy_Lq*zF}VpyOs zcJP^ZDKWhNbRO&_9<&`hcK8jg5viLm=#A@9J@io~)d|D)9i|e&=ERg#q$#Z*ZqVI$ zu557{JA$~|?U^87OLH@G59^DrYx7#|1}NG(T}Krs&p8G;=r3^+Y5M}`;BH99(_Eh= zwzFS`ec;T`^xDuk&*I|Z+FkT+HXtnuY-Kp`2_$^G0G(&nrASIkr!BF#lD|?>vDf9S zmsd6;|FY}{UGyx{3QMbJzdeIDy760A8%dLIAJXS$^8#Wh0C1NxA?|XvEcfWjk*c4D z`gy}u?$av+_Zv<{&vr2<+B`3wwqeeHN*$-#pZaS&78&?Ly>;Ls?nbO2=(*jTmnQ-}oHKI}w!-!HMi+v=p@vEt=UJYib<_*`B`A zQb@ibv0spIlVVc@Bid)i^7RR}z;&PAY_Se$d=IhusKUG6N8Af%N54dR`cpabJf>{BG$Q9@jWCDpv{*yAGC&vJ?36Cb#v7OFAjTjDvvkc{YT{5e~`V3!Ws!$-B4lOa)=v_8Fa4)59m8`$IEt2OyEu8F(qPV%a zS=yXH93eydwUo`_WV=XUex?jowko9kS&jANwow%HjGny=b3Fd8;?i)w#tbi{bNzE& z+*bzW6c5v>0{aDnI~lmCzoVFF z4kFFqzaV1VF^Xh}Xf^r{n?u10WR(8~lA$LCay=0#SdJlA`3E$J#>{`fc<33x*SSa* zJpUu7Mhwkl9?CAe{YnR>a^4((25*+~SLhc-2jDGQV>;1P=JiMfIc?1cj zzKUScbyGklXL-*OWS0faznpl47a+Ic2QA7(UQ9)}gb%aLd_T1NC)kjm%BSeu0@0k4yI90|cXn%{8TMcIbV5>$;C#Xi6J3BLo z4;hTTz+iI$zDd#(z$na+H9MV!BNocb8wJ|Fd-qP?a2=BhKJJ@W2#Ib|*rnA)CZLwgV zkxF%BvytA~s?m`s%3F>Uph(>7D~qQNG2ifoQ~^tzMidqASi5#D*-l_9Eh{TaO}+_% zmCk=G%qPZfF^vVkxc#yEo31O!qinF0{F<1^b|svl>}gR8;~><2>J;E-m%l-xXw(aE zvXhPuhptd>v_32$QUQccdVLnMDg-PXI1Z&#W3w}$y>6g94#)zT;r&%A^au-nhPJpl zRzpZktX(~FNKj5ZA--0Lu3df&_%t84rcmrVSas79A~b%)VolV-C;)P~@*(Hv%oE1Cd6`UR_i3V1DQmV3c2x|M$KIQU7hLJ;SP57iamTT6MD=f#B^tL(@O= zbM--cdw2H(&@I2kMSn>ov}~$AS;$raI3&mL7Krz&nzjx?hl1gKO1}t|ElW*tXCSQv z2dZV7a)*hHbDK-jt%)r3FR`-hR+Ym(AT;Vr_#X~Zsvv;rWI~ZfB zalBq0SnMY2V-iF1cz+9#J?Fs#)LE~bM{Q0#bvJT6=X7^tjj7+2Ilkm&%!qVH2??qQIza9W zNLd*eSaYxZaXl)k$whVq4>G8*37}?5Y#Q8+jjqH%DVz`qVJ`ts$vJx!HF^2Fb{MYy z3_?&d?rSDL|Ggn-A$Pd=;?4nRAQrRQ^Ko(u<;=%Q=?A6T{ip|K#IbKaE15J}t(}ps z+FYiq($+4>rWno+rethU}&GhtDLf|>H_!WIhW7%$mP&U4BeVe{U@XS9~J{E7hKi8CMy-OpYl%20)u^a-~v`g7r>-shKLLF6dtK^7OiQxR;isl^`nDg z-rbgGY3OudTtFv7r$bWx42^}iVnO!>qS~!gXSQ2g$Krtk%5bS!n4im^r1LJl)$XBi zGy;Q=#N}H@UCHS7>iJ|r7=yx0Kiu>`c1EqJZ(T# z;jZI?K*TQ35_wFy)<{8TgDDHBCiXpt+t72&wf7K&S!6MS)C7(u9>d>1lxH;i_dKO^ zn)elhK{`joti-#|{N#gZ&{4nAM=c&uH>9Z!umgd^Q2juyl6aY}!E|jr-*9i> z>%s%Qx@n0m$dg{+iZhs^TXpngXHon>f0Rly0Bb%)V?}8CMG>(%BQvz7PSXUq(?LbovgDQ z*sdDq0|txhio0^5zg6&j)xyXvv93?gS8To?1dNUv82l`Hi(Fbbk4x5j4I;7 zTJU}po134g5; z`3aaOT;4vvka1as?d@o^?pC?*zVXK#(N`jN`@^~h`ufs&XK)(D%3XS(RCwfo#N(ea z{`Ej19f0iSm9Dn`6`0WAKtGrz^uE8}t=AY0GOniS#tAc%mJ_fb1MVj9hE4T3??@~smHN~WKgz?ohDIun$?0{-iu8X&%`bex)+nqUdIV>khW5f92S6m`BHcg}NZd^9|`N9&^Z ydGWc!=PXxst!csG9?!?~yW{@^ot>)q(HM$(=Kj$PaLnLXU*82W#H)Wb9Y diff --git a/pyannote/audio/interactive/common/controller.js b/pyannote/audio/interactive/common/controller.js deleted file mode 100644 index cbffc2899..000000000 --- a/pyannote/audio/interactive/common/controller.js +++ /dev/null @@ -1,367 +0,0 @@ -// The MIT License (MIT) -// -// Copyright (c) 2021 CNRS -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -// Can't create constant because prodigy reload this file every batch -var currentRegion = 0; -var regions = null; -var ids = null; -var refresh = true; - -var left = 'ArrowLeft'; -var right = 'ArrowRight'; -var startR = 'Shift'; -var endR = 'Control'; - -var PRECISION = (prodigy.config.precision / 1000); -var BEEP = prodigy.config.beep; -var EXCERPT = 1; - -var keysMap = {}; - -/** -* Handle web audio for beep -* @see beep() -*/ -var audioCtx = new(window.AudioContext || window.webkitAudioContext)(); - -/** -* Makes sure that the document is loaded before executing waitForElement() -* Add a small timeout if wavesurfer is already defined (useful when a new batch is coming), -* the time for prodigy to update wavesurfer. -* @see waitForElement() -*/ -if(document.readyState !== 'loading') { - if(typeof window.wavesurfer !== "undefined"){ - setTimeout(waitForElement,25); - }else{ - waitForElement(); - } -} else { - document.addEventListener('DOMContentLoaded', function () { - waitForElement(); - }); -} - -/** -* Compare if a region is before or after another one -* Useful to sort global variable 'ids' -* @see reloadWave() -* @param {region1} Region object -* @param {region2} Region Object -* @return {number} -1 if region1 start before, 1 otherwise, 0 if the identical -*/ -function compare(region1, region2){ - if(region1.start < region2.start){ - return -1; - }else if (region1.start > region2.start){ - return 1; - }else{ - return 0; - } -} - -/** -* Simulate a click on prodigy's label radio button -* Only useful for "review recipe" -* Note: might break with future versions of Prodigy -* @param {label} Label to click on -*/ -function clickOnLabel(label){ - document.querySelector("input[type=radio][value=\'"+label+"\']").click() -} - -/** -* Update prodigy.content with all regions from window.wavesurfer.regions.list (thus, all regions that can be seen in the interface) -* Discuss in this issue : -* https://support.prodi.gy/t/weird-interaction-between-window-prodigy-update-and-wavesurfer/5450 -*/ -function updateContent(){ - var regions = window.wavesurfer.regions.list; - var content = []; - for (var id in regions){ - var region = regions[id]; - content.push({start : region.start, end : region.end, label : region.label, id : region.id, color : region.color}); - } - window.prodigy.update({audio_spans : content}); -} - -/** -* Create a beep sound from scratch -* You can adjust the gain, frequency (here its A 440) and duration -*/ -function beep() { - if(BEEP){ - var oscillator = audioCtx.createOscillator(); - var gainNode = audioCtx.createGain(); - - oscillator.connect(gainNode); - gainNode.connect(audioCtx.destination); - - gainNode.gain.value = 0.1; - oscillator.frequency.value = 440; - oscillator.type = "square"; - - oscillator.start(); - - setTimeout( - function() { - oscillator.stop(); - }, - 150 // FIXME: should depend on the value of "precision" - ); - } -} - -/** -* Change CSS style for the selected region -* @param {e} Region object -*/ -function activeRegion(e){ - e.element.style.borderTop = "3px solid"; - e.element.style.borderBottom = "3px solid"; -} - -/** -* @see activeRegion() -* Undo CSS change -* @param {e} Region object -*/ -function deactiveRegion(e){ - e.element.style.borderTop = ""; - e.element.style.borderBottom = ""; -} - -/** -* Update global variables 'regions' and 'ids' with regions in window.wavesurfer.regions.list -* Put the first one as "active" and update the variable currentRegion -*/ -function reloadWave(){ - regions = window.wavesurfer.regions.list; - ids = Object.values(regions); - ids.sort(compare); - if(ids.length > 0){ - currentRegion = 0; - activeRegion(ids[0]); - } -} - -/** -* Switch selected region -* Update var currentRegion -* Place wavesurfer cursor at the beginning of the new region or the beginning of the file if it's a new prodigy task -* @see activeRegion() / deactiveRegion() -* @param {ids} Ids of the region to be selected -*/ -function switchCurrent(newId){ - if(ids.length > 0){ - deactiveRegion(ids[currentRegion]); - currentRegion = newId; - activeRegion(ids[newId]) - if(refresh){ - window.wavesurfer.seekTo(0); - }else{ - var time = (ids[currentRegion].start) / (window.wavesurfer.getDuration()); - window.wavesurfer.seekTo(time); - } - } -} - -/** -* Handle wavesurfer regions -* Add event listener to some wavesurfer event -*/ -function waitForElement(){ - if(typeof window.wavesurfer !== "undefined"){ - reloadWave(); - // Select created region or the first one if it's a new task - window.wavesurfer.on('region-created', function(e){ - setTimeout(function(){ - if(ids.length > 0) deactiveRegion(ids[currentRegion]); - reloadWave(); - if(refresh){ - switchCurrent(0); - }else{ - switchCurrent(ids.indexOf(e)); - } - }, 5); - }); - // Change region label (by remove the old one and create a new one with proper label) - window.wavesurfer.on('region-dblclick',function(e){ - re = window.wavesurfer.addRegion({'start' : e.start,'end' : e.end}); - e.remove(); - window.wavesurfer.fireEvent('region-update-end',re); - }); - // Select region on click - window.wavesurfer.on('region-click',function(e){ - switchCurrent(ids.indexOf(e)); - }); - // Beep when region end - window.wavesurfer.on('region-out',function(e){ - beep(); - }); - // @see updateContent() - window.wavesurfer.on('region-update-end', function(e){ - updateContent(); - }); - // @see updateContent() - // Switch selected region when deleted - window.wavesurfer.on('region-removed',function(e){ - updateContent(); - if(currentRegion == (ids.length - 1)){ - var newId = 0; - }else{ - var newId = currentRegion; - } - reloadWave(); - if(ids.length > 0) switchCurrent(newId); - }); - }else{ - setTimeout(waitForElement, 250); - } -} - -// Check if it's a new prodigy task -document.addEventListener('prodigyanswer', e => { - refresh = true; -}) - -/** -* Keyboard controller -* | Key 1 | Key 2 | Command | -* | ------------- | ------------- | ------------ | -* | Arrows left/right | [W] | Move Cursor [speed up] | -* | Shift | Arrows left/right | Change start of current segment | -* | Control | Arrows left/right | Change end of current segment | -* | Arrows up/down | | Change current segment to the next/precedent one | -* | Shift | Arrows up/[down] | Create [or remove] segment | -* | Backspace | | Remove current segment | -*/ -document.querySelector('#root').onkeydown = document.querySelector('#root').onkeyup = function(e){ - e = e || event; - keysMap[e.key] = e.type == 'keydown'; - var pos = window.wavesurfer.getCurrentTime(); - var audioEnd = window.wavesurfer.getDuration(); - var region = ids[currentRegion]; - refresh = false; - - // If Left is pressed - if(keysMap[left] && !keysMap[right]){ - // If Shift is pressed - if(keysMap[startR] && !keysMap[endR]){ - // Shortens start if possible - if((region.start - PRECISION) <= 0){ - region.update({'start' : 0}); - window.wavesurfer.fireEvent('region-update-end',region); - window.wavesurfer.play(0, region.end); - }else{ - region.update({'start' : region.start - PRECISION }); - window.wavesurfer.fireEvent('region-update-end',region); - window.wavesurfer.play(region.start, region.end); - } - // If Ctrl is pressed - }else if(keysMap[endR] && !keysMap[startR]){ - var startTime = region.end - EXCERPT; - if(startTime < region.start) startTime = region.start; - // Shortens end if possible - if((region.end - PRECISION) > region.start){ - region.update({'end' : region.end - PRECISION }); - window.wavesurfer.fireEvent('region-update-end',region); - window.wavesurfer.play(startTime, region.end); - } - }else{ - // Else change cursor position - // Speed up naviguation if W is pressed - if(keysMap['w']){ - var time = (pos - PRECISION*2) / audioEnd; - }else{ - var time = (pos - PRECISION) / audioEnd; - } - if(time < 0) time = 0; - window.wavesurfer.pause(); - window.wavesurfer.seekTo(time); - } - // If Right is pressed - }else if(keysMap[right] && !keysMap[left]){ - // If Shift is pressed - if(keysMap[startR] && !keysMap[endR]){ - // Extend start if possible - if(region.start + PRECISION < region.end){ - region.update({'start' : region.start + PRECISION }); - window.wavesurfer.fireEvent('region-update-end',region); - window.wavesurfer.play(region.start, region.end); - } - // If Ctrl is pressed - }else if(keysMap[endR] && !keysMap[startR]){ - // Extend end if possible (while keep playing the audio) - if(!window.wavesurfer.isPlaying()){ - var startTime = region.end - EXCERPT; - if(startTime < region.start) startTime = region.start; - }else{ - var startTime = pos; - } - if((region.end + PRECISION) >= audioEnd){ - region.update({'end' : audioEnd }); - window.wavesurfer.fireEvent('region-update-end',region); - }else{ - region.update({'end' : region.end + PRECISION }); - window.wavesurfer.fireEvent('region-update-end',region); - } - window.wavesurfer.play(startTime, region.end); - }else{ - // Else change cursor position - // Speed up naviguation if W is pressed - if(keysMap['w']){ - var time = (pos + PRECISION*2) / audioEnd; - }else{ - var time = (pos + PRECISION) / audioEnd; - } - if(time > 1) time = 1; - window.wavesurfer.pause(); - window.wavesurfer.seekTo(time); - } - // If Up and shift is pressed : new region - }else if (keysMap['ArrowUp'] && keysMap['Shift']){ - var fin = pos + 1; - if(fin > audioEnd) fin = audioEnd; - re = window.wavesurfer.addRegion({'start' : pos,'end' : fin}); - window.wavesurfer.fireEvent('region-update-end',re); - // If Down and Shift or Backspace: delete region - // Check backspace for diarization text field - }else if(keysMap['Backspace'] || (keysMap['ArrowDown'] && keysMap['Shift'])){ - ids[currentRegion].remove(); - // If Up/Down @see switchCurrent - }else if(keysMap['ArrowUp']){ - if(currentRegion == (ids.length - 1)){ - switchCurrent(0); - }else{ - switchCurrent(currentRegion + 1); - } - }else if(keysMap['ArrowDown']){ - if(currentRegion == 0){ - switchCurrent(ids.length - 1); - }else{ - switchCurrent(currentRegion - 1); - } - }else if(keysMap['u']){ - reloadWave(); - } -} diff --git a/pyannote/audio/interactive/common/instructions.html b/pyannote/audio/interactive/common/instructions.html deleted file mode 100644 index 0b75a98c1..000000000 --- a/pyannote/audio/interactive/common/instructions.html +++ /dev/null @@ -1,69 +0,0 @@ - - - -

Commands

- - - You have to mark the speech moments with bounding boxes. -
- -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Key 1Key 2Command
Arrows left/right[W]Move Cursor [speed up]
ShiftArrow left/rightChange start of current segment
ControlArrow left/rightChange end of current segment
Arrows up/downChange current segment to the next/precedent one
ShiftArrow up/[down]Create or [remove] segment
BackspaceRemove current segment
SpacebarPlay/pause audio
UUndo all actions
EscapeIgnore this sample
EnterValidate annotation
- - diff --git a/pyannote/audio/interactive/common/regions.js b/pyannote/audio/interactive/common/regions.js deleted file mode 100644 index c40b15cd1..000000000 --- a/pyannote/audio/interactive/common/regions.js +++ /dev/null @@ -1,1362 +0,0 @@ -/*! - * wavesurfer.js regions plugin 5.2.0 (2021-08-16) - * https://wavesurfer-js.org - * @license BSD-3-Clause - */ -(function webpackUniversalModuleDefinition(root, factory) { - if(typeof exports === 'object' && typeof module === 'object') - module.exports = factory(); - else if(typeof define === 'function' && define.amd) - define("WaveSurfer", [], factory); - else if(typeof exports === 'object') - exports["WaveSurfer"] = factory(); - else - root["WaveSurfer"] = root["WaveSurfer"] || {}, root["WaveSurfer"]["regions"] = factory(); -})(self, function() { -return /******/ (() => { // webpackBootstrap -/******/ "use strict"; -/******/ var __webpack_modules__ = ({ - -/***/ "./src/plugin/regions/index.js": -/*!*************************************!*\ - !*** ./src/plugin/regions/index.js ***! - \*************************************/ -/***/ ((module, exports, __webpack_require__) => { - - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.default = void 0; - -var _region = __webpack_require__(/*! ./region.js */ "./src/plugin/regions/region.js"); - -function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } - -function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -/** - * Regions are visual overlays on waveform that can be used to play and loop - * portions of audio. Regions can be dragged and resized. - * - * Visual customization is possible via CSS (using the selectors - * `.wavesurfer-region` and `.wavesurfer-handle`). - * - * @implements {PluginClass} - * @extends {Observer} - * - * @example - * // es6 - * import RegionsPlugin from 'wavesurfer.regions.js'; - * - * // commonjs - * var RegionsPlugin = require('wavesurfer.regions.js'); - * - * // if you are using