From 4b09aefe4093a681b258626523a1408d754dd90c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sat, 21 Oct 2023 16:11:03 +0200 Subject: [PATCH 01/57] feat(pipeline): add ArtifactHook for saving internal steps (#1511) --- CHANGELOG.md | 169 +++++++++++++------------ pyannote/audio/pipelines/utils/hook.py | 57 +++++++-- 2 files changed, 128 insertions(+), 98 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b9805e758..fcdebb82c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,137 +2,138 @@ ## `develop` branch - - feat(pipeline): add `TimingHook` for profiling processing time - - feat(pipeline): add support for list of hooks with `Hooks` - - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` +- feat(pipeline): add `TimingHook` for profiling processing time +- feat(pipeline): add `ArtifactHook` for saving internal steps +- feat(pipeline): add support for list of hooks with `Hooks` +- BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) +- fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` ## Version 3.0.1 (2023-09-28) - - fix(pipeline): fix WeSpeaker GPU support +- fix(pipeline): fix WeSpeaker GPU support ## Version 3.0.0 (2023-09-26) ### Features and improvements - - feat(pipeline): send pipeline to device with `pipeline.to(device)` - - feat(pipeline): add `return_embeddings` option to `SpeakerDiarization` pipeline - - feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) - - feat(pipeline): add progress hook to pipelines - - feat(task): add [powerset](https://www.isca-speech.org/archive/interspeech_2023/plaquet23_interspeech.html) support to `SpeakerDiarization` task - - feat(task): add support for multi-task models - - feat(task): add support for label scope in speaker diarization task - - feat(task): add support for missing classes in multi-label segmentation task - - feat(model): add segmentation model based on torchaudio self-supervised representation - - feat(pipeline): check version compatibility at load time - - improve(task): load metadata as tensors rather than pyannote.core instances - - improve(task): improve error message on missing specifications +- feat(pipeline): send pipeline to device with `pipeline.to(device)` +- feat(pipeline): add `return_embeddings` option to `SpeakerDiarization` pipeline +- feat(pipeline): make `segmentation_batch_size` and `embedding_batch_size` mutable in `SpeakerDiarization` pipeline (they now default to `1`) +- feat(pipeline): add progress hook to pipelines +- feat(task): add [powerset](https://www.isca-speech.org/archive/interspeech_2023/plaquet23_interspeech.html) support to `SpeakerDiarization` task +- feat(task): add support for multi-task models +- feat(task): add support for label scope in speaker diarization task +- feat(task): add support for missing classes in multi-label segmentation task +- feat(model): add segmentation model based on torchaudio self-supervised representation +- feat(pipeline): check version compatibility at load time +- improve(task): load metadata as tensors rather than pyannote.core instances +- improve(task): improve error message on missing specifications ### Breaking changes - - BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` - - BREAKING(pipeline): pipeline defaults to CPU (use `pipeline.to(device)`) - - BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (use `SpeakerDiarization` pipeline) - - BREAKING(pipeline): remove `segmentation_duration` parameter from `SpeakerDiarization` pipeline (defaults to `duration` of segmentation model) - - BREAKING(task): remove support for variable chunk duration for segmentation tasks - - BREAKING(pipeline): remove support for `FINCHClustering` and `HiddenMarkovModelClustering` - - BREAKING(setup): drop support for Python 3.7 - - BREAKING(io): channels are now 0-indexed (used to be 1-indexed) - - BREAKING(io): multi-channel audio is no longer downmixed to mono by default. - You should update how `pyannote.audio.core.io.Audio` is instantiated: - * replace `Audio()` by `Audio(mono="downmix")`; - * replace `Audio(mono=True)` by `Audio(mono="downmix")`; - * replace `Audio(mono=False)` by `Audio()`. - - BREAKING(model): get rid of (flaky) `Model.introspection` - If, for some weird reason, you wrote some custom code based on that, - you should instead rely on `Model.example_output`. - - BREAKING(interactive): remove support for Prodigy recipes - +- BREAKING(task): rename `Segmentation` task to `SpeakerDiarization` +- BREAKING(pipeline): pipeline defaults to CPU (use `pipeline.to(device)`) +- BREAKING(pipeline): remove `SpeakerSegmentation` pipeline (use `SpeakerDiarization` pipeline) +- BREAKING(pipeline): remove `segmentation_duration` parameter from `SpeakerDiarization` pipeline (defaults to `duration` of segmentation model) +- BREAKING(task): remove support for variable chunk duration for segmentation tasks +- BREAKING(pipeline): remove support for `FINCHClustering` and `HiddenMarkovModelClustering` +- BREAKING(setup): drop support for Python 3.7 +- BREAKING(io): channels are now 0-indexed (used to be 1-indexed) +- BREAKING(io): multi-channel audio is no longer downmixed to mono by default. + You should update how `pyannote.audio.core.io.Audio` is instantiated: + - replace `Audio()` by `Audio(mono="downmix")`; + - replace `Audio(mono=True)` by `Audio(mono="downmix")`; + - replace `Audio(mono=False)` by `Audio()`. +- BREAKING(model): get rid of (flaky) `Model.introspection` + If, for some weird reason, you wrote some custom code based on that, + you should instead rely on `Model.example_output`. +- BREAKING(interactive): remove support for Prodigy recipes ### Fixes and improvements - - fix(pipeline): fix reproducibility issue with Ampere CUDA devices - - fix(pipeline): fix support for IOBase audio - - fix(pipeline): fix corner case with no speaker - - fix(train): prevent metadata preparation to happen twice - - fix(task): fix support for "balance" option - - improve(task): shorten and improve structure of Tensorboard tags +- fix(pipeline): fix reproducibility issue with Ampere CUDA devices +- fix(pipeline): fix support for IOBase audio +- fix(pipeline): fix corner case with no speaker +- fix(train): prevent metadata preparation to happen twice +- fix(task): fix support for "balance" option +- improve(task): shorten and improve structure of Tensorboard tags ### Dependencies update - - setup: switch to torch 2.0+, torchaudio 2.0+, soundfile 0.12+, lightning 2.0+, torchmetrics 0.11+ - - setup: switch to pyannote.core 5.0+, pyannote.database 5.0+, and pyannote.pipeline 3.0+ - - setup: switch to speechbrain 0.5.14+ +- setup: switch to torch 2.0+, torchaudio 2.0+, soundfile 0.12+, lightning 2.0+, torchmetrics 0.11+ +- setup: switch to pyannote.core 5.0+, pyannote.database 5.0+, and pyannote.pipeline 3.0+ +- setup: switch to speechbrain 0.5.14+ ## Version 2.1.1 (2022-10-27) - - BREAKING(pipeline): rewrite speaker diarization pipeline - - feat(pipeline): add option to optimize for DER variant - - feat(clustering): add support for NeMo speaker embedding - - feat(clustering): add FINCH clustering - - feat(clustering): add min_cluster_size hparams to AgglomerativeClustering - - feat(hub): add support for private/gated models - - setup(hub): switch to latest hugginface_hub API - - fix(pipeline): fix support for missing reference in Resegmentation pipeline - - fix(clustering) fix corner case where HMM.fit finds too little states +- BREAKING(pipeline): rewrite speaker diarization pipeline +- feat(pipeline): add option to optimize for DER variant +- feat(clustering): add support for NeMo speaker embedding +- feat(clustering): add FINCH clustering +- feat(clustering): add min_cluster_size hparams to AgglomerativeClustering +- feat(hub): add support for private/gated models +- setup(hub): switch to latest hugginface_hub API +- fix(pipeline): fix support for missing reference in Resegmentation pipeline +- fix(clustering) fix corner case where HMM.fit finds too little states ## Version 2.0.1 (2022-07-20) - - BREAKING: complete rewrite - - feat: much better performance - - feat: Python-first API - - feat: pretrained pipelines (and models) on Huggingface model hub - - feat: multi-GPU training with pytorch-lightning - - feat: data augmentation with torch-audiomentations - - feat: Prodigy recipe for model-assisted audio annotation +- BREAKING: complete rewrite +- feat: much better performance +- feat: Python-first API +- feat: pretrained pipelines (and models) on Huggingface model hub +- feat: multi-GPU training with pytorch-lightning +- feat: data augmentation with torch-audiomentations +- feat: Prodigy recipe for model-assisted audio annotation ## Version 1.1.2 (2021-01-28) - - fix: make sure master branch is used to load pretrained models (#599) +- fix: make sure master branch is used to load pretrained models (#599) ## Version 1.1 (2020-11-08) - - last release before complete rewriting +- last release before complete rewriting ## Version 1.0.1 (2018-07-19) - - fix: fix regression in Precomputed.__call__ (#110, #105) +- fix: fix regression in Precomputed.**call** (#110, #105) ## Version 1.0 (2018-07-03) - - chore: switch from keras to pytorch (with tensorboard support) - - improve: faster & better traning (`AutoLR`, advanced learning rate schedulers, improved batch generators) - - feat: add tunable speaker diarization pipeline (with its own tutorial) - - chore: drop support for Python 2 (use Python 3.6 or later) +- chore: switch from keras to pytorch (with tensorboard support) +- improve: faster & better traning (`AutoLR`, advanced learning rate schedulers, improved batch generators) +- feat: add tunable speaker diarization pipeline (with its own tutorial) +- chore: drop support for Python 2 (use Python 3.6 or later) ## Version 0.3.1 (2017-07-06) - - feat: add python 3 support - - chore: rewrite neural speaker embedding using autograd - - feat: add new embedding architectures - - feat: add new embedding losses - - chore: switch to Keras 2 - - doc: add tutorial for (MFCC) feature extraction - - doc: add tutorial for (LSTM-based) speech activity detection - - doc: add tutorial for (LSTM-based) speaker change detection - - doc: add tutorial for (TristouNet) neural speaker embedding +- feat: add python 3 support +- chore: rewrite neural speaker embedding using autograd +- feat: add new embedding architectures +- feat: add new embedding losses +- chore: switch to Keras 2 +- doc: add tutorial for (MFCC) feature extraction +- doc: add tutorial for (LSTM-based) speech activity detection +- doc: add tutorial for (LSTM-based) speaker change detection +- doc: add tutorial for (TristouNet) neural speaker embedding ## Version 0.2.1 (2017-03-28) - - feat: add LSTM-based speech activity detection - - feat: add LSTM-based speaker change detection - - improve: refactor LSTM-based speaker embedding - - feat: add librosa basic support - - feat: add SMORMS3 optimizer +- feat: add LSTM-based speech activity detection +- feat: add LSTM-based speaker change detection +- improve: refactor LSTM-based speaker embedding +- feat: add librosa basic support +- feat: add SMORMS3 optimizer ## Version 0.1.4 (2016-09-26) - - feat: add 'covariance_type' option to BIC segmentation +- feat: add 'covariance_type' option to BIC segmentation ## Version 0.1.3 (2016-09-23) - - chore: rename sequence generator in preparation of the release of - TristouNet reproducible research package. +- chore: rename sequence generator in preparation of the release of + TristouNet reproducible research package. ## Version 0.1.2 (2016-09-22) - - first public version +- first public version diff --git a/pyannote/audio/pipelines/utils/hook.py b/pyannote/audio/pipelines/utils/hook.py index 86ecf1ec1..fc6e56734 100644 --- a/pyannote/audio/pipelines/utils/hook.py +++ b/pyannote/audio/pipelines/utils/hook.py @@ -33,20 +33,49 @@ ) -def logging_hook( - step_name: Text, - step_artifact: Any, - file: Optional[Mapping] = None, - completed: Optional[int] = None, - total: Optional[int] = None, -): - """Hook to save step_artifact as file[step_name] - - Useful for debugging purposes +class ArtifactHook: + """Hook to save artifacts of each internal step + + Parameters + ---------- + artifacts: list of str, optional + List of steps to save. Defaults to all steps. + file_key: str, optional + Key used to store artifacts in `file`. + Defaults to "artifact". + + Usage + ----- + >>> with ArtifactHook() as hook: + ... output = pipeline(file, hook=hook) + # file["artifact"] contains a dict with artifacts of each step + """ - if completed is None: - file[step_name] = deepcopy(step_artifact) + def __init__(self, *artifacts, file_key: str = "artifact"): + self.artifacts = artifacts + self.file_key = file_key + + def __enter__(self): + return self + + def __exit__(self, *args): + pass + + def __call__( + self, + step_name: Text, + step_artifact: Any, + file: Optional[Mapping] = None, + total: Optional[int] = None, + completed: Optional[int] = None, + ): + if (step_artifact is None) or ( + self.artifacts and step_name not in self.artifacts + ): + return + + file.setdefault(self.file_key, dict())[step_name] = deepcopy(step_artifact) class ProgressHook: @@ -119,7 +148,7 @@ class TimingHook: # file["timing_hook"] contains processing time for each step """ - def __init__(self, file_key: str = "timing_hook"): + def __init__(self, file_key: str = "timing"): self.file_key = file_key def __enter__(self): @@ -164,7 +193,7 @@ class Hooks: Usage ----- - >>> with Hooks(ProgessHook(), TimingHook()) as hook: + >>> with Hooks(ProgessHook(), TimingHook(), ArtifactHook()) as hook: ... output = pipeline("audio.wav", hook=hook) """ From 03f826535995648d5205f5ec22203e2e3006ed61 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sun, 22 Oct 2023 12:04:30 +0200 Subject: [PATCH 02/57] fix: fix of list of Hooks (#1514) --- pyannote/audio/pipelines/utils/hook.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/pipelines/utils/hook.py b/pyannote/audio/pipelines/utils/hook.py index fc6e56734..2a675d1c9 100644 --- a/pyannote/audio/pipelines/utils/hook.py +++ b/pyannote/audio/pipelines/utils/hook.py @@ -212,6 +212,13 @@ def __exit__(self, *args): if hasattr(hook, "__exit__"): hook.__exit__(*args) - def __call__(self, *args: Any, **kwds: Any) -> Any: + def __call__( + self, + step_name: Text, + step_artifact: Any, + file: Optional[Mapping] = None, + total: Optional[int] = None, + completed: Optional[int] = None, + ): for hook in self.hooks: - hook(*args, **kwds) + hook(step_name, step_artifact, file=file, total=total, completed=completed) From 0b45103cb228a81a9d9d776cca92694cb30ddb41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sun, 22 Oct 2023 16:44:32 +0200 Subject: [PATCH 03/57] feat(utils): add "soft" option to Powerset.to_multilabel conversion (#1516) --- CHANGELOG.md | 1 + pyannote/audio/utils/powerset.py | 22 ++++++++++++++-------- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fcdebb82c..c63e65bea 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ - feat(pipeline): add support for list of hooks with `Hooks` - BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` +- feat(utils): add `"soft"` option to `Powerset.to_multilabel` ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index 0f5cfb5bc..810519829 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -84,26 +84,32 @@ def build_cardinality(self) -> torch.Tensor: powerset_k += 1 return cardinality - def to_multilabel(self, powerset: torch.Tensor) -> torch.Tensor: - """Convert predictions from (soft) powerset to (hard) multi-label + def to_multilabel(self, powerset: torch.Tensor, soft: bool = False) -> torch.Tensor: + """Convert predictions from powerset to multi-label Parameter --------- powerset : (batch_size, num_frames, num_powerset_classes) torch.Tensor Soft predictions in "powerset" space. + soft : bool, optional + Return soft multi-label predictions. Defaults to False (i.e. hard predictions) + Assumes that `powerset` are "logits" (not "probabilities"). Returns ------- multi_label : (batch_size, num_frames, num_classes) torch.Tensor - Hard predictions in "multi-label" space. + Predictions in "multi-label" space. """ - hard_powerset = torch.nn.functional.one_hot( - torch.argmax(powerset, dim=-1), - self.num_powerset_classes, - ).float() + if soft: + powerset_probs = torch.exp(powerset) + else: + powerset_probs = torch.nn.functional.one_hot( + torch.argmax(powerset, dim=-1), + self.num_powerset_classes, + ).float() - return torch.matmul(hard_powerset, self.mapping) + return torch.matmul(powerset_probs, self.mapping) def forward(self, powerset: torch.Tensor) -> torch.Tensor: """Alias for `to_multilabel`""" From 40fa67b1ead65d08963b9cfd85541cd833c072ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 7 Nov 2023 09:38:45 +0100 Subject: [PATCH 04/57] fix(pipeline): compute fbank on selected device (#1529) --- CHANGELOG.md | 1 + pyannote/audio/pipelines/speaker_verification.py | 7 ++++--- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c63e65bea..f52704595 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ - BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - feat(utils): add `"soft"` option to `Powerset.to_multilabel` +- improve(pipeline): compute `fbank` on GPU when requested ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 6b39679dd..8a36fc70c 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -556,6 +556,7 @@ def compute_fbank( for waveform in waveforms ] ) + return features - torch.mean(features, dim=1, keepdim=True) def __call__( @@ -578,12 +579,12 @@ def __call__( batch_size, num_channels, num_samples = waveforms.shape assert num_channels == 1 - features = self.compute_fbank(waveforms) + features = self.compute_fbank(waveforms.to(self.device)) _, num_frames, _ = features.shape if masks is None: embeddings = self.session_.run( - output_names=["embs"], input_feed={"feats": features.numpy()} + output_names=["embs"], input_feed={"feats": features.numpy(force=True)} )[0] return embeddings @@ -606,7 +607,7 @@ def __call__( embeddings[f] = self.session_.run( output_names=["embs"], - input_feed={"feats": masked_feature.numpy()[None]}, + input_feed={"feats": masked_feature.numpy(force=True)[None]}, )[0][0] return embeddings From 0e1a726ad2141bc6c4cc9672a2899ac2bb73fe73 Mon Sep 17 00:00:00 2001 From: Olivier <22832930+olvb@users.noreply.github.com> Date: Tue, 7 Nov 2023 12:02:41 +0100 Subject: [PATCH 05/57] fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Olivier Birot Co-authored-by: Hervé BREDIN --- CHANGELOG.md | 1 + pyannote/audio/pipelines/clustering.py | 3 ++- tests/test_clustering.py | 29 ++++++++++++++++++++++++++ 3 files changed, 32 insertions(+), 1 deletion(-) create mode 100644 tests/test_clustering.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f52704595..cb025c0bd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - feat(utils): add `"soft"` option to `Powerset.to_multilabel` - improve(pipeline): compute `fbank` on GPU when requested +- fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index a779016cb..c51cdcc50 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -386,7 +386,8 @@ def cluster( elif num_large_clusters > max_clusters: num_clusters = max_clusters - if num_clusters is not None: + # look for perfect candidate if necessary + if num_clusters is not None and num_large_clusters != num_clusters: # switch stopping criterion from "inter-cluster distance" stopping to "iteration index" _dendrogram = np.copy(dendrogram) _dendrogram[:, 2] = np.arange(num_embeddings - 1) diff --git a/tests/test_clustering.py b/tests/test_clustering.py new file mode 100644 index 000000000..535da47de --- /dev/null +++ b/tests/test_clustering.py @@ -0,0 +1,29 @@ +import numpy as np + +from pyannote.audio.pipelines.clustering import AgglomerativeClustering + + +def test_agglomerative_clustering_num_cluster(): + """ + Make sure AgglomerativeClustering doesn't "over-merge" clusters when initial + clustering already matches target num_clusters, cf + https://github.com/pyannote/pyannote-audio/issues/1525 + """ + + # 2 embeddings different enough + embeddings = np.array([[1.0, 1.0, 1.0, 1.0], [1.0, 2.0, 1.0, 2.0]]) + + # clustering with params that should yield 1 cluster per embedding + clustering = AgglomerativeClustering().instantiate( + { + "method": "centroid", + "min_cluster_size": 0, + "threshold": 0.0, + } + ) + + # request 2 clusters + clusters = clustering.cluster( + embeddings=embeddings, min_clusters=2, max_clusters=2, num_clusters=2 + ) + assert np.array_equal(clusters, np.array([0, 1])) From fb1c5c4bce604ecc2cf383f6669d13f1058c21c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 10 Nov 2023 15:58:52 +0100 Subject: [PATCH 06/57] improve: add support for "soft" option in Powerset.forward --- pyannote/audio/utils/powerset.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index 810519829..b75221e48 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -111,9 +111,9 @@ def to_multilabel(self, powerset: torch.Tensor, soft: bool = False) -> torch.Ten return torch.matmul(powerset_probs, self.mapping) - def forward(self, powerset: torch.Tensor) -> torch.Tensor: + def forward(self, powerset: torch.Tensor, soft: bool = False) -> torch.Tensor: """Alias for `to_multilabel`""" - return self.to_multilabel(powerset) + return self.to_multilabel(powerset, soft=soft) def to_powerset(self, multilabel: torch.Tensor) -> torch.Tensor: """Convert (hard) predictions from multi-label to powerset From e0544b8ce16481001beac195275de55e4525521a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 10 Nov 2023 16:00:27 +0100 Subject: [PATCH 07/57] feat: use strings for track identifiers --- pyannote/audio/pipelines/utils/diarization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/pipelines/utils/diarization.py b/pyannote/audio/pipelines/utils/diarization.py index f494c6073..91413350b 100644 --- a/pyannote/audio/pipelines/utils/diarization.py +++ b/pyannote/audio/pipelines/utils/diarization.py @@ -197,7 +197,7 @@ def to_annotation( min_duration_off=min_duration_off, ) - return binarize(discrete_diarization) + return binarize(discrete_diarization).rename_tracks(generator="string") @staticmethod def to_diarization( From 2787f123cc408dfc6a43fbf437d725fd93b7c537 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 13 Nov 2023 17:12:32 +0100 Subject: [PATCH 08/57] BREAKING(setup): prepare for getting rid of ONNX runtime (#1541) --- CHANGELOG.md | 3 +++ pyannote/audio/pipelines/speaker_verification.py | 16 +++++++++++----- requirements.txt | 1 - 3 files changed, 14 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cb025c0bd..8cd56ad36 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,9 @@ - feat(utils): add `"soft"` option to `Powerset.to_multilabel` - improve(pipeline): compute `fbank` on GPU when requested - fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided +- BREAKING(pipeline): rename `WeSpeakerPretrainedSpeakerEmbedding` to `ONNXWeSpeakerPretrainedSpeakerEmbedding` +- BREAKING(setup): remove `onnxruntime` dependency. + You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 8a36fc70c..9f10f6e51 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -386,7 +386,7 @@ def __call__( return embeddings -class WeSpeakerPretrainedSpeakerEmbedding(BaseInference): +class ONNXWeSpeakerPretrainedSpeakerEmbedding(BaseInference): """Pretrained WeSpeaker speaker embedding Parameters @@ -398,7 +398,7 @@ class WeSpeakerPretrainedSpeakerEmbedding(BaseInference): Usage ----- - >>> get_embedding = WeSpeakerPretrainedSpeakerEmbedding("hbredin/wespeaker-voxceleb-resnet34-LM") + >>> get_embedding = ONNXWeSpeakerPretrainedSpeakerEmbedding("hbredin/wespeaker-voxceleb-resnet34-LM") >>> assert waveforms.ndim == 3 >>> batch_size, num_channels, num_samples = waveforms.shape >>> assert num_channels == 1 @@ -418,7 +418,7 @@ def __init__( ): if not ONNX_IS_AVAILABLE: raise ImportError( - f"'onnxruntime' must be installed to use '{embedding}' embeddings. " + f"'onnxruntime' must be installed to use '{embedding}' embeddings." ) super().__init__() @@ -745,7 +745,12 @@ def PretrainedSpeakerEmbedding( >>> embeddings = get_embedding(waveforms, masks=masks) """ - if isinstance(embedding, str) and "speechbrain" in embedding: + if isinstance(embedding, str) and "pyannote" in embedding: + return PyannoteAudioPretrainedSpeakerEmbedding( + embedding, device=device, use_auth_token=use_auth_token + ) + + elif isinstance(embedding, str) and "speechbrain" in embedding: return SpeechBrainPretrainedSpeakerEmbedding( embedding, device=device, use_auth_token=use_auth_token ) @@ -754,9 +759,10 @@ def PretrainedSpeakerEmbedding( return NeMoPretrainedSpeakerEmbedding(embedding, device=device) elif isinstance(embedding, str) and "wespeaker" in embedding: - return WeSpeakerPretrainedSpeakerEmbedding(embedding, device=device) + return ONNXWeSpeakerPretrainedSpeakerEmbedding(embedding, device=device) else: + # fallback to pyannote in case we are loading a local model return PyannoteAudioPretrainedSpeakerEmbedding( embedding, device=device, use_auth_token=use_auth_token ) diff --git a/requirements.txt b/requirements.txt index 7829ada37..7e71fe024 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,7 +3,6 @@ einops >=0.6.0 huggingface_hub >= 0.13.0 lightning >= 2.0.1 omegaconf >=2.1,<3.0 -onnxruntime-gpu >= 1.16.0 pyannote.core >= 5.0.0 pyannote.database >= 5.0.1 pyannote.metrics >= 3.2 From 884913e1ac838af7d1451e5def997878c91ea46f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Tue, 14 Nov 2023 10:33:56 +0100 Subject: [PATCH 09/57] feat(model): add support for multi-speaker statistics pooling (#1386) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Hervé BREDIN --- CHANGELOG.md | 1 + pyannote/audio/models/blocks/pooling.py | 109 ++++++++++++++------ tests/test_stats_pool.py | 131 ++++++++++++++++++++++++ 3 files changed, 209 insertions(+), 32 deletions(-) create mode 100644 tests/test_stats_pool.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 8cd56ad36..3c8a4d8ff 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ - BREAKING(pipeline): rename `WeSpeakerPretrainedSpeakerEmbedding` to `ONNXWeSpeakerPretrainedSpeakerEmbedding` - BREAKING(setup): remove `onnxruntime` dependency. You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. +- feat(model): add support for multi-speaker statistics pooling ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/models/blocks/pooling.py b/pyannote/audio/models/blocks/pooling.py index debb05d13..b02f6f69e 100644 --- a/pyannote/audio/models/blocks/pooling.py +++ b/pyannote/audio/models/blocks/pooling.py @@ -1,6 +1,6 @@ # MIT License # -# Copyright (c) 2020 CNRS +# Copyright (c) 2020- CNRS # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal @@ -26,6 +26,7 @@ import torch import torch.nn as nn import torch.nn.functional as F +from einops import rearrange class StatsPool(nn.Module): @@ -40,49 +41,93 @@ class StatsPool(nn.Module): """ - def forward( - self, sequences: torch.Tensor, weights: Optional[torch.Tensor] = None - ) -> torch.Tensor: - """Forward pass + def _pool(self, sequences: torch.Tensor, weights: torch.Tensor) -> torch.Tensor: + """Helper function to compute statistics pooling + + Assumes that weights are already interpolated to match the number of frames + in sequences and that they encode the activation of only one speaker. Parameters ---------- - sequences : (batch, channel, frames) torch.Tensor - Sequences. - weights : (batch, frames) torch.Tensor, optional - When provided, compute weighted mean and standard deviation. + sequences : (batch, features, frames) torch.Tensor + Sequences of features. + weights : (batch, frames) torch.Tensor + (Already interpolated) weights. Returns ------- - output : (batch, 2 * channel) torch.Tensor + output : (batch, 2 * features) torch.Tensor Concatenation of mean and (unbiased) standard deviation. """ - if weights is None: - mean = sequences.mean(dim=2) - std = sequences.std(dim=2, unbiased=True) + weights = weights.unsqueeze(dim=1) + # (batch, 1, frames) - else: - weights = weights.unsqueeze(dim=1) - # (batch, 1, frames) + v1 = weights.sum(dim=2) + 1e-8 + mean = torch.sum(sequences * weights, dim=2) / v1 + + dx2 = torch.square(sequences - mean.unsqueeze(2)) + v2 = torch.square(weights).sum(dim=2) + + var = torch.sum(dx2 * weights, dim=2) / (v1 - v2 / v1) + std = torch.sqrt(var) + + return torch.cat([mean, std], dim=1) + + def forward( + self, sequences: torch.Tensor, weights: Optional[torch.Tensor] = None + ) -> torch.Tensor: + """Forward pass - num_frames = sequences.shape[2] - num_weights = weights.shape[2] - if num_frames != num_weights: - warnings.warn( - f"Mismatch between frames ({num_frames}) and weights ({num_weights}) numbers." - ) - weights = F.interpolate( - weights, size=num_frames, mode="linear", align_corners=False - ) + Parameters + ---------- + sequences : (batch, features, frames) torch.Tensor + Sequences of features. + weights : (batch, frames) or (batch, speakers, frames) torch.Tensor, optional + Compute weighted mean and standard deviation, using provided `weights`. - v1 = weights.sum(dim=2) - mean = torch.sum(sequences * weights, dim=2) / v1 + Note + ---- + `sequences` and `weights` might use a different number of frames, in which case `weights` + are interpolated linearly to reach the number of frames in `sequences`. - dx2 = torch.square(sequences - mean.unsqueeze(2)) - v2 = torch.square(weights).sum(dim=2) + Returns + ------- + output : (batch, 2 * features) or (batch, speakers, 2 * features) torch.Tensor + Concatenation of mean and (unbiased) standard deviation. When `weights` are + provided with the `speakers` dimension, `output` is computed for each speaker + separately and returned as (batch, speakers, 2 * channel)-shaped tensor. + """ - var = torch.sum(dx2 * weights, dim=2) / (v1 - v2 / v1) - std = torch.sqrt(var) + if weights is None: + mean = sequences.mean(dim=-1) + std = sequences.std(dim=-1, correction=1) + return torch.cat([mean, std], dim=-1) - return torch.cat([mean, std], dim=1) + if weights.dim() == 2: + has_speaker_dimension = False + weights = weights.unsqueeze(dim=1) + # (batch, frames) -> (batch, 1, frames) + else: + has_speaker_dimension = True + + # interpolate weights if needed + _, _, num_frames = sequences.shape + _, _, num_weights = weights.shape + if num_frames != num_weights: + warnings.warn( + f"Mismatch between frames ({num_frames}) and weights ({num_weights}) numbers." + ) + weights = F.interpolate( + weights, size=num_frames, mode="linear", align_corners=False + ) + + output = rearrange( + torch.vmap(self._pool, in_dims=(None, 1))(sequences, weights), + "speakers batch features -> batch speakers features", + ) + + if not has_speaker_dimension: + return output.squeeze(dim=1) + + return output diff --git a/tests/test_stats_pool.py b/tests/test_stats_pool.py new file mode 100644 index 000000000..e30262eda --- /dev/null +++ b/tests/test_stats_pool.py @@ -0,0 +1,131 @@ +# MIT License +# +# Copyright (c) 2023- CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import torch + +from pyannote.audio.models.blocks.pooling import StatsPool + + +def test_stats_pool_weightless(): + x = torch.Tensor([[[2.0, 4.0], [2.0, 4.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + stats_pool = StatsPool() + + y = stats_pool(x) + # (batch = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor([[3.0, 3.0, 1.4142, 1.4142], [1.0, 1.0, 0.0, 0.0]]), + ) + + +def test_stats_pool_one_speaker(): + x = torch.Tensor([[[2.0, 4.0], [2.0, 4.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + w = torch.Tensor( + [ + [0.5, 0.01], + [0.2, 0.1], + ] + ) + # (batch = 2, frames = 2) + + stats_pool = StatsPool() + + y = stats_pool(x, weights=w) + # (batch = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor([[2.0392, 2.0392, 1.4142, 1.4142], [1.0, 1.0, 0.0, 0.0]]), + ) + + +def test_stats_pool_multi_speaker(): + x = torch.Tensor([[[2.0, 4.0], [2.0, 4.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + w = torch.Tensor([[[0.1, 0.2], [0.2, 0.3]], [[0.001, 0.001], [0.2, 0.3]]]) + # (batch = 2, speakers = 2, frames = 2) + + stats_pool = StatsPool() + + y = stats_pool(x, weights=w) + # (batch = 2, speakers = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor( + [ + [[3.3333, 3.3333, 1.4142, 1.4142], [3.2, 3.2, 1.4142, 1.4142]], + [[1.0, 1.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.0]], + ] + ), + ) + + +def test_stats_pool_frame_mismatch(): + x = torch.Tensor([[[2.0, 2.0], [2.0, 2.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + stats_pool = StatsPool() + w = torch.Tensor( + [ + [0.5, 0.5, 0.0], + [0.0, 0.5, 0.5], + ] + ) + # (batch = 2, frames = 3) + + y = stats_pool(x, weights=w) + # (batch = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor([[2.0, 2.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.0]]), + ) + + +def test_stats_pool_all_zero_weights(): + x = torch.Tensor([[[2.0, 4.0], [2.0, 4.0]], [[1.0, 1.0], [1.0, 1.0]]]) + # (batch = 2, features = 2, frames = 2) + + w = torch.Tensor( + [ + [0.5, 0.01], + [0.0, 0.0], # all zero weights + ] + ) + # (batch = 2, frames = 2) + + stats_pool = StatsPool() + + y = stats_pool(x, weights=w) + # (batch = 2, features = 4) + + assert torch.equal( + torch.round(y, decimals=4), + torch.Tensor([[2.0392, 2.0392, 1.4142, 1.4142], [0.0, 0.0, 0.0, 0.0]]), + ) From 15b847acfbb4d80ee6262f1814eba97fd2e8f47f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 15 Nov 2023 16:23:40 +0100 Subject: [PATCH 10/57] fix(model): fix pooling layer (#1546) * fix(mps): fix support for MPS * fix: fix (unlikely but possible) division by zero --- pyannote/audio/models/blocks/pooling.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/pyannote/audio/models/blocks/pooling.py b/pyannote/audio/models/blocks/pooling.py index b02f6f69e..22d736a03 100644 --- a/pyannote/audio/models/blocks/pooling.py +++ b/pyannote/audio/models/blocks/pooling.py @@ -69,7 +69,7 @@ def _pool(self, sequences: torch.Tensor, weights: torch.Tensor) -> torch.Tensor: dx2 = torch.square(sequences - mean.unsqueeze(2)) v2 = torch.square(weights).sum(dim=2) - var = torch.sum(dx2 * weights, dim=2) / (v1 - v2 / v1) + var = torch.sum(dx2 * weights, dim=2) / (v1 - v2 / v1 + 1e-8) std = torch.sqrt(var) return torch.cat([mean, std], dim=1) @@ -118,9 +118,7 @@ def forward( warnings.warn( f"Mismatch between frames ({num_frames}) and weights ({num_weights}) numbers." ) - weights = F.interpolate( - weights, size=num_frames, mode="linear", align_corners=False - ) + weights = F.interpolate(weights, size=num_frames, mode="nearest") output = rearrange( torch.vmap(self._pool, in_dims=(None, 1))(sequences, weights), From 343ce66d674c5a1d970bbaf4fc6177ad936c7d82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 09:22:45 +0100 Subject: [PATCH 11/57] feat(model): add WeSpeaker embedding wrapper based on pytorch (#1540) --- CHANGELOG.md | 1 + pyannote/audio/models/embedding/__init__.py | 15 +- .../embedding/wespeaker/LICENSE.WeSpeaker | 21 ++ .../models/embedding/wespeaker/__init__.py | 236 ++++++++++++++ .../models/embedding/wespeaker/convert.py | 62 ++++ .../models/embedding/wespeaker/resnet.py | 302 ++++++++++++++++++ .../audio/pipelines/speaker_verification.py | 2 +- 7 files changed, 637 insertions(+), 2 deletions(-) create mode 100644 pyannote/audio/models/embedding/wespeaker/LICENSE.WeSpeaker create mode 100644 pyannote/audio/models/embedding/wespeaker/__init__.py create mode 100644 pyannote/audio/models/embedding/wespeaker/convert.py create mode 100644 pyannote/audio/models/embedding/wespeaker/resnet.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c8a4d8ff..2dff9c969 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ ## `develop` branch +- feat(pipeline): add WeSpeaker embedding wrapper - feat(pipeline): add `TimingHook` for profiling processing time - feat(pipeline): add `ArtifactHook` for saving internal steps - feat(pipeline): add support for list of hooks with `Hooks` diff --git a/pyannote/audio/models/embedding/__init__.py b/pyannote/audio/models/embedding/__init__.py index 08f8a576c..2819096c2 100644 --- a/pyannote/audio/models/embedding/__init__.py +++ b/pyannote/audio/models/embedding/__init__.py @@ -21,6 +21,19 @@ # SOFTWARE. +from .wespeaker import ( + WeSpeakerResNet34, + WeSpeakerResNet152, + WeSpeakerResNet221, + WeSpeakerResNet293, +) from .xvector import XVectorMFCC, XVectorSincNet -__all__ = ["XVectorSincNet", "XVectorMFCC"] +__all__ = [ + "XVectorSincNet", + "XVectorMFCC", + "WeSpeakerResNet34", + "WeSpeakerResNet152", + "WeSpeakerResNet221", + "WeSpeakerResNet293", +] diff --git a/pyannote/audio/models/embedding/wespeaker/LICENSE.WeSpeaker b/pyannote/audio/models/embedding/wespeaker/LICENSE.WeSpeaker new file mode 100644 index 000000000..136492006 --- /dev/null +++ b/pyannote/audio/models/embedding/wespeaker/LICENSE.WeSpeaker @@ -0,0 +1,21 @@ +Copyright (c) 2021 Shuai Wang (wsstriving@gmail.com) +2022 Zhengyang Chen (chenzhengyang117@gmail.com) +2023 Bing Han (hanbing97@sjtu.edu.cn) + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +File `resnet.py` has been borrowed from WeSpeaker that is available under the Apache License, Version 2.0. + +The original file is available at https://github.com/wenet-e2e/wespeaker/blob/c20d765295359e681321625fbefc1a02e8794163/wespeaker/models/resnet.py + +Neither Shuai Wang (@wsstriving on Github) nor myself (Hervé Bredin, or @hbredin on Github) are lawyers, but we both agreed that putting this license file in this directory is enough to comply with the license. See https://github.com/pyannote/pyannote-audio/issues/1537#issuecomment-1808029836. If you know better about this potential MIT/Apache 2.0 compatibility issue, please let us know. diff --git a/pyannote/audio/models/embedding/wespeaker/__init__.py b/pyannote/audio/models/embedding/wespeaker/__init__.py new file mode 100644 index 000000000..603a88c64 --- /dev/null +++ b/pyannote/audio/models/embedding/wespeaker/__init__.py @@ -0,0 +1,236 @@ +# MIT License +# +# Copyright (c) 2023 CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +from functools import partial +from typing import Optional + +import torch +import torchaudio.compliance.kaldi as kaldi + +from pyannote.audio.core.model import Model +from pyannote.audio.core.task import Task + +from .resnet import ResNet34, ResNet152, ResNet221, ResNet293 + + +class BaseWeSpeakerResNet(Model): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__(sample_rate=sample_rate, num_channels=num_channels, task=task) + + self.save_hyperparameters( + "sample_rate", + "num_channels", + "num_mel_bins", + "frame_length", + "frame_shift", + "dither", + "window_type", + "use_energy", + ) + + self._fbank = partial( + kaldi.fbank, + num_mel_bins=self.hparams.num_mel_bins, + frame_length=self.hparams.frame_length, + frame_shift=self.hparams.frame_shift, + dither=self.hparams.dither, + sample_frequency=self.hparams.sample_rate, + window_type=self.hparams.window_type, + use_energy=self.hparams.use_energy, + ) + + def compute_fbank(self, waveforms: torch.Tensor) -> torch.Tensor: + """Extract fbank features + + Parameters + ---------- + waveforms : (batch_size, num_channels, num_samples) + + Returns + ------- + fbank : (batch_size, num_frames, num_mel_bins) + + Source: https://github.com/wenet-e2e/wespeaker/blob/45941e7cba2c3ea99e232d02bedf617fc71b0dad/wespeaker/bin/infer_onnx.py#L30C1-L50 + """ + + waveforms = waveforms * (1 << 15) + + # fall back to CPU for FFT computation when using MPS + # until FFT is fixed in MPS + device = waveforms.device + fft_device = torch.device("cpu") if device.type == "mps" else device + + features = torch.vmap(self._fbank)(waveforms.to(fft_device)).to(device) + + return features - torch.mean(features, dim=1, keepdim=True) + + def forward( + self, waveforms: torch.Tensor, weights: torch.Tensor = None + ) -> torch.Tensor: + """ + + Parameters + ---------- + waveforms : torch.Tensor + Batch of waveforms with shape (batch, channel, sample) + weights : torch.Tensor, optional + Batch of weights with shape (batch, frame). + """ + + fbank = self.compute_fbank(waveforms) + return self.resnet(fbank, weights=weights)[1] + + +class WeSpeakerResNet34(BaseWeSpeakerResNet): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__( + sample_rate=sample_rate, + num_channels=num_channels, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + window_type=window_type, + use_energy=use_energy, + task=task, + ) + self.resnet = ResNet34( + num_mel_bins, 256, pooling_func="TSTP", two_emb_layer=False + ) + + +class WeSpeakerResNet152(BaseWeSpeakerResNet): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__( + sample_rate=sample_rate, + num_channels=num_channels, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + window_type=window_type, + use_energy=use_energy, + task=task, + ) + self.resnet = ResNet152( + num_mel_bins, 256, pooling_func="TSTP", two_emb_layer=False + ) + + +class WeSpeakerResNet221(BaseWeSpeakerResNet): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__( + sample_rate=sample_rate, + num_channels=num_channels, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + window_type=window_type, + use_energy=use_energy, + task=task, + ) + self.resnet = ResNet221( + num_mel_bins, 256, pooling_func="TSTP", two_emb_layer=False + ) + + +class WeSpeakerResNet293(BaseWeSpeakerResNet): + def __init__( + self, + sample_rate: int = 16000, + num_channels: int = 1, + num_mel_bins: int = 80, + frame_length: int = 25, + frame_shift: int = 10, + dither: float = 0.0, + window_type: str = "hamming", + use_energy: bool = False, + task: Optional[Task] = None, + ): + super().__init__( + sample_rate=sample_rate, + num_channels=num_channels, + num_mel_bins=num_mel_bins, + frame_length=frame_length, + frame_shift=frame_shift, + dither=dither, + window_type=window_type, + use_energy=use_energy, + task=task, + ) + self.resnet = ResNet293( + num_mel_bins, 256, pooling_func="TSTP", two_emb_layer=False + ) + + +__all__ = [ + "WeSpeakerResNet34", + "WeSpeakerResNet152", + "WeSpeakerResNet221", + "WeSpeakerResNet293", +] diff --git a/pyannote/audio/models/embedding/wespeaker/convert.py b/pyannote/audio/models/embedding/wespeaker/convert.py new file mode 100644 index 000000000..34aec6092 --- /dev/null +++ b/pyannote/audio/models/embedding/wespeaker/convert.py @@ -0,0 +1,62 @@ +# MIT License +# +# Copyright (c) 2023 CNRS +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# Script used to convert from WeSpeaker to pyannote.audio + +import sys +from pathlib import Path + +import pytorch_lightning as pl +import torch + +import pyannote.audio.models.embedding.wespeaker as wespeaker +from pyannote.audio import Model +from pyannote.audio.core.task import Problem, Resolution, Specifications + +wespeaker_checkpoint_dir = sys.argv[1] # /path/to/wespeaker_cnceleb-resnet34-LM + +wespeaker_checkpoint = Path(wespeaker_checkpoint_dir) / "wespeaker.pt" + +depth = Path(wespeaker_checkpoint_dir).parts[-1].split("-")[-2][6:] # '34' +Klass = getattr(wespeaker, f"WeSpeakerResNet{depth}") # WeSpeakerResNet34 + +duration = 5.0 # whatever +specifications = Specifications( + problem=Problem.REPRESENTATION, resolution=Resolution.CHUNK, duration=duration +) + +state_dict = torch.load(wespeaker_checkpoint, map_location=torch.device("cpu")) +state_dict.pop("projection.weight") + +model = Klass() +model.resnet.load_state_dict(state_dict, strict=True) +model.specifications = specifications + +checkpoint = {"state_dict": model.state_dict()} +model.on_save_checkpoint(checkpoint) +checkpoint["pytorch-lightning_version"] = pl.__version__ + +pyannote_checkpoint = Path(wespeaker_checkpoint_dir) / "pytorch_model.bin" +torch.save(checkpoint, pyannote_checkpoint) + +model = Model.from_pretrained(pyannote_checkpoint) +print(model) diff --git a/pyannote/audio/models/embedding/wespeaker/resnet.py b/pyannote/audio/models/embedding/wespeaker/resnet.py new file mode 100644 index 000000000..54f95fa8b --- /dev/null +++ b/pyannote/audio/models/embedding/wespeaker/resnet.py @@ -0,0 +1,302 @@ +# Copyright (c) 2021 Shuai Wang (wsstriving@gmail.com) +# 2022 Zhengyang Chen (chenzhengyang117@gmail.com) +# 2023 Bing Han (hanbing97@sjtu.edu.cn) +# 2023 CNRS +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from einops import rearrange + +from pyannote.audio.models.blocks.pooling import StatsPool + + +class TSTP(nn.Module): + """ + Temporal statistics pooling, concatenate mean and std, which is used in + x-vector + Comment: simple concatenation can not make full use of both statistics + """ + + def __init__(self, in_dim=0, **kwargs): + super(TSTP, self).__init__() + self.in_dim = in_dim + self.stats_pool = StatsPool() + + def forward(self, features, weights: torch.Tensor = None): + """ + + Parameters + ---------- + features : (batch, dimension, channel, frames) torch.Tensor + Batch of features + weights: (batch, frames) torch.Tensor, optional + Batch of weights + + """ + + features = rearrange( + features, + "batch dimension channel frames -> batch (dimension channel) frames", + ) + + return self.stats_pool(features, weights=weights) + + # # The last dimension is the temporal axis + # pooling_mean = features.mean(dim=-1) + # pooling_std = torch.sqrt(torch.var(features, dim=-1) + 1e-7) + # pooling_mean = pooling_mean.flatten(start_dim=1) + # pooling_std = pooling_std.flatten(start_dim=1) + # stats = torch.cat((pooling_mean, pooling_std), 1) + # return stats + + def get_out_dim(self): + self.out_dim = self.in_dim * 2 + return self.out_dim + + +POOLING_LAYERS = {"TSTP": TSTP} + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, in_planes, planes, stride=1): + super(BasicBlock, self).__init__() + self.conv1 = nn.Conv2d( + in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False + ) + self.bn1 = nn.BatchNorm2d(planes) + self.conv2 = nn.Conv2d( + planes, planes, kernel_size=3, stride=1, padding=1, bias=False + ) + self.bn2 = nn.BatchNorm2d(planes) + + self.shortcut = nn.Sequential() + if stride != 1 or in_planes != self.expansion * planes: + self.shortcut = nn.Sequential( + nn.Conv2d( + in_planes, + self.expansion * planes, + kernel_size=1, + stride=stride, + bias=False, + ), + nn.BatchNorm2d(self.expansion * planes), + ) + + def forward(self, x): + out = F.relu(self.bn1(self.conv1(x))) + out = self.bn2(self.conv2(out)) + out += self.shortcut(x) + out = F.relu(out) + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, in_planes, planes, stride=1): + super(Bottleneck, self).__init__() + self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.conv2 = nn.Conv2d( + planes, planes, kernel_size=3, stride=stride, padding=1, bias=False + ) + self.bn2 = nn.BatchNorm2d(planes) + self.conv3 = nn.Conv2d( + planes, self.expansion * planes, kernel_size=1, bias=False + ) + self.bn3 = nn.BatchNorm2d(self.expansion * planes) + + self.shortcut = nn.Sequential() + if stride != 1 or in_planes != self.expansion * planes: + self.shortcut = nn.Sequential( + nn.Conv2d( + in_planes, + self.expansion * planes, + kernel_size=1, + stride=stride, + bias=False, + ), + nn.BatchNorm2d(self.expansion * planes), + ) + + def forward(self, x): + out = F.relu(self.bn1(self.conv1(x))) + out = F.relu(self.bn2(self.conv2(out))) + out = self.bn3(self.conv3(out)) + out += self.shortcut(x) + out = F.relu(out) + return out + + +class ResNet(nn.Module): + def __init__( + self, + block, + num_blocks, + m_channels=32, + feat_dim=40, + embed_dim=128, + pooling_func="TSTP", + two_emb_layer=True, + ): + super(ResNet, self).__init__() + self.in_planes = m_channels + self.feat_dim = feat_dim + self.embed_dim = embed_dim + self.stats_dim = int(feat_dim / 8) * m_channels * 8 + self.two_emb_layer = two_emb_layer + + self.conv1 = nn.Conv2d( + 1, m_channels, kernel_size=3, stride=1, padding=1, bias=False + ) + self.bn1 = nn.BatchNorm2d(m_channels) + self.layer1 = self._make_layer(block, m_channels, num_blocks[0], stride=1) + self.layer2 = self._make_layer(block, m_channels * 2, num_blocks[1], stride=2) + self.layer3 = self._make_layer(block, m_channels * 4, num_blocks[2], stride=2) + self.layer4 = self._make_layer(block, m_channels * 8, num_blocks[3], stride=2) + + self.pool = POOLING_LAYERS[pooling_func]( + in_dim=self.stats_dim * block.expansion + ) + self.pool_out_dim = self.pool.get_out_dim() + self.seg_1 = nn.Linear(self.pool_out_dim, embed_dim) + if self.two_emb_layer: + self.seg_bn_1 = nn.BatchNorm1d(embed_dim, affine=False) + self.seg_2 = nn.Linear(embed_dim, embed_dim) + else: + self.seg_bn_1 = nn.Identity() + self.seg_2 = nn.Identity() + + def _make_layer(self, block, planes, num_blocks, stride): + strides = [stride] + [1] * (num_blocks - 1) + layers = [] + for stride in strides: + layers.append(block(self.in_planes, planes, stride)) + self.in_planes = planes * block.expansion + return nn.Sequential(*layers) + + def forward(self, x: torch.Tensor, weights: torch.Tensor = None): + """ + + Parameters + ---------- + x : (batch, frames, features) torch.Tensor + Batch of features + weights : (batch, frames) torch.Tensor, optional + Batch of weights + + Returns + ------- + embedding : (batch, embedding_dim) torch.Tensor + """ + x = x.permute(0, 2, 1) # (B,T,F) => (B,F,T) + + x = x.unsqueeze_(1) + out = F.relu(self.bn1(self.conv1(x))) + out = self.layer1(out) + out = self.layer2(out) + out = self.layer3(out) + out = self.layer4(out) + + stats = self.pool(out, weights=weights) + + embed_a = self.seg_1(stats) + if self.two_emb_layer: + out = F.relu(embed_a) + out = self.seg_bn_1(out) + embed_b = self.seg_2(out) + return embed_a, embed_b + else: + return torch.tensor(0.0), embed_a + + +def ResNet18(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + BasicBlock, + [2, 2, 2, 2], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet34(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + BasicBlock, + [3, 4, 6, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet50(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [3, 4, 6, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet101(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [3, 4, 23, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet152(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [3, 8, 36, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet221(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [6, 16, 48, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) + + +def ResNet293(feat_dim, embed_dim, pooling_func="TSTP", two_emb_layer=True): + return ResNet( + Bottleneck, + [10, 20, 64, 3], + feat_dim=feat_dim, + embed_dim=embed_dim, + pooling_func=pooling_func, + two_emb_layer=two_emb_layer, + ) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index 9f10f6e51..c870ea622 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -687,7 +687,7 @@ def min_num_samples(self) -> int: try: _ = self.model_(torch.randn(1, 1, middle).to(self.device)) upper = middle - except RuntimeError: + except Exception: lower = middle middle = (lower + upper) // 2 From 6ad2f87015d6cfe660a098233ff2f72bbdc5cd84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 09:37:10 +0100 Subject: [PATCH 12/57] doc: update changelog (#1549) --- CHANGELOG.md | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2dff9c969..e506c0413 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,19 +2,30 @@ ## `develop` branch -- feat(pipeline): add WeSpeaker embedding wrapper +### New features + +- feat(model): add WeSpeaker embedding wrapper based on PyTorch +- feat(model): add support for multi-speaker statistics pooling - feat(pipeline): add `TimingHook` for profiling processing time - feat(pipeline): add `ArtifactHook` for saving internal steps - feat(pipeline): add support for list of hooks with `Hooks` -- BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) -- fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - feat(utils): add `"soft"` option to `Powerset.to_multilabel` -- improve(pipeline): compute `fbank` on GPU when requested + +### Fixes + +- fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided + +## Improvements + +- improve(pipeline): compute `fbank` on GPU when requested + +### Breaking changes + - BREAKING(pipeline): rename `WeSpeakerPretrainedSpeakerEmbedding` to `ONNXWeSpeakerPretrainedSpeakerEmbedding` - BREAKING(setup): remove `onnxruntime` dependency. You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. -- feat(model): add support for multi-speaker statistics pooling +- BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) ## Version 3.0.1 (2023-09-28) From 23001a75cf6b465d1d824b5a0bd96ffe32ba5bbc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 10:22:43 +0100 Subject: [PATCH 13/57] doc: fix typo in changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e506c0413..6feac98ae 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,7 +16,7 @@ - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided -## Improvements +### Improvements - improve(pipeline): compute `fbank` on GPU when requested From bbc804401ead3fe4819ccb1ee820fabbbd35404c Mon Sep 17 00:00:00 2001 From: Dmitrii Mukhutdinov Date: Thu, 16 Nov 2023 18:29:41 +0800 Subject: [PATCH 14/57] fix(pipeline): fix frame-wise speaker count exceeding max_speakers * fix(pipeline): fix frame-wise speaker count exceeding max_speakers or detected num_speakers in SpeakerDiarization pipeline * BREAKING(pipeline): remove onset and offset parameter in SpeakerDiarizationMixin.speaker_count --- CHANGELOG.md | 3 + pyannote/audio/pipelines/clustering.py | 1 - pyannote/audio/pipelines/resegmentation.py | 11 +++- .../audio/pipelines/speaker_diarization.py | 65 +++++++++++++------ pyannote/audio/pipelines/utils/diarization.py | 18 ++--- 5 files changed, 62 insertions(+), 36 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6feac98ae..19e25f36e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,7 @@ - fix(pipeline): add missing "embedding" hook call in `SpeakerDiarization` - fix(pipeline): fix `AgglomerativeClustering` to honor `num_clusters` when provided +- fix(pipeline): fix frame-wise speaker count exceeding `max_speakers` or detected `num_speakers` in `SpeakerDiarization` pipeline ### Improvements @@ -26,6 +27,8 @@ - BREAKING(setup): remove `onnxruntime` dependency. You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. - BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) +- BREAKING(pipeline): remove `onset` and `offset` parameter in `SpeakerDiarizationMixin.speaker_count` + You should now binarize segmentations before passing them to `speaker_count` ## Version 3.0.1 (2023-09-28) diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index c51cdcc50..b63ab214f 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -253,7 +253,6 @@ def __call__( hard_clusters = np.zeros((num_chunks, num_speakers), dtype=np.int8) soft_clusters = np.ones((num_chunks, num_speakers, 1)) centroids = np.mean(train_embeddings, axis=0, keepdims=True) - return hard_clusters, soft_clusters, centroids train_clusters = self.cluster( diff --git a/pyannote/audio/pipelines/resegmentation.py b/pyannote/audio/pipelines/resegmentation.py index bb71abf22..d01e5d65f 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -39,6 +39,7 @@ get_model, ) from pyannote.audio.utils.permutation import mae_cost_func, permutate +from pyannote.audio.utils.signal import binarize class Resegmentation(SpeakerDiarizationMixin, Pipeline): @@ -181,11 +182,17 @@ def apply( hook("segmentation", segmentations) - # estimate frame-level number of instantaneous speakers - count = self.speaker_count( + # binarize segmentations before speaker counting + binarized_segmentations: SlidingWindowFeature = binarize( segmentations, onset=self.onset, offset=self.offset, + initial_state=False, + ) + + # estimate frame-level number of instantaneous speakers + count = self.speaker_count( + binarized_segmentations, warm_up=(self.warm_up, self.warm_up), frames=self._frames, ) diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index d5cf04e05..354f6be7e 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -25,6 +25,8 @@ import functools import itertools import math +import textwrap +import warnings from typing import Callable, Optional, Text, Union import numpy as np @@ -478,12 +480,19 @@ def apply( hook("segmentation", segmentations) # shape: (num_chunks, num_frames, local_num_speakers) + # binarize segmentation + if self._segmentation.model.specifications.powerset: + binarized_segmentations = segmentations + else: + binarized_segmentations: SlidingWindowFeature = binarize( + segmentations, + onset=self.segmentation.threshold, + initial_state=False, + ) + # estimate frame-level number of instantaneous speakers count = self.speaker_count( - segmentations, - onset=0.5 - if self._segmentation.model.specifications.powerset - else self.segmentation.threshold, + binarized_segmentations, frames=self._frames, warm_up=(0.0, 0.0), ) @@ -499,16 +508,6 @@ def apply( return diarization - # binarize segmentation - if self._segmentation.model.specifications.powerset: - binarized_segmentations = segmentations - else: - binarized_segmentations: SlidingWindowFeature = binarize( - segmentations, - onset=self.segmentation.threshold, - initial_state=False, - ) - if self.klustering == "OracleClustering" and not return_embeddings: embeddings = None else: @@ -533,6 +532,27 @@ def apply( # hard_clusters: (num_chunks, num_speakers) # centroids: (num_speakers, dimension) + # number of detected clusters is the number of different speakers + num_different_speakers = np.max(hard_clusters) + 1 + + # detected number of speakers can still be out of bounds + # (specifically, lower than `min_speakers`), since there could be too few embeddings + # to make enough clusters with a given minimum cluster size. + if num_different_speakers < min_speakers or num_different_speakers > max_speakers: + warnings.warn(textwrap.dedent( + f""" + The detected number of speakers ({num_different_speakers}) is outside + the given bounds [{min_speakers}, {max_speakers}]. This can happen if the + given audio file is too short to contain {min_speakers} or more speakers. + Try to lower the desired minimal number of speakers. + """ + )) + + # during counting, we could possibly overcount the number of instantaneous + # speakers due to segmentation errors, so we cap the maximum instantaneous number + # of speakers by the `max_speakers` value + count.data = np.minimum(count.data, max_speakers).astype(np.int8) + # reconstruct discrete diarization from raw hard clusters # keep track of inactive speakers @@ -588,6 +608,18 @@ def apply( if not return_embeddings: return diarization + # this can happen when we use OracleClustering + if centroids is None: + return diarization, None + + # The number of centroids may be smaller than the number of speakers + # in the annotation. This can happen if the number of active speakers + # obtained from `speaker_count` for some frames is larger than the number + # of clusters obtained from `clustering`. In this case, we append zero embeddings + # for extra speakers + if len(diarization.labels()) > centroids.shape[0]: + centroids = np.pad(centroids, ((0, len(diarization.labels()) - centroids.shape[0]), (0, 0))) + # re-order centroids so that they match # the order given by diarization.labels() inverse_mapping = {label: index for index, label in mapping.items()} @@ -595,11 +627,6 @@ def apply( [inverse_mapping[label] for label in diarization.labels()] ] - # FIXME: the number of centroids may be smaller than the number of speakers - # in the annotation. This can happen if the number of active speakers - # obtained from `speaker_count` for some frames is larger than the number - # of clusters obtained from `clustering`. Will be fixed in the future - return diarization, centroids def get_metric(self) -> GreedyDiarizationErrorRate: diff --git a/pyannote/audio/pipelines/utils/diarization.py b/pyannote/audio/pipelines/utils/diarization.py index 91413350b..4a35f7049 100644 --- a/pyannote/audio/pipelines/utils/diarization.py +++ b/pyannote/audio/pipelines/utils/diarization.py @@ -117,13 +117,10 @@ def optimal_mapping( else: return mapped_hypothesis - # TODO: get rid of onset/offset (binarization should be applied before calling speaker_count) # TODO: get rid of warm-up parameter (trimming should be applied before calling speaker_count) @staticmethod def speaker_count( - segmentations: SlidingWindowFeature, - onset: float = 0.5, - offset: float = None, + binarized_segmentations: SlidingWindowFeature, warm_up: Tuple[float, float] = (0.1, 0.1), frames: SlidingWindow = None, ) -> SlidingWindowFeature: @@ -131,12 +128,8 @@ def speaker_count( Parameters ---------- - segmentations : SlidingWindowFeature - (num_chunks, num_frames, num_classes)-shaped scores. - onset : float, optional - Onset threshold. Defaults to 0.5 - offset : float, optional - Offset threshold. Defaults to `onset`. + binarized_segmentations : SlidingWindowFeature + (num_chunks, num_frames, num_classes)-shaped binarized scores. warm_up : (float, float) tuple, optional Left/right warm up ratio of chunk duration. Defaults to (0.1, 0.1), i.e. 10% on both sides. @@ -151,10 +144,7 @@ def speaker_count( (num_frames, 1)-shaped instantaneous speaker count """ - binarized: SlidingWindowFeature = binarize( - segmentations, onset=onset, offset=offset, initial_state=False - ) - trimmed = Inference.trim(binarized, warm_up=warm_up) + trimmed = Inference.trim(binarized_segmentations, warm_up=warm_up) count = Inference.aggregate( np.sum(trimmed, axis=-1, keepdims=True), frames=frames, From 3403b7a9a36fef836e3fa0fc934590a9ea4a1570 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 12:57:12 +0100 Subject: [PATCH 15/57] improve(cli): store top 10 checkpoints rather than top 1 --- pyannote/audio/cli/train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index 9ab8b1658..74041554b 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -115,7 +115,7 @@ def configure_optimizers(self): checkpoint = ModelCheckpoint( monitor=monitor, mode=direction, - save_top_k=None if monitor is None else 1, + save_top_k=None if monitor is None else 10, every_n_epochs=1, save_last=True, save_weights_only=False, From ffd5b816caf272b7fce599f1b59ca09762b70b20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 13:24:08 +0100 Subject: [PATCH 16/57] doc: update changelog --- CHANGELOG.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 19e25f36e..346d8ad26 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ ## `develop` branch +## Version 3.1.0 (2023-11-16) + +### TL;DR + +[`pyannote/speaker-diarization-3.1`](https://hf.co/pyannote/speaker-diarization-3.1) no longer requires [unpopular](https://github.com/pyannote/pyannote-audio/issues/1537) ONNX runtime + ### New features - feat(model): add WeSpeaker embedding wrapper based on PyTorch @@ -27,7 +33,7 @@ - BREAKING(setup): remove `onnxruntime` dependency. You can still use ONNX `hbredin/wespeaker-voxceleb-resnet34-LM` but you will have to install `onnxruntime` yourself. - BREAKING(pipeline): remove `logging_hook` (use `ArtifactHook` instead) -- BREAKING(pipeline): remove `onset` and `offset` parameter in `SpeakerDiarizationMixin.speaker_count` +- BREAKING(pipeline): remove `onset` and `offset` parameter in `SpeakerDiarizationMixin.speaker_count` You should now binarize segmentations before passing them to `speaker_count` ## Version 3.0.1 (2023-09-28) From eecc634df83c5c273b4aa0723e8e467efa1e7765 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 13:24:41 +0100 Subject: [PATCH 17/57] setup: bump version --- version.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.txt b/version.txt index cb2b00e4f..fd2a01863 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -3.0.1 +3.1.0 From 7d80ec4cc450105e7388bf3816b204d3597d3e48 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 13:33:15 +0100 Subject: [PATCH 18/57] doc: update README for 3.1 --- README.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index d63cd26f8..939bb30ea 100644 --- a/README.md +++ b/README.md @@ -12,16 +12,16 @@ Make the most of it thanks to our [consulting services](https://herve.niderb.fr/ ## TL;DR -1. Install [`pyannote.audio`](https://github.com/pyannote/pyannote-audio) `3.0` with `pip install pyannote.audio` +1. Install [`pyannote.audio`](https://github.com/pyannote/pyannote-audio) `3.1` with `pip install pyannote.audio` 2. Accept [`pyannote/segmentation-3.0`](https://hf.co/pyannote/segmentation-3.0) user conditions -3. Accept [`pyannote/speaker-diarization-3.0`](https://hf.co/pyannote/speaker-diarization-3.0) user conditions +3. Accept [`pyannote/speaker-diarization-3.1`](https://hf.co/pyannote/speaker-diarization-3.1) user conditions 4. Create access token at [`hf.co/settings/tokens`](https://hf.co/settings/tokens). ```python from pyannote.audio import Pipeline pipeline = Pipeline.from_pretrained( - "pyannote/speaker-diarization-3.0", + "pyannote/speaker-diarization-3.1", use_auth_token="HUGGINGFACE_ACCESS_TOKEN_GOES_HERE") # send pipeline to GPU (when available) @@ -77,18 +77,18 @@ for turn, _, speaker in diarization.itertracks(yield_label=True): ## Benchmark -Out of the box, `pyannote.audio` speaker diarization [pipeline](https://hf.co/pyannote/speaker-diarization-3.0) v3.0 is expected to be much better (and faster) than v2.x. +Out of the box, `pyannote.audio` speaker diarization [pipeline](https://hf.co/pyannote/speaker-diarization-3.1) v3.1 is expected to be much better (and faster) than v2.x. Those numbers are diarization error rates (in %): -| Dataset \ Version | v1.1 | v2.0 | [v2.1](https://hf.co/pyannote/speaker-diarization-2.1) | [v3.0](https://hf.co/pyannote/speaker-diarization-3.0) | Premium | +| Dataset \ Version | v1.1 | v2.0 | [v2.1](https://hf.co/pyannote/speaker-diarization-2.1) | [v3.1](https://hf.co/pyannote/speaker-diarization-3.1) | Premium | | ---------------------- | ---- | ---- | ------ | ------ | --------- | -| AISHELL-4 | - | 14.6 | 14.1 | 12.3 | 12.3 | -| AliMeeting (channel 1) | - | - | 27.4 | 24.3 | 19.4 | -| AMI (IHM) | 29.7 | 18.2 | 18.9 | 19.0 | 16.7 | -| AMI (SDM) | - | 29.0 | 27.1 | 22.2 | 20.1 | -| AVA-AVD | - | - | - | 49.1 | 42.7 | +| AISHELL-4 | - | 14.6 | 14.1 | 12.2 | 12.3 | +| AliMeeting (channel 1) | - | - | 27.4 | 24.4 | 19.4 | +| AMI (IHM) | 29.7 | 18.2 | 18.9 | 18.8 | 16.7 | +| AMI (SDM) | - | 29.0 | 27.1 | 22.4 | 20.1 | +| AVA-AVD | - | - | - | 50.0 | 42.7 | | DIHARD 3 (full) | 29.2 | 21.0 | 26.9 | 21.7 | 17.0 | -| MSDWild | - | - | - | 24.6 | 20.4 | +| MSDWild | - | - | - | 25.3 | 20.4 | | REPERE (phase2) | - | 12.6 | 8.2 | 7.8 | 7.8 | | VoxConverse (v0.3) | 21.5 | 12.6 | 11.2 | 11.3 | 9.5 | From 8b975bb5575121d034e12e94405625df69eefb97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 13:44:18 +0100 Subject: [PATCH 19/57] doc: remove v2.0 from benchmark --- README.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 939bb30ea..b7621210e 100644 --- a/README.md +++ b/README.md @@ -80,17 +80,17 @@ for turn, _, speaker in diarization.itertracks(yield_label=True): Out of the box, `pyannote.audio` speaker diarization [pipeline](https://hf.co/pyannote/speaker-diarization-3.1) v3.1 is expected to be much better (and faster) than v2.x. Those numbers are diarization error rates (in %): -| Dataset \ Version | v1.1 | v2.0 | [v2.1](https://hf.co/pyannote/speaker-diarization-2.1) | [v3.1](https://hf.co/pyannote/speaker-diarization-3.1) | Premium | -| ---------------------- | ---- | ---- | ------ | ------ | --------- | -| AISHELL-4 | - | 14.6 | 14.1 | 12.2 | 12.3 | -| AliMeeting (channel 1) | - | - | 27.4 | 24.4 | 19.4 | -| AMI (IHM) | 29.7 | 18.2 | 18.9 | 18.8 | 16.7 | -| AMI (SDM) | - | 29.0 | 27.1 | 22.4 | 20.1 | -| AVA-AVD | - | - | - | 50.0 | 42.7 | -| DIHARD 3 (full) | 29.2 | 21.0 | 26.9 | 21.7 | 17.0 | -| MSDWild | - | - | - | 25.3 | 20.4 | -| REPERE (phase2) | - | 12.6 | 8.2 | 7.8 | 7.8 | -| VoxConverse (v0.3) | 21.5 | 12.6 | 11.2 | 11.3 | 9.5 | +| Dataset \ Version | v1.1 | [v2.1](https://hf.co/pyannote/speaker-diarization-2.1) | [v3.1](https://hf.co/pyannote/speaker-diarization-3.1) | Premium | +| ---------------------- | ---- | ----- | ------ | --------- | +| AISHELL-4 | - | 14.1 | 12.2 | 12.3 | +| AliMeeting (channel 1) | - | 27.4 | 24.4 | 19.4 | +| AMI (IHM) | 29.7 | 18.9 | 18.8 | 16.7 | +| AMI (SDM) | - | 27.1 | 22.4 | 20.1 | +| AVA-AVD | - | - | 50.0 | 42.7 | +| DIHARD 3 (full) | 29.2 | 26.9 | 21.7 | 17.0 | +| MSDWild | - | - | 25.3 | 20.4 | +| REPERE (phase2) | - | 8.2 | 7.8 | 7.8 | +| VoxConverse (v0.3) | 21.5 | 11.2 | 11.3 | 9.5 | ## Citations From 036060567dfa935801036f26f90d3484038a4d58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 20:42:12 +0100 Subject: [PATCH 20/57] doc: update intro tutorial to 3.1 --- tutorials/intro.ipynb | 4829 +++++++++-------------------------------- 1 file changed, 1002 insertions(+), 3827 deletions(-) diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index 75344267a..2df5081c3 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -1,3888 +1,1063 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "9-KmdPlBYnp6" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "1Fs2d8otYnp7" - }, - "source": [ - "[`pyannote.audio`](https://github.com/pyannote/pyannote-audio) is an open-source toolkit written in Python for **speaker diarization**. \n", - "\n", - "Based on [`PyTorch`](https://pytorch.org) machine learning framework, it provides a set of trainable end-to-end neural building blocks that can be combined and jointly optimized to build speaker diarization pipelines. \n", - "\n", - "`pyannote.audio` also comes with pretrained [models](https://huggingface.co/models?other=pyannote-audio-model) and [pipelines](https://huggingface.co/models?other=pyannote-audio-pipeline) covering a wide range of domains for voice activity detection, speaker segmentation, overlapped speech detection, speaker embedding reaching state-of-the-art performance for most of them. \n", - "\n", - "**This notebook will teach you how to apply those pretrained pipelines on your own data.**\n", - "\n", - "Make sure you run it using a GPU (or it might otherwise be slow...)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "tckHJKZnYnp7" - }, - "source": [ - "## Installation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ai082p4HYnp7", - "outputId": "bb673846-8b58-4743-cea2-6c6270632d7f" - }, - "outputs": [], - "source": [ - "!pip install -qq pyannote.audio==3.0.1\n", - "!pip install -qq ipython==7.34.0" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "qggK-7VBYnp8" - }, - "source": [ - "# Visualization with `pyannote.core`\n", - "\n", - "For the purpose of this notebook, we will download and use an audio file coming from the [AMI corpus](http://groups.inf.ed.ac.uk/ami/corpus/), which contains a conversation between 4 people in a meeting room." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "uJWoQiJgYnp8" - }, - "outputs": [], - "source": [ - "!wget -q http://groups.inf.ed.ac.uk/ami/AMICorpusMirror/amicorpus/ES2004a/audio/ES2004a.Mix-Headset.wav\n", - "DEMO_FILE = {'uri': 'ES2004a.Mix-Headset', 'audio': 'ES2004a.Mix-Headset.wav'}" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "EPIapoCJYnp8" - }, - "source": [ - "Because AMI is a benchmarking dataset, it comes with manual annotations (a.k.a *groundtruth*). \n", - "Let us load and visualize the expected output of the speaker diarization pipeline.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "Mmm0Q22JYnp8" - }, - "outputs": [], - "source": [ - "!wget -q https://raw.githubusercontent.com/pyannote/AMI-diarization-setup/main/only_words/rttms/test/ES2004a.rttm" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 233 - }, - "id": "ToqCwl_FYnp9", - "outputId": "a1d9631f-b198-44d1-ff6d-ec304125a9f4" - }, - "outputs": [ + "cells": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# load groundtruth\n", - "from pyannote.database.util import load_rttm\n", - "_, groundtruth = load_rttm('ES2004a.rttm').popitem()\n", - "\n", - "# visualize groundtruth\n", - "groundtruth" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "p_R9T9Y5Ynp9" - }, - "source": [ - "For the rest of this notebook, we will only listen to and visualize a one-minute long excerpt of the file (but will process the whole file anyway)." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 230 }, - "id": "bAHza4Y1Ynp-", - "outputId": "c4cc2369-bfe4-4ac2-bb71-37602e7c7a8a" - }, - "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": { + "id": "9-KmdPlBYnp6" + }, + "source": [ + "\"Open" ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.core import Segment, notebook\n", - "# make notebook visualization zoom on 600s < t < 660s time range\n", - "EXCERPT = Segment(600, 660)\n", - "notebook.crop = EXCERPT\n", - "\n", - "# visualize excerpt groundtruth\n", - "groundtruth" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "L3FQXT5FYnp-" - }, - "source": [ - "This nice visualization is brought to you by [`pyannote.core`](http://pyannote.github.io/pyannote-core/) and basically indicates when each speaker speaks. " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 62 }, - "id": "rDhZ3bXEYnp-", - "outputId": "a82efe4e-2f9c-48bd-94fb-c62af3a3cb43" - }, - "outputs": [ { - "data": { - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" + "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...)" ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.audio import Audio \n", - "from IPython.display import Audio as IPythonAudio\n", - "waveform, sr = Audio(mono=\"downmix\").crop(DEMO_FILE, EXCERPT)\n", - "IPythonAudio(waveform.flatten(), rate=sr)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hkzox7QIYnp_" - }, - "source": [ - "# Processing your own audio file (optional)\n", - "\n", - "In case you just want to go ahead with the demo file, skip this section entirely.\n", - "\n", - "In case you want to try processing your own audio file, proceed with running this section. It will offer you to upload an audio file (preferably a `wav` file but all formats supported by [`SoundFile`](https://pysoundfile.readthedocs.io/en/latest/) should work just fine)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3hmFmLzFYnp_" - }, - "source": [ - "## Upload audio file" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "xC05jFO_Ynp_", - "outputId": "c5502632-56ae-4adb-8bdc-112deedc8893" - }, - "outputs": [], - "source": [ - "import google.colab\n", - "own_file, _ = google.colab.files.upload().popitem()\n", - "OWN_FILE = {'audio': own_file}\n", - "notebook.reset()\n", - "\n", - "# load audio waveform and play it\n", - "waveform, sample_rate = Audio(mono=\"downmix\")(OWN_FILE)\n", - "IPythonAudio(data=waveform.squeeze(), rate=sample_rate, autoplay=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ctw4nLaPYnp_" - }, - "source": [ - "Simply replace `DEMO_FILE` by `OWN_FILE` in the rest of the notebook.\n", - "\n", - "Note, however, that unless you provide a groundtruth annotation in the next cell, you will (obviously) not be able to visualize groundtruth annotation nor evaluate the performance of the diarization pipeline quantitatively" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "x9AQgDzFYnp_" - }, - "source": [ - "## Upload groundtruth (optional)\n", - "\n", - "The groundtruth file is expected to use the RTTM format, with one line per speech turn with the following convention:\n", - "\n", - "```\n", - "SPEAKER {file_name} 1 {start_time} {duration} {speaker_name} \n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "iZaFudpDYnp_", - "outputId": "981274fa-e654-4091-c838-91c81f921e5d" - }, - "outputs": [ + }, { - "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": [ - "" + "cell_type": "markdown", + "metadata": { + "id": "tckHJKZnYnp7" + }, + "source": [ + "## Installation" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saving sample.rttm to sample.rttm\n" - ] + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ai082p4HYnp7" + }, + "outputs": [], + "source": [ + "!pip install -qq pyannote.audio==3.1.0\n", + "!pip install -qq ipython==7.34.0" + ] }, { - "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==", - "text/plain": [ - "" + "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." ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "groundtruth_rttm, _ = google.colab.files.upload().popitem()\n", - "groundtruths = load_rttm(groundtruth_rttm)\n", - "if OWN_FILE['audio'] in groundtruths:\n", - " groundtruth = groundtruths[OWN_FILE['audio']]\n", - "else:\n", - " _, groundtruth = groundtruths.popitem()\n", - "groundtruth" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "5MclWK2GYnp_" - }, - "source": [ - "# Speaker diarization with `pyannote.pipeline`\n", - "\n", - "We are about to run a full speaker diarization pipeline, that includes speaker segmentation, speaker embedding, and a final clustering step. **Brace yourself!**\n", - "\n", - "To load the speaker diarization pipeline, \n", - "\n", - "* accept the user conditions on [hf.co/pyannote/speaker-diarization-3.0](https://hf.co/pyannote/speaker-diarization-3.0)\n", - "* accept the user conditions on [hf.co/pyannote/segmentation-3.0](https://hf.co/pyannote/segmentation-3.0)\n", - "* login using `notebook_login` below" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 301, - "referenced_widgets": [ - "c8731777ce834e58a76a295076200cfc", - "859b12a6d95b4c6f987791ca848122b9", - "94756148d2e94a93ae233baba20af683", - "ba18cded436e486da34882d821d8f1eb", - "99898e6ee64a46bd832af112e79b58b7", - "79184c8c2a6f4b7493bb7f6983f18a09", - "ea95ffd922c0455d957120f034e541f8", - "13525aa369a9410a83343952ab511f3c", - "b2be65e192384c948fb8987d4cfca505", - "333b42ca7aa44788b1c22724eb11bcc3", - "0e382d66f09f4958a40baa7ab83c4ccb", - "6a45ce374e2e47ba9457d02e02522748", - "765485a1d3f941d28b79782dcffbf401", - "3499ef4dd9f243d9bef00b396e78ed69" - ] }, - "id": "r5u7VMb-YnqB", - "outputId": "c714a997-d4f8-417a-e5ad-0a4924333859" - }, - "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6e56329c30c0441c8d45df3975e75a76", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "uJWoQiJgYnp8" }, - "text/plain": [ - "VBox(children=(HTML(value='
" + "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" ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "diarization" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "DLhErS6wYnqB" - }, - "source": [ - "# Evaluation with `pyannote.metrics`\n", - "\n", - "Because groundtruth is available, we can evaluate the quality of the diarization pipeline by computing the [diarization error rate](http://pyannote.github.io/pyannote-metrics/reference.html#diarization)." - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": { - "id": "vNHQRTUIYnqB" - }, - "outputs": [], - "source": [ - "from pyannote.metrics.diarization import DiarizationErrorRate\n", - "metric = DiarizationErrorRate()\n", - "der = metric(groundtruth, diarization)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" }, - "id": "9d0vKQ0fYnqB", - "outputId": "9a664753-cd84-4211-9153-d33e929bb252" - }, - "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "diarization error rate = 19.8%\n" - ] - } - ], - "source": [ - "print(f'diarization error rate = {100 * der:.1f}%')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Xz5QJV9nYnqB" - }, - "source": [ - "This implementation of diarization error rate is brought to you by [`pyannote.metrics`](http://pyannote.github.io/pyannote-metrics/).\n", - "\n", - "It can also be used to improve visualization by find the optimal one-to-one mapping between groundtruth and hypothesized speakers." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 230 + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Mmm0Q22JYnp8" + }, + "outputs": [], + "source": [ + "!wget -q https://raw.githubusercontent.com/pyannote/AMI-diarization-setup/main/only_words/rttms/test/ES2004a.rttm" + ] }, - "id": "xMLf4mrYYnqB", - "outputId": "ed08bcc8-24c6-439c-a244-3a673ff480b0" - }, - "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + }, + "id": "ToqCwl_FYnp9", + "outputId": "a1d9631f-b198-44d1-ff6d-ec304125a9f4" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# load groundtruth\n", + "from pyannote.database.util import load_rttm\n", + "_, groundtruth = load_rttm('ES2004a.rttm').popitem()\n", + "\n", + "# visualize groundtruth\n", + "groundtruth" ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mapping = metric.optimal_mapping(groundtruth, diarization)\n", - "diarization.rename_labels(mapping=mapping)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 230 }, - "id": "Z0ewsLlQYnqB", - "outputId": "8a8cd040-ee1d-48f7-d4be-eef9e08e9e55" - }, - "outputs": [ { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABjwAAADyCAYAAAD5q2z1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAl9UlEQVR4nO3de3RV5Z0//k8gEEJIjpAYAnJzitzECpWZqnTVajtKRwutq/WCIkjrZU3VTlupdrqsOi67rFOko1ZbrTq9UGnroF+trbd6RSq2CK1WRlFBRblowBAEApL9+4OfZ4xccjsnJzu8XmtlLbL3s5/97PPs8znn8M7ZuyhJkiQAAAAAAABSrFuhBwAAAAAAANBeAg8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2Bx27MmDEjioqKdvl56aWX9rhu0qRJ2e2HDRu22zZXXXVVts1rr70Wn/vc56KsrCyqqqriggsuiG3btmXXb926NWbMmBGHHHJIFBcXx+c///ldxrlgwYKYOHFiVFZWRmlpaYwaNSrmzJmT18cm7dIytxERDQ0N8Z3vfCeGDh0aJSUl8ZGPfCRuvfXWvD02aff+/J177rm7rPvXf/3XKCoqihkzZjRp21nm+n1PPvlkFBcXx7hx49r1WHR1uZ7riIiFCxfGv/zLv0Tfvn2jV69eccghh8Ts2bNjx44dTdpt2LAhpk2bFplMJjKZTEybNi3eeeedJm2+9rWvxWGHHRYlJSW7ncuVK1fudkz33Xdfux4XAAAAgH1dcSF2uuHdbc03yqG+ZT1bvc2kSZPitttua7Js//333+O6kpKSJr//x3/8R5x11llNlpWXl0dExI4dO+L444+P/fffPxYsWBC1tbUxffr0SJIkrrvuumyb0tLSuOCCC+J//ud/djvGsrKyOO+88+KjH/1olJWVxYIFC+Kcc86JsrKyOPvss1t9zLlQ11DXYfvKlGTatF0a5jYi4qSTToq1a9fGLbfcEsOHD49169bFe++916Zjbq8tdVs7dH+lmV5t2m7w4MExb968mDNnTpSWlkbEztDh9ttvjyFDhjRp25nmOiKirq4uzjjjjPj0pz8da9eubf3B58iO2toO3V/3yso2bZfLub7zzjvjpJNOijPPPDMeeeSR2G+//eKhhx6Kb33rW/HUU0/Fb37zmygqKoqIiKlTp8aqVauy4cTZZ58d06ZNi3vuuSfbX5IkMXPmzFi0aFH87W9/2+MxPPTQQ3HwwQdnf+/Xr1+bHgsAAAAAdipI4PHZqx/p0P09dflxrd6mpKQkampqWr3ufeXl5Xts88ADD8Tzzz8fr7/+egwcODAiImbPnh0zZsyIK6+8MioqKqKsrCxuvPHGiNj5V98f/gviiIjx48fH+PHjs78PGzYs5s+fH0888UTBAo9pf5jaYfu6+/P3tmm7NMztfffdF4899li88sor2f8EHTZsWAuPMPd+fsYdHbq/c/7f6W3a7mMf+1i88sorMX/+/DjttNMiImL+/PkxePDg+Id/+IcmbTvLXL/vnHPOialTp0b37t3jrrvuauER596aj47r0P0d8MbrbdouV3P97rvvxllnnRWTJ0+Om266Kbv8K1/5SvTv3z8mT54cv/nNb+Lkk0+OZcuWxX333RdPPfVUfPzjH4+IiJtvvjmOOOKIeOGFF2LkyJEREXHttddGRMRbb72118CjsrKy2XMQAAAAgJZzSasC+NOf/hRjx47N/idpRMRxxx0XDQ0NsXjx4jb3u2TJkli4cGEcddRRuRgmbZCrub377rtjwoQJcfXVV8cBBxwQI0aMiAsvvDC2bNmSj2F3KWeeeWaTv+a/9dZbY+bMmTnfTy6fx7fddlu8/PLLcemll+Z6mF1aLub6gQceiNra2rjwwgt3Wfe5z30uRowYEbfffntE7JzzTCaTDTsiIg4//PDIZDKxcOHCVo9/8uTJUV1dHRMnTow77ujYUBEAAACgKxJ47MHvfve76NOnT/bnS1/60h7X9enTJ6644oom21900UW7tHn00UcjImLNmjXRv3//Ju379u0bPXv2jDVr1rR6rIMGDYqSkpKYMGFCfPWrX42vfOUrrT/gfUga5vaVV16JBQsWxHPPPRd33nln/PCHP4w77rgjvvrVr7b9wPcR06ZNiwULFsTKlSvj1VdfjSeffDJOP33Xb4x0lrlevnx5XHzxxTF37twoLi7Il+5SKxdz/eKLL0ZExOjRo3e7j1GjRmXbrFmzJqqrq3dpU11d3ao579OnT1xzzTVxxx13xO9///v49Kc/HSeffHL88pe/bHEfAAAAAOzK/67twdFHH529FE3Ezvtl7GldxK7XXp81a1b2prnvO+CAA7L/fv968B+UJMlulzfniSeeiE2bNsVTTz0VF198cQwfPjxOPfXUVvezr0jD3DY2NkZRUVHMnTs3Mpmd9yq55ppr4otf/GL86Ec/yt6zgF1VVVXF8ccfHz/72c8iSZI4/vjjo6qqapd2nWGud+zYEVOnTo3LL788RowY0aJt+D+5nOskSXa7jw/PZy6e31VVVfH1r389+/uECRNiw4YNcfXVV+82sAEAAACgZQoSePzhW0cXYretUlZWFsOHD2/1uvdVVVXtsU1NTU0sWrSoybINGzbE9u3bd/mL8ZY48MADIyLikEMOibVr18Zll11WsMDjF5/9VUH22xppmNsBAwbEAQcckA07Inb+BXqSJLFq1ao46KCDWtxXLpzx8y926P7aa+bMmXHeeedFRMSPfvSj3bbpDHNdX18ff/nLX2LJkiXZ8TY2NkaSJFFcXBwPPPBAHHPMMS3qK1dq/ra0Q/fXXu2d6/eDpmXLlsWRRx65y/r//d//jTFjxkTEzjnf3Q3l33rrrTbV7g86/PDD46c//Wm7+gAAAADY1xUk8Ohb1rMQu+00jjjiiLjyyitj9erVMWDAgIjYeR35kpKSOOyww9rVd5Ik0dDQkIthtkmmJNN8oy4sV3M7ceLE+O1vfxubNm2KPn36RMTOS+9069YtBg0alJex701ppleH77M9Jk2aFNu2bYuInffVyIdczHVFRUU8++yzTZbdcMMN8fDDD8cdd9yRDTM7UvfKyg7fZ3u0d66PPfbY6NevX8yePXuXwOPuu++O5cuXZy9/dcQRR0RdXV08/fTT8U//9E8REbFo0aKoq6vbbVjSGkuWLMmeRwAAAAC0jUtatUFDQ8Mu12svLi5ucimV+vr6Xdr07t07Kioq4thjj40xY8bEtGnT4j//8z9j/fr1ceGFF8ZZZ50VFRUV2fbPP/98bNu2LdavXx/19fWxdOnSiIgYN25cROz8a+YhQ4bEqFGjIiJiwYIF8YMf/CDOP//8PBz1vqGzzO3UqVPjiiuuiDPPPDMuv/zyePvtt2PWrFkxc+ZMl7Nqge7du8eyZcuy/96dzjDX3bp1i7Fjxzbpv7q6Onr16rXLcnavvXNdVlYWP/nJT+KUU06Js88+O84777yoqKiIP/7xjzFr1qz44he/GCeddFJE7PyW1aRJk+Kss86Kn/zkJxERcfbZZ8cJJ5wQI0eOzPb90ksvxaZNm2LNmjWxZcuW7JyPGTMmevbsGT/72c+iR48eMX78+OjWrVvcc889ce2118b3v//9XD88AAAAAPuWhF1Mnz49mTJlyh7XRcQuPyNHjsy2GTp06G7bnHPOOdk2r776anL88ccnpaWlSb9+/ZLzzjsv2bp1a5N97amf91177bXJwQcfnPTu3TupqKhIxo8fn9xwww3Jjh07cvuAdCFpmdskSZJly5Yln/nMZ5LS0tJk0KBByTe+8Y1k8+bNuXswupi9zW2SJMmUKVOS6dOnZ9t2prn+oEsvvTQ59NBD2/QY7CtyPddJkiSPP/54MmnSpCSTySQ9e/ZMxowZk/zgBz9I3nvvvSbtamtrk9NOOy0pLy9PysvLk9NOOy3ZsGFDkzZHHXXUbve5YsWKJEmS5L//+7+T0aNHJ717907Ky8uTww47LPnFL37R3ocFAAAAYJ9XlCR7uFMrAAAAAABASnQr9AAAAAAAAADaS+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6hXnq+PGxsZ48803o7y8PIqKivK1GwAAAAAAIAWSJIn6+voYOHBgdOuW++9j5C3wePPNN2Pw4MH56h4AAAAAAEih119/PQYNGpTzfvMWeJSXl0fEzoFXVFTkazcAAAAAAEAKbNy4MQYPHpzND3Itb4HH+5exqqioEHgAAAAAAAAREXm7DYablgMAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEi9vAce767fnO9dQJe0avUb8YPfzo5Vq98o9FDoYtZvXR+/WjY31m9dHxE76/Rfbv9rTut1PvpMsx1r18bG2dfEjrVrCz2UnOkKx5Sr8zRN5/uHn//tbQe5lo9z74N9vl3fEDc/8lK8Xd+Qs/7Zt3XkOaU2A+RPV6mxXeU4IrrWsdCx8h54bHlna753AV3Smto18XiPh2NN7ZpCD4UuZsPW9THvhV/Fhv//TcPmDVti8bxnY/OGLTnbRz76TLMd69ZF/TVzYse6dYUeSs50hWPK1XmapvP9w8//9raDXMvHuffBPt+ub4hbHn1Z4EHOdOQ5pTYD5E9XqbFd5Tgiutax0LFc0goAAAAAAEg9gQcAAAAAAJB6xfneQcO722JLnctaQWtt27w9IiLefe/dqGuoK/Bo6Eo2bdu02+UNm3JXrxs2bctJP11N4zt1saO2ttDDyInGd7pOXWrvuZ/G833Ttk17fW3ZU52AjtLcOdravj6sfsv22PBu+p67dD71W7Z3+D5z+fwAYKeu9v63K7xWdLU5oePkPfC4/8rHorRHab53A11OXeX6iMkRs1d+P2JloUfDvuDe7/6x0EPo8mpPObXQQ2A39sVz/5KF3yn0EGCv8n2Onv/zv+S1f8gnNRyA5nitYF/mklYAAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpl/d7eBz3naNi2Ngh+d4NdDlLXlgaC968P7457KIYN/rQQg+HLmRl3YrdXs/z+P/4dFQO65uTfdSu3LBP3hehOZXzbo8eY0YXehg5sf35ZV3mniTtPffTeL5fceSVMSxz4B7X76lOQEdp7hxtjd2dz9edMSGG15TnpH/2bS+tqe/we8Lk8vkBwE5d7f1vV3it6GpzQsfJe+BRUtYzSjO98r0b6HJ69u4RERFlxWWRKckUeDR0JX169tnt8pI+uavXJX165qSfrqbbfpnoXllZ6GHkxI79uk5dau+5n8bzvU/PPnt9bdlTnYCO0tw52tq+Pqy8tEf0LUvfc5fOp7y0R4fvM5fPDwB26mrvf7vCa0VXmxM6jktaAQAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASL28Bx6l+7lhObRFTWVNfHL7MVFTWVPoodDF9O3VL04ZOTX69uoXERG9+5bGYaccEr37luZsH/noM826V1dH+Te+Ht2rqws9lJzpCseUq/M0Tef7h5//7W0HuZaPc++DfVaVl8SXP/WRqCovyVn/7Ns68pxSmwHyp6vU2K5yHBFd61joWEVJkiT56Hjjxo2RyWSirq4uKioq8rELAAAAAAAgJfKdG7ikFQAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfw6ALWb10fv1o2N9ZvXd8p+sm33Y2zvWN/u74hbn7kpXi7viEn7XIlX/vr6OMg/8xpunWW+ess4wA6H/WBQmnJ+/y2fBbYsXZtbJx9TexYu7ZN42rv9sBOrXl98VrUsQrxeJvj3POY0hnV5vl8FHh0ARu2ro95L/wqNrQzqMhVP/m2u3G2d+xv1zfELY++3KLAoyXtciVf++vo4yD/zGm6dZb56yzjADof9YFCacn7/LZ8Ftixbl3UXzMndqxb16ZxtXd7YKfWvL54LepYhXi8zXHueUzpjGo3CTwAAAAAAAD2SuABAAAAAACknsADAAAAAABIveJCD4Dc2bRtU9Q11LVr+zT54PHmauz1W7bHhne37XV9ITQ3rrb0R9eU63OFjtHZnpPOI+DDOludYt+zt8867fks0PhOXeyorW3TdkDutOT9p9eiwujIzwbmOH98xqMzqd/yXl77F3h0IZcs/E6hh9Ch8nG85//8LznvMxc667jofJwr5ILzCIDOJl+fdWpPOTUv/QKt4/1n52VuugbzSGfyXsO7ee3fJa0AAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABSzz08upArjrwyhmUObPP2K+tWpOo+IB883lyN/bozJsTwmvI9rn9pTX1BrnvY3Lhaq1DHQf7l+lyhY3S256TzCPiwzlan2Pfs7bNOez4LVM67PXqMGd3q7bY/v8z9PyCHWvL+02tRYXTkZwNznD8+49GZLF3+Zhzz/fz1L/DoQvr07BOZkky7tk+TDx5vrsZeXtoj+pb13Ov6QmhuXG3pj64p1+cKHaOzPSedR8CHdbY6xb5nb5912vNZoNt+meheWdnq7Xbs1/bPXcCuWvL+02tRYXTkZwNznD8+49GZlJfmN5JwSSsAAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3h0AX179YtTRk6Nvr36dYp+8m1342zv2KvKS+LLn/pIVJWX5KRdruRrfx19HOSfOU23zjJ/nWUcQOejPlAoLXmf35bPAt2rq6P8G1+P7tXVbRpXe7cHdmrN64vXoo5ViMfbHOeex5TOqLJPfs/HoiRJknx0vHHjxshkMlFXVxcVFRX52AUAAAAAAJAS+c4NfMMDAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/DYh7xd3xA3P/JSvF3f0Kb1AEDE+q3r41fL5sb6retbtBwAAADoGAKPfcjb9Q1xy6Mv7zXw2Nt6ACBiw9b1Me+FX8WGDwUbe1oOAAAAdAyBBwAAAAAAkHoCDwAAAAAAIPWKCz0AOl79lu2x4d1tu10OALTMpm2boq6hrsnvAAAAQOEIPPZB5//8L4UeAgCk3iULv1PoIQAAAAAf4JJWAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqeceHvug686YEMNryndZ/tKaevf3AIAWuuLIK2NY5sDs7yvrVrivBwAAABSQwGMfVF7aI/qW9dztcgCgZfr07BOZkkyT3wEAAIDCcUkrAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfw2IdUlZfElz/1kagqL2nTegAgom+vfnHKyKnRt1e/Fi0HAAAAOkZRkiRJPjreuHFjZDKZqKuri4qKinzsAgAAAAAASIl85wa+4QEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1ivPVcZIkERGxcePGfO0CAAAAAABIiffzgvfzg1zLW+BRW1sbERGDBw/O1y4AAAAAAICUqa2tjUwmk/N+8xZ49OvXLyIiXnvttbwMHEiHjRs3xuDBg+P111+PioqKQg8HKAB1AFAHgAi1AFAHgIi6uroYMmRINj/ItbwFHt267bw9SCaTUcCAqKioUAtgH6cOAOoAEKEWAOoA8H/5Qc77zUuvAAAAAAAAHUjgAQAAAAAApF7eAo+SkpK49NJLo6SkJF+7AFJALQDUAUAdACLUAkAdAPJfB4qSJEny0jMAAAAAAEAHcUkrAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqdfqwOONN96I008/PSorK6N3794xbty4WLx4cXZ9kiRx2WWXxcCBA6O0tDQ+9alPxd///vcmfTQ0NMT5558fVVVVUVZWFpMnT45Vq1a1/2iADtFcHZg/f34cd9xxUVVVFUVFRbF06dJd+lAHIP32Vgu2b98eF110URxyyCFRVlYWAwcOjDPOOCPefPPNJn2oBZBuzb0nuOyyy2LUqFFRVlYWffv2jc985jOxaNGiJn2oA5BuzdWBDzrnnHOiqKgofvjDHzZZrg5A+jVXC2bMmBFFRUVNfg4//PAmfagFkG4teU+wbNmymDx5cmQymSgvL4/DDz88Xnvttez6XNSBVgUeGzZsiIkTJ0aPHj3iD3/4Qzz//PMxe/bs2G+//bJtrr766rjmmmvi+uuvjz//+c9RU1MT//zP/xz19fXZNv/2b/8Wd955Z8ybNy8WLFgQmzZtihNOOCF27NjRqsEDHa8ldeDdd9+NiRMnxlVXXbXHftQBSLfmasHmzZvjmWeeiUsuuSSeeeaZmD9/frz44osxefLkJv2oBZBeLXlPMGLEiLj++uvj2WefjQULFsSwYcPi2GOPjbfeeivbRh2A9GpJHXjfXXfdFYsWLYqBAwfusk4dgHRraS2YNGlSrF69Ovvz+9//vsl6tQDSqyV14OWXX45PfOITMWrUqHj00Ufjr3/9a1xyySXRq1evbJuc1IGkFS666KLkE5/4xB7XNzY2JjU1NclVV12VXbZ169Ykk8kkP/7xj5MkSZJ33nkn6dGjRzJv3rxsmzfeeCPp1q1bct9997VmOEABNFcHPmjFihVJRCRLlixpslwdgPRrTS1439NPP51ERPLqq68mSaIWQNq1pQ7U1dUlEZE89NBDSZKoA5B2La0Dq1atSg444IDkueeeS4YOHZrMmTMnu04dgPRrSS2YPn16MmXKlD2uVwsg3VpSB04++eTk9NNP3+P6XNWBVn3D4+67744JEybEl770paiuro7x48fHzTffnF2/YsWKWLNmTRx77LHZZSUlJXHUUUfFwoULIyJi8eLFsX379iZtBg4cGGPHjs22ATqv5upAS6gDkH5tqQV1dXVRVFSU/QsPtQDSrbV1YNu2bXHTTTdFJpOJQw89NCLUAUi7ltSBxsbGmDZtWsyaNSsOPvjgXfpQByD9Wvqe4NFHH43q6uoYMWJEnHXWWbFu3brsOrUA0q25OtDY2Bj33ntvjBgxIo477riorq6Oj3/843HXXXdl2+SqDrQq8HjllVfixhtvjIMOOijuv//+OPfcc+OCCy6In//85xERsWbNmoiI6N+/f5Pt+vfvn123Zs2a6NmzZ/Tt23ePbYDOq7k60BLqAKRfa2vB1q1b4+KLL46pU6dGRUVFRKgFkHYtrQO/+93vok+fPtGrV6+YM2dOPPjgg1FVVRUR6gCkXUvqwPe///0oLi6OCy64YLd9qAOQfi2pBZ/97Gdj7ty58fDDD8fs2bPjz3/+cxxzzDHR0NAQEWoBpF1zdWDdunWxadOmuOqqq2LSpEnxwAMPxBe+8IU48cQT47HHHouI3NWB4tYMvLGxMSZMmBDf+973IiJi/Pjx8fe//z1uvPHGOOOMM7LtioqKmmyXJMkuyz6sJW2AwmtpHWgLdQDSozW1YPv27XHKKadEY2Nj3HDDDc32rRZAOrS0Dhx99NGxdOnSePvtt+Pmm2+Ok046KRYtWhTV1dV77FsdgHRorg4sXrw4/uu//iueeeaZVj+n1QFIj5a8Jzj55JOz7ceOHRsTJkyIoUOHxr333hsnnnjiHvtWCyAdmqsDjY2NERExZcqU+PrXvx4REePGjYuFCxfGj3/84zjqqKP22Hdr60CrvuExYMCAGDNmTJNlo0ePzt5JvaamJiJil8Rl3bp12W991NTUxLZt22LDhg17bAN0Xs3VgZZQByD9WloLtm/fHieddFKsWLEiHnzwwey3OyLUAki7ltaBsrKyGD58eBx++OFxyy23RHFxcdxyyy0RoQ5A2jVXB5544olYt25dDBkyJIqLi6O4uDheffXV+OY3vxnDhg2LCHUAuoK2/D/BgAEDYujQobF8+fKIUAsg7ZqrA1VVVVFcXNxstpCLOtCqwGPixInxwgsvNFn24osvxtChQyMi4sADD4yampp48MEHs+u3bdsWjz32WBx55JEREXHYYYdFjx49mrRZvXp1PPfcc9k2QOfVXB1oCXUA0q8lteD9sGP58uXx0EMPRWVlZZP2agGkW1vfEyRJkr18hToA6dZcHZg2bVr87W9/i6VLl2Z/Bg4cGLNmzYr7778/ItQB6Ara8p6gtrY2Xn/99RgwYEBEqAWQds3VgZ49e8Y//uM/7rVNzupAi29vniTJ008/nRQXFydXXnllsnz58mTu3LlJ7969k1/+8pfZNldddVWSyWSS+fPnJ88++2xy6qmnJgMGDEg2btyYbXPuuecmgwYNSh566KHkmWeeSY455pjk0EMPTd57773WDAcogJbUgdra2mTJkiXJvffem0REMm/evGTJkiXJ6tWrs23UAUi35mrB9u3bk8mTJyeDBg1Kli5dmqxevTr709DQkO1HLYD0aq4ObNq0Kfn2t7+d/OlPf0pWrlyZLF68OPnyl7+clJSUJM8991y2H3UA0qslnw0+bOjQocmcOXOaLFMHIN2aqwX19fXJN7/5zWThwoXJihUrkkceeSQ54ogjkgMOOMD/F0IX0ZL3BPPnz0969OiR3HTTTcny5cuT6667LunevXvyxBNPZNvkog60KvBIkiS55557krFjxyYlJSXJqFGjkptuuqnJ+sbGxuTSSy9NampqkpKSkuSTn/xk8uyzzzZps2XLluS8885L+vXrl5SWliYnnHBC8tprr7V2KECBNFcHbrvttiQidvm59NJLs23UAUi/vdWCFStW7LYORETyyCOPZNupBZBue6sDW7ZsSb7whS8kAwcOTHr27JkMGDAgmTx5cvL000836UMdgHRr7rPBh+0u8FAHIP32Vgs2b96cHHvsscn++++f9OjRIxkyZEgyffr0XZ7nagGkW0veE9xyyy3J8OHDk169eiWHHnpoctdddzVZn4s6UJQkSdKKb6cAAAAAAAB0Oq26hwcAAAAAAEBnJPAAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AACAdrvsssti3LhxhR4GAACwDytKkiQp9CAAAIDOq6ioaK/rp0+fHtdff300NDREZWVlB40KAACgKYEHAACwV2vWrMn++9e//nV897vfjRdeeCG7rLS0NDKZTCGGBgAAkOWSVgAAwF7V1NRkfzKZTBQVFe2y7MOXtJoxY0Z8/vOfj+9973vRv3//2G+//eLyyy+P9957L2bNmhX9+vWLQYMGxa233tpkX2+88UacfPLJ0bdv36isrIwpU6bEypUrO/aAAQCAVBJ4AAAAefHwww/Hm2++GY8//nhcc801cdlll8UJJ5wQffv2jUWLFsW5554b5557brz++usREbF58+Y4+uijo0+fPvH444/HggULok+fPjFp0qTYtm1bgY8GAADo7AQeAABAXvTr1y+uvfbaGDlyZMycOTNGjhwZmzdvjn//93+Pgw46KL797W9Hz54948knn4yIiHnz5kW3bt3ipz/9aRxyyCExevTouO222+K1116LRx99tLAHAwAAdHrFhR4AAADQNR188MHRrdv//Y1V//79Y+zYsdnfu3fvHpWVlbFu3bqIiFi8eHG89NJLUV5e3qSfrVu3xssvv9wxgwYAAFJL4AEAAORFjx49mvxeVFS022WNjY0REdHY2BiHHXZYzJ07d5e+9t9///wNFAAA6BIEHgAAQKfwsY99LH79619HdXV1VFRUFHo4AABAyriHBwAA0CmcdtppUVVVFVOmTIknnngiVqxYEY899lh87Wtfi1WrVhV6eAAAQCcn8AAAADqF3r17x+OPPx5DhgyJE088MUaPHh0zZ86MLVu2+MYHAADQrKIkSZJCDwIAAAAAAKA9fMMDAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOr9fw+gShyFf/1LAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" + "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)." ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "groundtruth" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "MxlrTbyPYnqB" - }, - "source": [ - "# Going further \n", - "\n", - "We have only scratched the surface in this introduction. \n", - "\n", - "More details can be found in the [`pyannote.audio` Github repository](https://github.com/pyannote/pyannote-audio).\n" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "include_colab_link": true, - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.5" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "0125df9fa8e14b3db0e2bce299529812": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_407e250e244b4985b1ce8c9d32a8af7d", - "max": 318, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_8127c4258e374ad986ce1f8b4c70f704", - "value": 318 - } - }, - "0821b47ae70444dfa38b84719c4836a6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0adb304bf90f4079a4031caea1cfb924": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0b4bf8076fdf4d19843a3246c8bd61ac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0d10fb0edc9144b1a1fc1f2c9e322410": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d33fba0d78fb41f983c55f5cd2a0a740", - "placeholder": "​", - "style": "IPY_MODEL_fd47487fc8734594823f8afa00c4239d", - "value": "Downloading: 100%" - } - }, - "0d80273cabbc42ba9a408fb1144151c9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } }, - "0e382d66f09f4958a40baa7ab83c4ccb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "13525aa369a9410a83343952ab511f3c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "1600b9cd09c446e581b7912e35c9f56e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "16c0017f65b649f5ac5bebf1c955a1fd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "17856a72e4e948039a66c51e8244cb50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "183c55d5d3ce4058ae338c81344547c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_70efa83bf3ea45b4bd8cc41f57613328", - "IPY_MODEL_338747810ac74b4e83e356a01459c8a5", - "IPY_MODEL_ac0bcfa1ef6e4e78a7769c4cb2e8762f" + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 230 + }, + "id": "bAHza4Y1Ynp-", + "outputId": "c4cc2369-bfe4-4ac2-bb71-37602e7c7a8a" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } ], - "layout": "IPY_MODEL_6efb7939bb954dc8ba116680139eb257" - } - }, - "1946386483ed4947a2184cdb4ea6e434": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "23d4e25ec6c541818d5927b69576d278": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + "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" + ] }, - "27f6f437c5264368bc2c679942ad1e53": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + { + "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." + ] }, - "28004251b0e44a6c9dfa7ce1b30dcb18": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e98cf7a63c814ffd94f69928f0700ebf", - "IPY_MODEL_6a4dee55cbae4959bd7fe3c4d92242b1", - "IPY_MODEL_8dba487876124827919079519406ecb8" + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 62 + }, + "id": "rDhZ3bXEYnp-", + "outputId": "a82efe4e-2f9c-48bd-94fb-c62af3a3cb43" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } ], - "layout": "IPY_MODEL_5c211704f90946afbae2f66a7586ce70" - } - }, - "2b2d7912186a49dd9891ae12c77482c7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2cbf0faadd4842c8b22e10541ff9de4e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2d7a0b901d7044d5b1f273a3e9bea560": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "304e9682570b4abeb1719001c04449d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "32accb0adfa24c62a75c15c8ec88df8c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_23d4e25ec6c541818d5927b69576d278", - "max": 128619, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_54d9456703324160aced03ee5fef2943", - "value": 128619 - } - }, - "333b42ca7aa44788b1c22724eb11bcc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "338747810ac74b4e83e356a01459c8a5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_e4c1e9affaba4045a3ec903091b6f454", - "max": 500, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_1946386483ed4947a2184cdb4ea6e434", - "value": 500 - } - }, - "341615c971b04033b7293d82fc40f35c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + "source": [ + "from pyannote.audio import Audio\n", + "from IPython.display import Audio as IPythonAudio\n", + "waveform, sr = Audio(mono=\"downmix\").crop(DEMO_FILE, EXCERPT)\n", + "IPythonAudio(waveform.flatten(), rate=sr)" + ] }, - "3499ef4dd9f243d9bef00b396e78ed69": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } + { + "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)." + ] }, - "358c3a67f8b54c4c899e095611fa116b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + { + "cell_type": "markdown", + "metadata": { + "id": "3hmFmLzFYnp_" + }, + "source": [ + "## Upload audio file" + ] }, - "38b3054ad59549e4b4f2de4697139a87": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_0adb304bf90f4079a4031caea1cfb924", - "placeholder": "​", - "style": "IPY_MODEL_40021e0b59fe4e1e9bac351dbec57c6c", - "value": "Downloading: 100%" - } + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xC05jFO_Ynp_" + }, + "outputs": [], + "source": [ + "import google.colab\n", + "own_file, _ = google.colab.files.upload().popitem()\n", + "OWN_FILE = {'audio': own_file}\n", + "notebook.reset()\n", + "\n", + "# load audio waveform and play it\n", + "waveform, sample_rate = Audio(mono=\"downmix\")(OWN_FILE)\n", + "IPythonAudio(data=waveform.squeeze(), rate=sample_rate, autoplay=True)" + ] }, - "3bd33a372aad4c438f64d73c97f14c6a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } + { + "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" + ] }, - "40021e0b59fe4e1e9bac351dbec57c6c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } + { + "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", + "```" + ] }, - "404f7ce06a01470fbb0b747981d00e84": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_38b3054ad59549e4b4f2de4697139a87", - "IPY_MODEL_7d90af87c9574f5ca21fca058c39bf02", - "IPY_MODEL_fee75343289f42fb8d6dfb4bf26fe368" + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving sample.rttm to sample.rttm\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } ], - "layout": "IPY_MODEL_f21c0c6379d74898ac6aadcb6fc14a8a" - } + "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" + ] }, - "407e250e244b4985b1ce8c9d32a8af7d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + { + "cell_type": "markdown", + "metadata": { + "id": "5MclWK2GYnp_" + }, + "source": [ + "# Speaker diarization with `pyannote.pipeline`\n", + "\n", + "We are about to run a full speaker diarization pipeline, that includes speaker segmentation, speaker embedding, and a final clustering step. **Brace yourself!**\n", + "\n", + "To load the speaker diarization pipeline,\n", + "\n", + "* accept the user conditions on [hf.co/pyannote/speaker-diarization-3.1](https://hf.co/pyannote/speaker-diarization-3.1)\n", + "* accept the user conditions on [hf.co/pyannote/segmentation-3.0](https://hf.co/pyannote/segmentation-3.0)\n", + "* login using `notebook_login` below" + ] }, - "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" + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 301, + "referenced_widgets": [ + "c8731777ce834e58a76a295076200cfc", + "859b12a6d95b4c6f987791ca848122b9", + "94756148d2e94a93ae233baba20af683", + "ba18cded436e486da34882d821d8f1eb", + "99898e6ee64a46bd832af112e79b58b7", + "79184c8c2a6f4b7493bb7f6983f18a09", + "ea95ffd922c0455d957120f034e541f8", + "13525aa369a9410a83343952ab511f3c", + "b2be65e192384c948fb8987d4cfca505", + "333b42ca7aa44788b1c22724eb11bcc3", + "0e382d66f09f4958a40baa7ab83c4ccb", + "6a45ce374e2e47ba9457d02e02522748", + "765485a1d3f941d28b79782dcffbf401", + "3499ef4dd9f243d9bef00b396e78ed69", + "6e56329c30c0441c8d45df3975e75a76" + ] + }, + "id": "r5u7VMb-YnqB", + "outputId": "c714a997-d4f8-417a-e5ad-0a4924333859" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6e56329c30c0441c8d45df3975e75a76", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value='
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } ], - "layout": "IPY_MODEL_6ede83f870a24e71b5182fcc458cdc42" - } - }, - "8127c4258e374ad986ce1f8b4c70f704": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "859b12a6d95b4c6f987791ca848122b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ea95ffd922c0455d957120f034e541f8", - "placeholder": "​", - "style": "IPY_MODEL_13525aa369a9410a83343952ab511f3c", - "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" - } - }, - "8dba487876124827919079519406ecb8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_67fcc38a1e5d4eb39381685447e397de", - "placeholder": "​", - "style": "IPY_MODEL_0b4bf8076fdf4d19843a3246c8bd61ac", - "value": " 1.92k/1.92k [00:00<00:00, 63.2kB/s]" - } - }, - "94756148d2e94a93ae233baba20af683": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "PasswordModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "PasswordModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "PasswordView", - "continuous_update": true, - "description": "Token:", - "description_tooltip": null, - "disabled": false, - "layout": "IPY_MODEL_b2be65e192384c948fb8987d4cfca505", - "placeholder": "​", - "style": "IPY_MODEL_333b42ca7aa44788b1c22724eb11bcc3", - "value": "" - } - }, - "99898e6ee64a46bd832af112e79b58b7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_765485a1d3f941d28b79782dcffbf401", - "placeholder": "​", - "style": "IPY_MODEL_3499ef4dd9f243d9bef00b396e78ed69", - "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks.
" - } - }, - "a02030ba8f324d93a7ed6cc793d70a3b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a899f4bc6ed842d397723cca582669e6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_341615c971b04033b7293d82fc40f35c", - "placeholder": "​", - "style": "IPY_MODEL_17856a72e4e948039a66c51e8244cb50", - "value": " 5.53M/5.53M [00:00<00:00, 21.7MB/s]" - } - }, - "ab32c7daa1d9404fb921f39fbc4fc05c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "aba21021d3bb4565a58ffa40049810db": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ac0bcfa1ef6e4e78a7769c4cb2e8762f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_549a30c85c47466eadedbd24da42e304", - "placeholder": "​", - "style": "IPY_MODEL_bedc7d916b9745f097094c5c51a81f06", - "value": " 500/500 [00:00<00:00, 5.05kB/s]" - } - }, - "ac2950d08fc145ba9eb9cf5824b1ee18": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b26354d0278f447d92c7e1ad4c211d64": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b2be65e192384c948fb8987d4cfca505": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ba18cded436e486da34882d821d8f1eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ButtonModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ButtonView", - "button_style": "", - "description": "Login", - "disabled": false, - "icon": "", - "layout": "IPY_MODEL_0e382d66f09f4958a40baa7ab83c4ccb", - "style": "IPY_MODEL_6a45ce374e2e47ba9457d02e02522748", - "tooltip": "" - } - }, - "bacfb50c001047c4824a05c9f2ee2e40": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "bcf766d2a2c641f0aa2af596c7da1b18": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ee537ee5470f4d7b816a8c8f96948b4d", - "max": 17719103, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_652e97509a914f3b914665c4889c6d11", - "value": 17719103 - } - }, - "bedc7d916b9745f097094c5c51a81f06": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "bf299285318b4a04a88569cc581ecd75": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_bacfb50c001047c4824a05c9f2ee2e40", - "placeholder": "​", - "style": "IPY_MODEL_c53a1cf68fcd4388abf1f0379891089a", - "value": " 129k/129k [00:00<00:00, 155kB/s]" - } + "source": [ + "diarization" + ] }, - "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" - } + { + "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)." + ] }, - "c53a1cf68fcd4388abf1f0379891089a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vNHQRTUIYnqB" + }, + "outputs": [], + "source": [ + "from pyannote.metrics.diarization import DiarizationErrorRate\n", + "metric = DiarizationErrorRate()\n", + "der = metric(groundtruth, diarization)" + ] }, - "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" + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9d0vKQ0fYnqB", + "outputId": "9a664753-cd84-4211-9153-d33e929bb252" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "diarization error rate = 19.8%\n" + ] + } ], - "layout": "IPY_MODEL_79184c8c2a6f4b7493bb7f6983f18a09" - } - }, - "c8e0c9a60ef34d2caee9d55a3c21c3d4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + "source": [ + "print(f'diarization error rate = {100 * der:.1f}%')" + ] }, - "c9974003727a401797953ef2885db5a2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + { + "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." + ] }, - "d12f07e25bf5422facc38c3463700994": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_eae11f84c2644ada8295b445c924baec", - "IPY_MODEL_bcf766d2a2c641f0aa2af596c7da1b18", - "IPY_MODEL_74bf69aa6eaa4a8594b2ea9a0fb20957" + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 230 + }, + "id": "xMLf4mrYYnqB", + "outputId": "ed08bcc8-24c6-439c-a244-3a673ff480b0" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } ], - "layout": "IPY_MODEL_2d7a0b901d7044d5b1f273a3e9bea560" - } - }, - "d13ba6030aff42bca48c72ff071c44c0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c8e0c9a60ef34d2caee9d55a3c21c3d4", - "max": 5534328, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_764aa53d75324d73ab06936c52fd8fc8", - "value": 5534328 - } + "source": [ + "mapping = metric.optimal_mapping(groundtruth, diarization)\n", + "diarization.rename_labels(mapping=mapping)" + ] }, - "d182e37b4a404158bee8446fc2728bd9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_603e99f45afb4910a99f7684ffd21b6a", - "IPY_MODEL_d13ba6030aff42bca48c72ff071c44c0", - "IPY_MODEL_a899f4bc6ed842d397723cca582669e6" + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 230 + }, + "id": "Z0ewsLlQYnqB", + "outputId": "8a8cd040-ee1d-48f7-d4be-eef9e08e9e55" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjwAAADyCAYAAAD5q2z1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAl9UlEQVR4nO3de3RV5Z0//k8gEEJIjpAYAnJzitzECpWZqnTVajtKRwutq/WCIkjrZU3VTlupdrqsOi67rFOko1ZbrTq9UGnroF+trbd6RSq2CK1WRlFBRblowBAEApL9+4OfZ4xccjsnJzu8XmtlLbL3s5/97PPs8znn8M7ZuyhJkiQAAAAAAABSrFuhBwAAAAAAANBeAg8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2Bx27MmDEjioqKdvl56aWX9rhu0qRJ2e2HDRu22zZXXXVVts1rr70Wn/vc56KsrCyqqqriggsuiG3btmXXb926NWbMmBGHHHJIFBcXx+c///ldxrlgwYKYOHFiVFZWRmlpaYwaNSrmzJmT18cm7dIytxERDQ0N8Z3vfCeGDh0aJSUl8ZGPfCRuvfXWvD02aff+/J177rm7rPvXf/3XKCoqihkzZjRp21nm+n1PPvlkFBcXx7hx49r1WHR1uZ7riIiFCxfGv/zLv0Tfvn2jV69eccghh8Ts2bNjx44dTdpt2LAhpk2bFplMJjKZTEybNi3eeeedJm2+9rWvxWGHHRYlJSW7ncuVK1fudkz33Xdfux4XAAAAgH1dcSF2uuHdbc03yqG+ZT1bvc2kSZPitttua7Js//333+O6kpKSJr//x3/8R5x11llNlpWXl0dExI4dO+L444+P/fffPxYsWBC1tbUxffr0SJIkrrvuumyb0tLSuOCCC+J//ud/djvGsrKyOO+88+KjH/1olJWVxYIFC+Kcc86JsrKyOPvss1t9zLlQ11DXYfvKlGTatF0a5jYi4qSTToq1a9fGLbfcEsOHD49169bFe++916Zjbq8tdVs7dH+lmV5t2m7w4MExb968mDNnTpSWlkbEztDh9ttvjyFDhjRp25nmOiKirq4uzjjjjPj0pz8da9eubf3B58iO2toO3V/3yso2bZfLub7zzjvjpJNOijPPPDMeeeSR2G+//eKhhx6Kb33rW/HUU0/Fb37zmygqKoqIiKlTp8aqVauy4cTZZ58d06ZNi3vuuSfbX5IkMXPmzFi0aFH87W9/2+MxPPTQQ3HwwQdnf+/Xr1+bHgsAAAAAdipI4PHZqx/p0P09dflxrd6mpKQkampqWr3ufeXl5Xts88ADD8Tzzz8fr7/+egwcODAiImbPnh0zZsyIK6+8MioqKqKsrCxuvPHGiNj5V98f/gviiIjx48fH+PHjs78PGzYs5s+fH0888UTBAo9pf5jaYfu6+/P3tmm7NMztfffdF4899li88sor2f8EHTZsWAuPMPd+fsYdHbq/c/7f6W3a7mMf+1i88sorMX/+/DjttNMiImL+/PkxePDg+Id/+IcmbTvLXL/vnHPOialTp0b37t3jrrvuauER596aj47r0P0d8MbrbdouV3P97rvvxllnnRWTJ0+Om266Kbv8K1/5SvTv3z8mT54cv/nNb+Lkk0+OZcuWxX333RdPPfVUfPzjH4+IiJtvvjmOOOKIeOGFF2LkyJEREXHttddGRMRbb72118CjsrKy2XMQAAAAgJZzSasC+NOf/hRjx47N/idpRMRxxx0XDQ0NsXjx4jb3u2TJkli4cGEcddRRuRgmbZCrub377rtjwoQJcfXVV8cBBxwQI0aMiAsvvDC2bNmSj2F3KWeeeWaTv+a/9dZbY+bMmTnfTy6fx7fddlu8/PLLcemll+Z6mF1aLub6gQceiNra2rjwwgt3Wfe5z30uRowYEbfffntE7JzzTCaTDTsiIg4//PDIZDKxcOHCVo9/8uTJUV1dHRMnTow77ujYUBEAAACgKxJ47MHvfve76NOnT/bnS1/60h7X9enTJ6644oom21900UW7tHn00UcjImLNmjXRv3//Ju379u0bPXv2jDVr1rR6rIMGDYqSkpKYMGFCfPWrX42vfOUrrT/gfUga5vaVV16JBQsWxHPPPRd33nln/PCHP4w77rgjvvrVr7b9wPcR06ZNiwULFsTKlSvj1VdfjSeffDJOP33Xb4x0lrlevnx5XHzxxTF37twoLi7Il+5SKxdz/eKLL0ZExOjRo3e7j1GjRmXbrFmzJqqrq3dpU11d3ao579OnT1xzzTVxxx13xO9///v49Kc/HSeffHL88pe/bHEfAAAAAOzK/67twdFHH529FE3Ezvtl7GldxK7XXp81a1b2prnvO+CAA7L/fv968B+UJMlulzfniSeeiE2bNsVTTz0VF198cQwfPjxOPfXUVvezr0jD3DY2NkZRUVHMnTs3Mpmd9yq55ppr4otf/GL86Ec/yt6zgF1VVVXF8ccfHz/72c8iSZI4/vjjo6qqapd2nWGud+zYEVOnTo3LL788RowY0aJt+D+5nOskSXa7jw/PZy6e31VVVfH1r389+/uECRNiw4YNcfXVV+82sAEAAACgZQoSePzhW0cXYretUlZWFsOHD2/1uvdVVVXtsU1NTU0sWrSoybINGzbE9u3bd/mL8ZY48MADIyLikEMOibVr18Zll11WsMDjF5/9VUH22xppmNsBAwbEAQcckA07Inb+BXqSJLFq1ao46KCDWtxXLpzx8y926P7aa+bMmXHeeedFRMSPfvSj3bbpDHNdX18ff/nLX2LJkiXZ8TY2NkaSJFFcXBwPPPBAHHPMMS3qK1dq/ra0Q/fXXu2d6/eDpmXLlsWRRx65y/r//d//jTFjxkTEzjnf3Q3l33rrrTbV7g86/PDD46c//Wm7+gAAAADY1xUk8Ohb1rMQu+00jjjiiLjyyitj9erVMWDAgIjYeR35kpKSOOyww9rVd5Ik0dDQkIthtkmmJNN8oy4sV3M7ceLE+O1vfxubNm2KPn36RMTOS+9069YtBg0alJex701ppleH77M9Jk2aFNu2bYuInffVyIdczHVFRUU8++yzTZbdcMMN8fDDD8cdd9yRDTM7UvfKyg7fZ3u0d66PPfbY6NevX8yePXuXwOPuu++O5cuXZy9/dcQRR0RdXV08/fTT8U//9E8REbFo0aKoq6vbbVjSGkuWLMmeRwAAAAC0jUtatUFDQ8Mu12svLi5ucimV+vr6Xdr07t07Kioq4thjj40xY8bEtGnT4j//8z9j/fr1ceGFF8ZZZ50VFRUV2fbPP/98bNu2LdavXx/19fWxdOnSiIgYN25cROz8a+YhQ4bEqFGjIiJiwYIF8YMf/CDOP//8PBz1vqGzzO3UqVPjiiuuiDPPPDMuv/zyePvtt2PWrFkxc+ZMl7Nqge7du8eyZcuy/96dzjDX3bp1i7Fjxzbpv7q6Onr16rXLcnavvXNdVlYWP/nJT+KUU06Js88+O84777yoqKiIP/7xjzFr1qz44he/GCeddFJE7PyW1aRJk+Kss86Kn/zkJxERcfbZZ8cJJ5wQI0eOzPb90ksvxaZNm2LNmjWxZcuW7JyPGTMmevbsGT/72c+iR48eMX78+OjWrVvcc889ce2118b3v//9XD88AAAAAPuWhF1Mnz49mTJlyh7XRcQuPyNHjsy2GTp06G7bnHPOOdk2r776anL88ccnpaWlSb9+/ZLzzjsv2bp1a5N97amf91177bXJwQcfnPTu3TupqKhIxo8fn9xwww3Jjh07cvuAdCFpmdskSZJly5Yln/nMZ5LS0tJk0KBByTe+8Y1k8+bNuXswupi9zW2SJMmUKVOS6dOnZ9t2prn+oEsvvTQ59NBD2/QY7CtyPddJkiSPP/54MmnSpCSTySQ9e/ZMxowZk/zgBz9I3nvvvSbtamtrk9NOOy0pLy9PysvLk9NOOy3ZsGFDkzZHHXXUbve5YsWKJEmS5L//+7+T0aNHJ717907Ky8uTww47LPnFL37R3ocFAAAAYJ9XlCR7uFMrAAAAAABASnQr9AAAAAAAAADaS+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6hXnq+PGxsZ48803o7y8PIqKivK1GwAAAAAAIAWSJIn6+voYOHBgdOuW++9j5C3wePPNN2Pw4MH56h4AAAAAAEih119/PQYNGpTzfvMWeJSXl0fEzoFXVFTkazcAAAAAAEAKbNy4MQYPHpzND3Itb4HH+5exqqioEHgAAAAAAAAREXm7DYablgMAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEi9vAce767fnO9dQJe0avUb8YPfzo5Vq98o9FDoYtZvXR+/WjY31m9dHxE76/Rfbv9rTut1PvpMsx1r18bG2dfEjrVrCz2UnOkKx5Sr8zRN5/uHn//tbQe5lo9z74N9vl3fEDc/8lK8Xd+Qs/7Zt3XkOaU2A+RPV6mxXeU4IrrWsdCx8h54bHlna753AV3Smto18XiPh2NN7ZpCD4UuZsPW9THvhV/Fhv//TcPmDVti8bxnY/OGLTnbRz76TLMd69ZF/TVzYse6dYUeSs50hWPK1XmapvP9w8//9raDXMvHuffBPt+ub4hbHn1Z4EHOdOQ5pTYD5E9XqbFd5Tgiutax0LFc0goAAAAAAEg9gQcAAAAAAJB6xfneQcO722JLnctaQWtt27w9IiLefe/dqGuoK/Bo6Eo2bdu02+UNm3JXrxs2bctJP11N4zt1saO2ttDDyInGd7pOXWrvuZ/G833Ttk17fW3ZU52AjtLcOdravj6sfsv22PBu+p67dD71W7Z3+D5z+fwAYKeu9v63K7xWdLU5oePkPfC4/8rHorRHab53A11OXeX6iMkRs1d+P2JloUfDvuDe7/6x0EPo8mpPObXQQ2A39sVz/5KF3yn0EGCv8n2Onv/zv+S1f8gnNRyA5nitYF/mklYAAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpl/d7eBz3naNi2Ngh+d4NdDlLXlgaC968P7457KIYN/rQQg+HLmRl3YrdXs/z+P/4dFQO65uTfdSu3LBP3hehOZXzbo8eY0YXehg5sf35ZV3mniTtPffTeL5fceSVMSxz4B7X76lOQEdp7hxtjd2dz9edMSGG15TnpH/2bS+tqe/we8Lk8vkBwE5d7f1vV3it6GpzQsfJe+BRUtYzSjO98r0b6HJ69u4RERFlxWWRKckUeDR0JX169tnt8pI+uavXJX165qSfrqbbfpnoXllZ6GHkxI79uk5dau+5n8bzvU/PPnt9bdlTnYCO0tw52tq+Pqy8tEf0LUvfc5fOp7y0R4fvM5fPDwB26mrvf7vCa0VXmxM6jktaAQAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASL28Bx6l+7lhObRFTWVNfHL7MVFTWVPoodDF9O3VL04ZOTX69uoXERG9+5bGYaccEr37luZsH/noM826V1dH+Te+Ht2rqws9lJzpCseUq/M0Tef7h5//7W0HuZaPc++DfVaVl8SXP/WRqCovyVn/7Ns68pxSmwHyp6vU2K5yHBFd61joWEVJkiT56Hjjxo2RyWSirq4uKioq8rELAAAAAAAgJfKdG7ikFQAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfw6ALWb10fv1o2N9ZvXd8p+sm33Y2zvWN/u74hbn7kpXi7viEn7XIlX/vr6OMg/8xpunWW+ess4wA6H/WBQmnJ+/y2fBbYsXZtbJx9TexYu7ZN42rv9sBOrXl98VrUsQrxeJvj3POY0hnV5vl8FHh0ARu2ro95L/wqNrQzqMhVP/m2u3G2d+xv1zfELY++3KLAoyXtciVf++vo4yD/zGm6dZb56yzjADof9YFCacn7/LZ8Ftixbl3UXzMndqxb16ZxtXd7YKfWvL54LepYhXi8zXHueUzpjGo3CTwAAAAAAAD2SuABAAAAAACknsADAAAAAABIveJCD4Dc2bRtU9Q11LVr+zT54PHmauz1W7bHhne37XV9ITQ3rrb0R9eU63OFjtHZnpPOI+DDOludYt+zt8867fks0PhOXeyorW3TdkDutOT9p9eiwujIzwbmOH98xqMzqd/yXl77F3h0IZcs/E6hh9Ch8nG85//8LznvMxc667jofJwr5ILzCIDOJl+fdWpPOTUv/QKt4/1n52VuugbzSGfyXsO7ee3fJa0AAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABSzz08upArjrwyhmUObPP2K+tWpOo+IB883lyN/bozJsTwmvI9rn9pTX1BrnvY3Lhaq1DHQf7l+lyhY3S256TzCPiwzlan2Pfs7bNOez4LVM67PXqMGd3q7bY/v8z9PyCHWvL+02tRYXTkZwNznD8+49GZLF3+Zhzz/fz1L/DoQvr07BOZkky7tk+TDx5vrsZeXtoj+pb13Ov6QmhuXG3pj64p1+cKHaOzPSedR8CHdbY6xb5nb5912vNZoNt+meheWdnq7Xbs1/bPXcCuWvL+02tRYXTkZwNznD8+49GZlJfmN5JwSSsAAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3h0AX179YtTRk6Nvr36dYp+8m1342zv2KvKS+LLn/pIVJWX5KRdruRrfx19HOSfOU23zjJ/nWUcQOejPlAoLXmf35bPAt2rq6P8G1+P7tXVbRpXe7cHdmrN64vXoo5ViMfbHOeex5TOqLJPfs/HoiRJknx0vHHjxshkMlFXVxcVFRX52AUAAAAAAJAS+c4NfMMDAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/DYh7xd3xA3P/JSvF3f0Kb1AEDE+q3r41fL5sb6retbtBwAAADoGAKPfcjb9Q1xy6Mv7zXw2Nt6ACBiw9b1Me+FX8WGDwUbe1oOAAAAdAyBBwAAAAAAkHoCDwAAAAAAIPWKCz0AOl79lu2x4d1tu10OALTMpm2boq6hrsnvAAAAQOEIPPZB5//8L4UeAgCk3iULv1PoIQAAAAAf4JJWAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqeceHvug686YEMNryndZ/tKaevf3AIAWuuLIK2NY5sDs7yvrVrivBwAAABSQwGMfVF7aI/qW9dztcgCgZfr07BOZkkyT3wEAAIDCcUkrAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfw2IdUlZfElz/1kagqL2nTegAgom+vfnHKyKnRt1e/Fi0HAAAAOkZRkiRJPjreuHFjZDKZqKuri4qKinzsAgAAAAAASIl85wa+4QEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1ivPVcZIkERGxcePGfO0CAAAAAABIiffzgvfzg1zLW+BRW1sbERGDBw/O1y4AAAAAAICUqa2tjUwmk/N+8xZ49OvXLyIiXnvttbwMHEiHjRs3xuDBg+P111+PioqKQg8HKAB1AFAHgAi1AFAHgIi6uroYMmRINj/ItbwFHt267bw9SCaTUcCAqKioUAtgH6cOAOoAEKEWAOoA8H/5Qc77zUuvAAAAAAAAHUjgAQAAAAAApF7eAo+SkpK49NJLo6SkJF+7AFJALQDUAUAdACLUAkAdAPJfB4qSJEny0jMAAAAAAEAHcUkrAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqdfqwOONN96I008/PSorK6N3794xbty4WLx4cXZ9kiRx2WWXxcCBA6O0tDQ+9alPxd///vcmfTQ0NMT5558fVVVVUVZWFpMnT45Vq1a1/2iADtFcHZg/f34cd9xxUVVVFUVFRbF06dJd+lAHIP32Vgu2b98eF110URxyyCFRVlYWAwcOjDPOOCPefPPNJn2oBZBuzb0nuOyyy2LUqFFRVlYWffv2jc985jOxaNGiJn2oA5BuzdWBDzrnnHOiqKgofvjDHzZZrg5A+jVXC2bMmBFFRUVNfg4//PAmfagFkG4teU+wbNmymDx5cmQymSgvL4/DDz88Xnvttez6XNSBVgUeGzZsiIkTJ0aPHj3iD3/4Qzz//PMxe/bs2G+//bJtrr766rjmmmvi+uuvjz//+c9RU1MT//zP/xz19fXZNv/2b/8Wd955Z8ybNy8WLFgQmzZtihNOOCF27NjRqsEDHa8ldeDdd9+NiRMnxlVXXbXHftQBSLfmasHmzZvjmWeeiUsuuSSeeeaZmD9/frz44osxefLkJv2oBZBeLXlPMGLEiLj++uvj2WefjQULFsSwYcPi2GOPjbfeeivbRh2A9GpJHXjfXXfdFYsWLYqBAwfusk4dgHRraS2YNGlSrF69Ovvz+9//vsl6tQDSqyV14OWXX45PfOITMWrUqHj00Ufjr3/9a1xyySXRq1evbJuc1IGkFS666KLkE5/4xB7XNzY2JjU1NclVV12VXbZ169Ykk8kkP/7xj5MkSZJ33nkn6dGjRzJv3rxsmzfeeCPp1q1bct9997VmOEABNFcHPmjFihVJRCRLlixpslwdgPRrTS1439NPP51ERPLqq68mSaIWQNq1pQ7U1dUlEZE89NBDSZKoA5B2La0Dq1atSg444IDkueeeS4YOHZrMmTMnu04dgPRrSS2YPn16MmXKlD2uVwsg3VpSB04++eTk9NNP3+P6XNWBVn3D4+67744JEybEl770paiuro7x48fHzTffnF2/YsWKWLNmTRx77LHZZSUlJXHUUUfFwoULIyJi8eLFsX379iZtBg4cGGPHjs22ATqv5upAS6gDkH5tqQV1dXVRVFSU/QsPtQDSrbV1YNu2bXHTTTdFJpOJQw89NCLUAUi7ltSBxsbGmDZtWsyaNSsOPvjgXfpQByD9Wvqe4NFHH43q6uoYMWJEnHXWWbFu3brsOrUA0q25OtDY2Bj33ntvjBgxIo477riorq6Oj3/843HXXXdl2+SqDrQq8HjllVfixhtvjIMOOijuv//+OPfcc+OCCy6In//85xERsWbNmoiI6N+/f5Pt+vfvn123Zs2a6NmzZ/Tt23ePbYDOq7k60BLqAKRfa2vB1q1b4+KLL46pU6dGRUVFRKgFkHYtrQO/+93vok+fPtGrV6+YM2dOPPjgg1FVVRUR6gCkXUvqwPe///0oLi6OCy64YLd9qAOQfi2pBZ/97Gdj7ty58fDDD8fs2bPjz3/+cxxzzDHR0NAQEWoBpF1zdWDdunWxadOmuOqqq2LSpEnxwAMPxBe+8IU48cQT47HHHouI3NWB4tYMvLGxMSZMmBDf+973IiJi/Pjx8fe//z1uvPHGOOOMM7LtioqKmmyXJMkuyz6sJW2AwmtpHWgLdQDSozW1YPv27XHKKadEY2Nj3HDDDc32rRZAOrS0Dhx99NGxdOnSePvtt+Pmm2+Ok046KRYtWhTV1dV77FsdgHRorg4sXrw4/uu//iueeeaZVj+n1QFIj5a8Jzj55JOz7ceOHRsTJkyIoUOHxr333hsnnnjiHvtWCyAdmqsDjY2NERExZcqU+PrXvx4REePGjYuFCxfGj3/84zjqqKP22Hdr60CrvuExYMCAGDNmTJNlo0ePzt5JvaamJiJil8Rl3bp12W991NTUxLZt22LDhg17bAN0Xs3VgZZQByD9WloLtm/fHieddFKsWLEiHnzwwey3OyLUAki7ltaBsrKyGD58eBx++OFxyy23RHFxcdxyyy0RoQ5A2jVXB5544olYt25dDBkyJIqLi6O4uDheffXV+OY3vxnDhg2LCHUAuoK2/D/BgAEDYujQobF8+fKIUAsg7ZqrA1VVVVFcXNxstpCLOtCqwGPixInxwgsvNFn24osvxtChQyMi4sADD4yampp48MEHs+u3bdsWjz32WBx55JEREXHYYYdFjx49mrRZvXp1PPfcc9k2QOfVXB1oCXUA0q8lteD9sGP58uXx0EMPRWVlZZP2agGkW1vfEyRJkr18hToA6dZcHZg2bVr87W9/i6VLl2Z/Bg4cGLNmzYr7778/ItQB6Ara8p6gtrY2Xn/99RgwYEBEqAWQds3VgZ49e8Y//uM/7rVNzupAi29vniTJ008/nRQXFydXXnllsnz58mTu3LlJ7969k1/+8pfZNldddVWSyWSS+fPnJ88++2xy6qmnJgMGDEg2btyYbXPuuecmgwYNSh566KHkmWeeSY455pjk0EMPTd57773WDAcogJbUgdra2mTJkiXJvffem0REMm/evGTJkiXJ6tWrs23UAUi35mrB9u3bk8mTJyeDBg1Kli5dmqxevTr709DQkO1HLYD0aq4ObNq0Kfn2t7+d/OlPf0pWrlyZLF68OPnyl7+clJSUJM8991y2H3UA0qslnw0+bOjQocmcOXOaLFMHIN2aqwX19fXJN7/5zWThwoXJihUrkkceeSQ54ogjkgMOOMD/F0IX0ZL3BPPnz0969OiR3HTTTcny5cuT6667LunevXvyxBNPZNvkog60KvBIkiS55557krFjxyYlJSXJqFGjkptuuqnJ+sbGxuTSSy9NampqkpKSkuSTn/xk8uyzzzZps2XLluS8885L+vXrl5SWliYnnHBC8tprr7V2KECBNFcHbrvttiQidvm59NJLs23UAUi/vdWCFStW7LYORETyyCOPZNupBZBue6sDW7ZsSb7whS8kAwcOTHr27JkMGDAgmTx5cvL000836UMdgHRr7rPBh+0u8FAHIP32Vgs2b96cHHvsscn++++f9OjRIxkyZEgyffr0XZ7nagGkW0veE9xyyy3J8OHDk169eiWHHnpoctdddzVZn4s6UJQkSdKKb6cAAAAAAAB0Oq26hwcAAAAAAEBnJPAAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AACAdrvsssti3LhxhR4GAACwDytKkiQp9CAAAIDOq6ioaK/rp0+fHtdff300NDREZWVlB40KAACgKYEHAACwV2vWrMn++9e//nV897vfjRdeeCG7rLS0NDKZTCGGBgAAkOWSVgAAwF7V1NRkfzKZTBQVFe2y7MOXtJoxY0Z8/vOfj+9973vRv3//2G+//eLyyy+P9957L2bNmhX9+vWLQYMGxa233tpkX2+88UacfPLJ0bdv36isrIwpU6bEypUrO/aAAQCAVBJ4AAAAefHwww/Hm2++GY8//nhcc801cdlll8UJJ5wQffv2jUWLFsW5554b5557brz++usREbF58+Y4+uijo0+fPvH444/HggULok+fPjFp0qTYtm1bgY8GAADo7AQeAABAXvTr1y+uvfbaGDlyZMycOTNGjhwZmzdvjn//93+Pgw46KL797W9Hz54948knn4yIiHnz5kW3bt3ipz/9aRxyyCExevTouO222+K1116LRx99tLAHAwAAdHrFhR4AAADQNR188MHRrdv//Y1V//79Y+zYsdnfu3fvHpWVlbFu3bqIiFi8eHG89NJLUV5e3qSfrVu3xssvv9wxgwYAAFJL4AEAAORFjx49mvxeVFS022WNjY0REdHY2BiHHXZYzJ07d5e+9t9///wNFAAA6BIEHgAAQKfwsY99LH79619HdXV1VFRUFHo4AABAyriHBwAA0CmcdtppUVVVFVOmTIknnngiVqxYEY899lh87Wtfi1WrVhV6eAAAQCcn8AAAADqF3r17x+OPPx5DhgyJE088MUaPHh0zZ86MLVu2+MYHAADQrKIkSZJCDwIAAAAAAKA9fMMDAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOr9fw+gShyFf/1LAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } ], - "layout": "IPY_MODEL_a02030ba8f324d93a7ed6cc793d70a3b" - } - }, - "d33fba0d78fb41f983c55f5cd2a0a740": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d7071582bfbe4ec4b2c3c9843e5481ae": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e1c9df12fa034c93a9b3530ea4a7c5aa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "e3169ca885e04536a709d5751173ce9a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_358c3a67f8b54c4c899e095611fa116b", - "placeholder": "​", - "style": "IPY_MODEL_e1c9df12fa034c93a9b3530ea4a7c5aa", - "value": " 318/318 [00:00<00:00, 11.0kB/s]" - } - }, - "e4c1e9affaba4045a3ec903091b6f454": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e7728d9c55e44274966f8f6dbc445c54": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e928540e99564d808cb2d12c92daa498": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c9974003727a401797953ef2885db5a2", - "placeholder": "​", - "style": "IPY_MODEL_77a361d1ff214e8799891bbeb28a0789", - "value": "Downloading: 100%" - } - }, - "e98cf7a63c814ffd94f69928f0700ebf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_aba21021d3bb4565a58ffa40049810db", - "placeholder": "​", - "style": "IPY_MODEL_f7812fa7fbf744c1b261b985d085e28e", - "value": "Downloading: 100%" - } - }, - "ea95ffd922c0455d957120f034e541f8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "eae11f84c2644ada8295b445c924baec": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2cbf0faadd4842c8b22e10541ff9de4e", - "placeholder": "​", - "style": "IPY_MODEL_ab32c7daa1d9404fb921f39fbc4fc05c", - "value": "Downloading: 100%" - } - }, - "ebc9801e164a44b3b6f8dc7f590e1c79": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ecd8e5e364d34ea8bfbba4fbd467384d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_554e567a83b348f88092c6ba01830930", - "placeholder": "​", - "style": "IPY_MODEL_6e334cad2e94462cae6e722bd6f11a9e", - "value": "Downloading: 100%" - } - }, - "ed169fd606274f2ebbb3e8f32ab42431": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ee537ee5470f4d7b816a8c8f96948b4d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f21c0c6379d74898ac6aadcb6fc14a8a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f439c1de68ac4c799d81fdb29d053d10": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f7812fa7fbf744c1b261b985d085e28e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f91dcd9f30c743d69f9d4b7e8d1beba5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2b2d7912186a49dd9891ae12c77482c7", - "placeholder": "​", - "style": "IPY_MODEL_1600b9cd09c446e581b7912e35c9f56e", - "value": " 83.3M/83.3M [00:01<00:00, 60.9MB/s]" - } - }, - "fc9a3c4ae0a947ec91a227360a80f602": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_27f6f437c5264368bc2c679942ad1e53", - "max": 83316686, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e7728d9c55e44274966f8f6dbc445c54", - "value": 83316686 - } - }, - "fd47487fc8734594823f8afa00c4239d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } + "source": [ + "groundtruth" + ] }, - "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]" - } + { + "cell_type": "markdown", + "metadata": { + "id": "MxlrTbyPYnqB" + }, + "source": [ + "# Going further\n", + "\n", + "We have only scratched the surface in this introduction.\n", + "\n", + "More details can be found in the [`pyannote.audio` Github repository](https://github.com/pyannote/pyannote-audio).\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "0e382d66f09f4958a40baa7ab83c4ccb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "13525aa369a9410a83343952ab511f3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "333b42ca7aa44788b1c22724eb11bcc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3499ef4dd9f243d9bef00b396e78ed69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "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": "" + } + }, + "765485a1d3f941d28b79782dcffbf401": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "79184c8c2a6f4b7493bb7f6983f18a09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "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.
" + } + }, + "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.
" + } + }, + "b2be65e192384c948fb8987d4cfca505": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba18cded436e486da34882d821d8f1eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_0e382d66f09f4958a40baa7ab83c4ccb", + "style": "IPY_MODEL_6a45ce374e2e47ba9457d02e02522748", + "tooltip": "" + } + }, + "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" + } + }, + "ea95ffd922c0455d957120f034e541f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } } - } - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 54ddfa362e7a0e3ef523b6570c318c0d4d676991 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 16 Nov 2023 20:44:06 +0100 Subject: [PATCH 21/57] doc: add progress bar hook --- tutorials/intro.ipynb | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index 2df5081c3..2aaa911f7 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -429,8 +429,10 @@ "if torch.cuda.is_available():\n", " pipeline.to(torch.device('cuda'))\n", "\n", - "# run the pipeline\n", - "diarization = pipeline(DEMO_FILE)" + "# run the pipeline (with progress bar)\n", + "from pyannote.audio.pipelines.utils.hook import ProgressHook\n", + "with ProgressHook() as hook:\n", + " diarization = pipeline(DEMO_FILE, hook=hook)" ] }, { From 1882ff17683e8380ba4cb20e796385753595e48d Mon Sep 17 00:00:00 2001 From: Ohad Hen Date: Fri, 17 Nov 2023 10:25:01 +0200 Subject: [PATCH 22/57] doc(setup): update ipython (8.10.0) and Sphinx (3.0.4) (#1391) https://security.snyk.io/package/pip/Sphinx/2.2.2 https://security.snyk.io/package/pip/ipython/7.16.3 --- doc/requirements.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/requirements.txt b/doc/requirements.txt index a0b596dbc..5377da241 100644 --- a/doc/requirements.txt +++ b/doc/requirements.txt @@ -1,4 +1,4 @@ -ipython==7.16.3 +ipython==8.10.0 recommonmark -Sphinx==2.2.2 +Sphinx==3.0.4 sphinx_rtd_theme==0.4.3 From 28b5531cec35c70b7f0353a502061dcd1dd11e1d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 24 Nov 2023 12:36:30 +0100 Subject: [PATCH 23/57] doc: add code of conduct (#1560) --- CODE_OF_CONDUCT.md | 128 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 CODE_OF_CONDUCT.md diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 000000000..b53ae3b44 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,128 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, religion, or sexual identity +and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the + overall community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or + advances of any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email + address, without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +herve.bredin@irit.fr. +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series +of actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or +permanent ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within +the community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.0, available at +https://www.contributor-covenant.org/version/2/0/code_of_conduct.html. + +Community Impact Guidelines were inspired by [Mozilla's code of conduct +enforcement ladder](https://github.com/mozilla/diversity). + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see the FAQ at +https://www.contributor-covenant.org/faq. Translations are available at +https://www.contributor-covenant.org/translations. From b4ed44bb23717c794b71ac086d397f64471bb83a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 1 Dec 2023 14:09:32 +0100 Subject: [PATCH 24/57] fix(pipeline): fix support for setting `num_speakers` in diarization pipeline --- CHANGELOG.md | 8 ++++++++ pyannote/audio/pipelines/clustering.py | 9 ++++++++- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 346d8ad26..3e0a93dbe 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ ## `develop` branch +### TL;DR + +Providing `num_speakers` to [`pyannote/speaker-diarization-3.1`](https://hf.co/pyannote/speaker-diarization-3.1) now [works as expected](https://github.com/pyannote/pyannote-audio/issues/1567). + +### Fixes + +- fix(pipeline): fix support for setting `num_speakers` in [`pyannote/speaker-diarization-3.1`](https://hf.co/pyannote/speaker-diarization-3.1) pipeline + ## Version 3.1.0 (2023-11-16) ### TL;DR diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index b63ab214f..80098ea24 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -97,7 +97,13 @@ def filter_embeddings( speaker_idx : (num_embeddings, ) array """ - chunk_idx, speaker_idx = np.where(~np.any(np.isnan(embeddings), axis=2)) + # whether speaker is active + active = np.sum(segmentations.data, axis=1) > 0 + # whether speaker embedding extraction went fine + valid = ~np.any(np.isnan(embeddings), axis=2) + + # indices of embeddings that are both active and valid + chunk_idx, speaker_idx = np.where(active * valid) # sample max_num_embeddings embeddings num_embeddings = len(chunk_idx) @@ -240,6 +246,7 @@ def __call__( ) num_embeddings, _ = train_embeddings.shape + num_clusters, min_clusters, max_clusters = self.set_num_clusters( num_embeddings, num_clusters=num_clusters, From 1a8f619924794f2edf96d87994ff9d9a25ba1d6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 1 Dec 2023 14:17:43 +0100 Subject: [PATCH 25/57] doc: getting ready for 3.1.1 --- README.md | 65 ++++++++++++++++++++++--------------------- tutorials/intro.ipynb | 22 +++++++-------- version.txt | 2 +- 3 files changed, 45 insertions(+), 44 deletions(-) diff --git a/README.md b/README.md index b7621210e..a82a2488f 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -Using `pyannote.audio` open-source toolkit in production? +Using `pyannote.audio` open-source toolkit in production? Make the most of it thanks to our [consulting services](https://herve.niderb.fr/consulting.html). # `pyannote.audio` speaker diarization toolkit @@ -9,15 +9,13 @@ Make the most of it thanks to our [consulting services](https://herve.niderb.fr/

- ## TL;DR -1. Install [`pyannote.audio`](https://github.com/pyannote/pyannote-audio) `3.1` with `pip install pyannote.audio` +1. Install [`pyannote.audio`](https://github.com/pyannote/pyannote-audio) with `pip install pyannote.audio` 2. Accept [`pyannote/segmentation-3.0`](https://hf.co/pyannote/segmentation-3.0) user conditions 3. Accept [`pyannote/speaker-diarization-3.1`](https://hf.co/pyannote/speaker-diarization-3.1) user conditions 4. Create access token at [`hf.co/settings/tokens`](https://hf.co/settings/tokens). - ```python from pyannote.audio import Pipeline pipeline = Pipeline.from_pretrained( @@ -47,50 +45,53 @@ for turn, _, speaker in diarization.itertracks(yield_label=True): - :snake: Python-first API - :zap: multi-GPU training with [pytorch-lightning](https://pytorchlightning.ai/) - ## Documentation - [Changelog](CHANGELOG.md) - [Frequently asked questions](FAQ.md) - Models - - Available tasks explained - - [Applying a pretrained model](tutorials/applying_a_model.ipynb) - - [Training, fine-tuning, and transfer learning](tutorials/training_a_model.ipynb) + - Available tasks explained + - [Applying a pretrained model](tutorials/applying_a_model.ipynb) + - [Training, fine-tuning, and transfer learning](tutorials/training_a_model.ipynb) - 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) + - 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) - - [Adding a new task](tutorials/add_your_own_task.ipynb) - - Adding a new pipeline - - Sharing pretrained models and pipelines + - [Adding a new model](tutorials/add_your_own_model.ipynb) + - [Adding a new task](tutorials/add_your_own_task.ipynb) + - 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) + - 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) - Videos - [Introduction to speaker diarization](https://umotion.univ-lemans.fr/video/9513-speech-segmentation-and-speaker-diarization/) / JSALT 2023 summer school / 90 min - [Speaker segmentation model](https://www.youtube.com/watch?v=wDH2rvkjymY) / Interspeech 2021 / 3 min - - [First releaase of pyannote.audio](https://www.youtube.com/watch?v=37R_R82lfwA) / ICASSP 2020 / 8 min + - [First releaase of pyannote.audio](https://www.youtube.com/watch?v=37R_R82lfwA) / ICASSP 2020 / 8 min ## Benchmark -Out of the box, `pyannote.audio` speaker diarization [pipeline](https://hf.co/pyannote/speaker-diarization-3.1) v3.1 is expected to be much better (and faster) than v2.x. +Out of the box, `pyannote.audio` speaker diarization [pipeline](https://hf.co/pyannote/speaker-diarization-3.1) v3.1 is expected to be much better (and faster) than v2.x. Those numbers are diarization error rates (in %): -| Dataset \ Version | v1.1 | [v2.1](https://hf.co/pyannote/speaker-diarization-2.1) | [v3.1](https://hf.co/pyannote/speaker-diarization-3.1) | Premium | -| ---------------------- | ---- | ----- | ------ | --------- | -| AISHELL-4 | - | 14.1 | 12.2 | 12.3 | -| AliMeeting (channel 1) | - | 27.4 | 24.4 | 19.4 | -| AMI (IHM) | 29.7 | 18.9 | 18.8 | 16.7 | -| AMI (SDM) | - | 27.1 | 22.4 | 20.1 | -| AVA-AVD | - | - | 50.0 | 42.7 | -| DIHARD 3 (full) | 29.2 | 26.9 | 21.7 | 17.0 | -| MSDWild | - | - | 25.3 | 20.4 | -| REPERE (phase2) | - | 8.2 | 7.8 | 7.8 | -| VoxConverse (v0.3) | 21.5 | 11.2 | 11.3 | 9.5 | +| Benchmark | [v2.1](https://hf.co/pyannote/speaker-diarization-2.1) | [v3.1](https://hf.co/pyannote/speaker-diarization-3.1) | [Premium](https://forms.gle/eKhn7H2zTa68sMMx8) | +| ---------------------- | ------------------------------------------------------ | ------------------------------------------------------ | ---------------------------------------------- | +| AISHELL-4 | 14.1 | 12.3 | 11.9 | +| AliMeeting (channel 1) | 27.4 | 24.5 | 22.5 | +| AMI (IHM) | 18.9 | 18.8 | 16.6 | +| AMI (SDM) | 27.1 | 22.6 | 20.9 | +| AVA-AVD | 66.3 | 50.0 | 39.8 | +| CALLHOME (part 2) | 31.6 | 28.4 | 22.2 | +| DIHARD 3 (full) | 26.9 | 21.4 | 17.2 | +| Ego4D (dev.) | 61.5 | 51.2 | 43.8 | +| MSDWild | 32.8 | 25.4 | 19.8 | +| REPERE (phase2) | 8.2 | 7.8 | 7.6 | +| VoxConverse (v0.3) | 11.2 | 11.2 | 9.4 | + +[Diarization error rate](http://pyannote.github.io/pyannote-metrics/reference.html#diarization) (in %) ## Citations diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index 2aaa911f7..572ea2f6d 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -3,8 +3,8 @@ { "cell_type": "markdown", "metadata": { - "id": "view-in-github", - "colab_type": "text" + "colab_type": "text", + "id": "view-in-github" }, "source": [ "\"Open" @@ -53,7 +53,7 @@ }, "outputs": [], "source": [ - "!pip install -qq pyannote.audio==3.1.0\n", + "!pip install -qq pyannote.audio==3.1.1\n", "!pip install -qq ipython==7.34.0" ] }, @@ -115,7 +115,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -157,7 +157,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -458,7 +458,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -544,7 +544,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjwAAADyCAYAAAD5q2z1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAqrUlEQVR4nO3de5hVdb0/8M/AMMPcuclNbpYBIl7hd5LoydRUvARpJikiRik8J7Urx0vmJbPUE2JWWiqCFkWmQJZFXhIEQVSEE6YHUVFQQRRwYIDhNuv3hw/7OA4wMzC3Nb5ezzPPM7PWd3+/373X2p+1Z7/3XisrSZIkAAAAAAAAUqxFY08AAAAAAABgfwk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB67ccEFF0RWVlaVn1deeWWP64YMGZK5fa9evXbb5sYbb8y0WbFiRXzxi1+MgoKC6NChQ1x66aWxbdu2zPry8vK44IIL4rDDDovs7Oz40pe+VGWec+fOjcGDB0f79u0jLy8v+vbtGxMmTKjXxybt0rJtIyK2bt0aP/jBD6Jnz56Rm5sbn/zkJ+Oee+6pt8cm7XZtv7Fjx1ZZ95//+Z+RlZUVF1xwQaW2TWVb7/LUU09FdnZ2HHnkkfv1WDR3db2tIyLmzZsXp556arRt2zZat24dhx12WIwfPz527txZqd369etj5MiRUVJSEiUlJTFy5Mh4//33K7X51re+FQMGDIjc3NzdbsvXX399t3OaOXPmfj0uzdmaNWtizJgx0aNHj8jNzY3OnTvHySefHPPnz4+Iys/X/Pz86N+/f/zmN7/J3H7y5Mm7fcxbt25dZax58+ZFy5Ytq+wjEf+37RYvXpxZtnHjxvj85z8fffv2jZUrV0ZE7HasrKysmDp1akREzJo1q9Ly9u3bx/HHHx9PPfVUrR6XBx98MPr16xe5ubnRr1+/mD59eqX1d9xxRxx++OFRXFwcxcXFMWjQoPj73/9eqzEAAAAgTbIbY9D1m7ZV36gOtS3IqfVthgwZEpMmTaq07IADDtjjutzc3Ep//+hHP4oLL7yw0rKioqKIiNi5c2ecdtppccABB8TcuXNj7dq1MWrUqEiSJH7xi19k2uTl5cWll14aDz744G7nWFBQEBdffHEcfvjhUVBQEHPnzo0xY8ZEQUFBXHTRRbW+z3WhdGtpg41VkluyT7dLw7aNiDj77LPjnXfeiYkTJ8bBBx8ca9asiR07duzTfd5fW0rLG3S8vJKqb0LWRPfu3WPq1KkxYcKEyMvLi4gPQoc//OEP0aNHj0ptm9K2jogoLS2N888/P0444YR45513an/n68jOtWsbdLyW7dvv0+3qcltPnz49zj777Pja174WTzzxRLRp0yYee+yx+K//+q94+umn4/7774+srKyIiDj33HPjzTffzIQTF110UYwcOTL+8pe/ZPpLkiRGjx4dCxYsiH/96197vA+PPfZYHHrooZm/27Vrt0+Pxf7asmVLg463a3vVxpe//OXYvn173HvvvfGJT3wi3nnnnXj88cdj3bp1mTa7nq9lZWUxefLkGDt2bLRp0yaGDx8eERHFxcWxdOnSSv3u2q4fds8998Qll1wSd999d6xYsaLK/vRh7777bpxyyikR8cGHEDp06JBZN2nSpCqhSZs2bSr9vXTp0iguLo533303fvzjH8dpp50WL7/8cnTs2LHax2T+/PkxfPjwuP766+OMM87I7Mdz586NT3/60xER0a1bt7jxxhvj4IMPjoiIe++9N4YNGxaLFi2qtO8BAABAc9EogccpNz/RoOM9fd3Jtb7Nrk+Q1nbdLkVFRXts88gjj8SLL74YK1eujK5du0ZExPjx4+OCCy6IG264IYqLi6OgoCDuuOOOiPjgU98f/QRxRMRRRx0VRx11VObvXr16xbRp02LOnDmNFniM/Pu5DTbWQ196eJ9ul4ZtO3PmzJg9e3a89tprmTdBe/XqVcN7WPfuO/+BBh1vzJ/P26fbHX300fHaa6/FtGnTYsSIERERMW3atOjevXt84hOfqNS2qWzrXcaMGRPnnntutGzZMmbMmFHDe1z3Vh9+ZIOOd+BbK/fpdnW1rTdt2hQXXnhhDB06NO68887M8m984xvRqVOnGDp0aNx///0xfPjweOmll2LmzJnx9NNPZ95Qvuuuu2LQoEGxdOnS6NOnT0RE3HbbbRHxwZvhews82rdvX+0+2BB++9vfNuh4tT0+vf/++zF37tyYNWtWHHvssRER0bNnz/iP//iPSu0+/Hz98Y9/HPfff3/MmDEjE3hkZWVV+3hv2rQp7r///nj22Wdj9erVMXny5Lj66qt323blypVx4oknRpcuXeKhhx7KhKG7tGnTptrxOnbsmGl31VVXxf333x8LFiyIL37xi3u9XUTErbfeGieeeGJcccUVERFxxRVXxOzZs+PWW2+NP/zhDxERVfq54YYb4o477oinn35a4AEAAECz5JRWjWD+/PnRv3//zJukEREnn3xybN26NRYuXLjP/S5atCjmzZuXeUOIhldX2/ahhx6KgQMHxs033xwHHnhg9O7dO77//e83+Cex0+hrX/tapU/z33PPPTF69Og6H6cun8eTJk2KV199Na655pq6nmazVhfb+pFHHom1a9fG97///SrrvvjFL0bv3r0zbx7Pnz8/SkpKMmFHRMQxxxwTJSUlMW/evFrPf+jQodGxY8cYPHhwPPBAw4aKaVJYWBiFhYUxY8aM2Lp1a41v17p169i+fXutxvrjH/8Yffr0iT59+sR5550XkyZNiiRJqrRbunRpDB48OPr27RszZ86sEnbU1ubNmzP7cqtWrWp0m/nz58dJJ51UadnJJ5+8x31x586dMXXq1Ni0aVMMGjRov+YLAAAATZXAYw/++te/Zt5kKSwsjK985St7XFdYWBjXX399pdtfdtllVdrMmjUrIiJWr14dnTp1qtS+bdu2kZOTE6tXr671XLt16xa5ubkxcODA+OY3vxnf+MY3an+HP0bSsG1fe+21mDt3brzwwgsxffr0uPXWW+OBBx6Ib37zm/t+xz8mRo4cGXPnzo3XX3893njjjXjqqafivPOqfmOkqWzrZcuWxeWXXx5TpkyJ7OxG+dJdatXFtn755ZcjIuKQQw7Z7Rh9+/bNtFm9evVuTzXUsWPHWm3zwsLCuOWWW+KBBx6Iv/3tb3HCCSfE8OHD43e/+12N+/g4yc7OjsmTJ8e9994bbdq0icGDB8eVV165x2/P7NixIyZPnhxLliyJE044IbO8tLS0yn7w0cBg4sSJmX1oyJAhUVZWFo8//niVMc4///z45Cc/GQ8++GCVU+Htcs4551QZ77XXXqvUplu3bpl1EyZMiAEDBlSa897srgZ16tSpyr64ZMmSKCwsjNzc3Bg7dmxMnz49+vXrV6MxAAAAIG28u7YHxx13XOZUNBEfXC9jT+siqp57fdy4cZmL5u5y4IEHZn7f3XnDkyTZ7fLqzJkzJ8rKyuLpp5+Oyy+/PA4++OA455xzat3Px0Uatm1FRUVkZWXFlClToqTkg2uV3HLLLXHWWWfFr371q306B/7HRYcOHeK0006Le++9N5IkidNOO63SefV3aQrbeufOnXHuuefGddddF717967Rbfg/dbmtd/cp/l3LP7w96+L53aFDh/jOd76T+XvgwIGxfv36uPnmm3cb2PDBNTxOO+20mDNnTsyfPz9mzpwZN998c9x9992Z5+hll10WV111VWzdujVycnJi3LhxMWbMmEwfRUVF8fzzz1fq98O1dOnSpfHMM8/EtGnTIuKDoGX48OFxzz33xBe+8IVKtxs2bFhMnz49HnzwwTj77LN3O+cJEyZUuV337t0r/T1nzpwoKCiIRYsWxWWXXRaTJ0+u8Tc8Iqruj7vbF/v06ROLFy+O999/Px588MEYNWpUzJ49W+gBAABAs9Qogcff/+u4xhi2VgoKCjIX+azNul06dOiwxzadO3eOBQsWVFq2fv362L59e5VPa9bEQQcdFBERhx12WLzzzjtx7bXXNlrg8dtTft8o49ZGGrZtly5d4sADD8yEHREffAI9SZJ4880341Of+lSN+6oL5993VoOOt79Gjx4dF198cURE/OpXv9ptm6awrTdu3BjPPfdcLFq0KDPfioqKSJIksrOz45FHHonjjz++Rn3Vlc7/Wtyg4+2v/d3Wu4Kml156KT7zmc9UWf+///u/mTeGO3fuvNsLyr/77rv7VLs/7Jhjjom77757v/rYVyNHjmyUcWurdevWceKJJ8aJJ54YV199dXzjG9+Ia665JhN47Aoo8/Pzo0uXLlXe+G/RosVen/MTJ06MHTt2VAo1kySJVq1axfr166Nt27aZ5VdeeWUcfvjhMWLEiEiSJHOdkA/r3LlztTXmoIMOijZt2kTv3r2jvLw8zjjjjHjhhRf2+K2Rj/b/0W9zrFmzpsq+mJOTk5nHwIED49lnn42f//zn8Zvf/KbaMQAAACBtGiXwaFuQ0xjDNhmDBg2KG264IVatWhVdunSJiA/OI5+bmxsDBgzYr76TJKnVOc7rWkluSfWNmrG62raDBw+OP/3pT1FWVhaFhYUR8cGpd1q0aBHdunWrl7nvTV5J6wYfc38MGTIktm3bFhEfnNO+PtTFti4uLo4lS5ZUWnb77bfHP//5z3jggQcyYWZDatm+fYOPuT/2d1ufdNJJ0a5duxg/fnyVwOOhhx6KZcuWZU5/NWjQoCgtLY1nnnkmc8HsBQsWRGlp6W7DktpYtGhRZj9qaGn9xli/fv1ixowZmb/3FlBWZ8eOHXHffffF+PHjq5zm6stf/nJMmTIlE6ztctVVV0V2dnaMGDEiKioq9vuDBiNHjowf/ehHcfvtt1f6BtCeDBo0KB599NFKbR955JFq98XGfp0AAAAA9ckprfbB1q1bq3yqMjs7u9KpVDZu3FilTX5+fhQXF8dJJ50U/fr1i5EjR8Z///d/x7p16+L73/9+XHjhhVFcXJxp/+KLL8a2bdti3bp1sXHjxli8eHFERBx55JER8cGnmXv06BF9+/aNiIi5c+fGz372s7jkkkvq4V5/PDSVbXvuuefG9ddfH1/72tfiuuuui/feey/GjRsXo0ePTu2bkw2pZcuW8dJLL2V+352msK1btGgR/fv3r9R/x44do3Xr1lWWs3v7u60LCgriN7/5TXz1q1+Niy66KC6++OIoLi6Oxx9/PMaNGxdnnXVW5pRFhxxySAwZMiQuvPDCzKfjL7roojj99NOjT58+mb5feeWVKCsri9WrV8eWLVsy27xfv36Rk5MT9957b7Rq1SqOOuqoaNGiRfzlL3+J2267LW666aa6fniahbVr18ZXvvKVGD16dBx++OFRVFQUzz33XNx8880xbNiwGveTJMlur7XSsWPH+Otf/xrr16+Pr3/965W+WRcRcdZZZ8XEiROrBB4REZdffnm0bNkyRo4cGRUVFTFixIjMuvfff7/KeEVFRZVOo/hhLVq0iG9/+9vx4x//OMaMGRP5+fl7vT/f+ta34nOf+1zcdNNNMWzYsPjzn/8cjz32WMydOzfT5sorr4xTTjklunfvHhs3boypU6fGrFmzYubMmXvtGwAAAFIroYpRo0Ylw4YN2+O6iKjy06dPn0ybnj177rbNmDFjMm3eeOON5LTTTkvy8vKSdu3aJRdffHFSXl5eaaw99bPLbbfdlhx66KFJfn5+UlxcnBx11FHJ7bffnuzcubNuH5BmJC3bNkmS5KWXXkq+8IUvJHl5eUm3bt2S7373u8nmzZvr7sFoZva2bZMkSYYNG5aMGjUq07YpbesPu+aaa5Ijjjhinx6Dj4u63tZJkiRPPvlkMmTIkKSkpCTJyclJ+vXrl/zsZz9LduzYUand2rVrkxEjRiRFRUVJUVFRMmLEiGT9+vWV2hx77LG7HXP58uVJkiTJ5MmTk0MOOSTJz89PioqKkgEDBiS//e1v9/dhabbKy8uTyy+/PDn66KOTkpKSJD8/P+nTp09y1VVXZWpiz549kwkTJuyxj0mTJu12m0REsmrVquT0009PTj311N3eduHChUlEJAsXLkyWL1+eRESyaNGiSm3Gjx+ftGzZMrnvvvuSJEn2ONZPf/rTJEmS5Iknnkgiosq+U1ZWlrRt2za56aabavTY/OlPf0r69OmTtGrVKunbt2/y4IMPVlo/evTopGfPnklOTk5ywAEHJCeccELyyCOP1KhvAAAASKOsJNnDlVoBAAAAAABSokVjTwAAAAAAAGB/CTwAAJqYwsLCPf7MmTOnsacHAAAATZJTWgEANDGvvPLKHtcdeOCBkZeX14CzAQAAgHQQeAAAAAAAAKnnlFYAAAAAAEDqCTwAAAAAAIDUy66vjisqKuLtt9+OoqKiyMrKqq9hAAAAAACAFEiSJDZu3Bhdu3aNFi3q/vsY9RZ4vP3229G9e/f66h4AAAAAAEihlStXRrdu3eq833oLPIqKiiLig4kXFxfX1zAAAAAAAEAKbNiwIbp3757JD+pavQUeu05jVVxcLPAAAAAAAAAiIurtMhguWg4AAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUq/eA49N6zbX9xDQIDat2xzP/eF/GmSfXle+Ln7/0pRYV76u3seCmrJf0tx8eJ9eu2JpzPnuqJh13bXx729eHBueey42jL8ldr7zTpXbbd68OZ577rnYvHlzpd/ToiZzTuP9onmo72ONY1k61WS7Nedt25zvG0BTl6YanJa5vvLe6rj0/unxynurG3sqNJK1G7fWa//1Hnhseb+8voeABrF5/ZZYOHVJbF6/pd7HWl++LqYu/X2sb+IHKT5e7Jc0Nx/ep0vffDXaz34xVkdWtJnx59jy4oux8ZYJsXPNmiq327x5czz//POZwGPX72lRkzmn8X7RPNT3scaxLJ1qst2a87ZtzvcNoKlLUw1Oy1xfX7s2nvl3fry+dm1jT4VGsrYs5YEHAAAAAABAfRN4AAAAAAAAqSfwAAAAAAAAUi+7vgfYumlbbCl1HQ/Sb2vZtgYfs2xbWZRuLW3wcWF3yraVNfYUoF6UbSuLlts3V/oUSFJW/f5eXp7u1zfl5eWxZcvur0uV9vtG+tXXayDHsnTb237xcdi2/jcAaHhpPL409ePFlh0fXCdwU/nOWL+p4d9ro/Ft3LKjXvuv98DjHzfMjrxWefU9DDRLP5z3g8aeAkCz98N5P4juKzbHNz+0bOcNP632dn/729/qb1INIO3zp3nzGojd+bjvFx/3+w9AzTT148X2zQdExDnx02mr4qexqrGnQyPYsXVTvfbvlFYAAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpV+/X8Dj5B8dGr/496nsYqHdrX18fD1/9eIOOef1nboheJQc16JiwJ6+XLm/y5wKFfXH9Z26Ilm1fiYibMsta/uCKaq/jceqpp0ZEeq+Fceqpp0b79u13u27t2rWpvV80D/X1GsixLN32tl98HLat/w0AGl4ajy9N/Xjx5Csvxw1L18UVZ3aJzx3ct7GnQyNYvOztOP6m6tvtq3oPPHILciKvpHV9DwP1Lrcwp8HHLMwpjJLckgYfF3anMKewsacA9aIwpzCyWuVH+YeWZRVWv7+3bp3u1zetW7eOvLy8Pa6DxlRfr4Ecy9Jtb/vFx2Hb+t8AoOGl8fjS1I8Xedn5EbEuClq3jLYFDf9eG42vKK9+IwmntAIAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB69X7R8rw2LnpJ85DfNi8GfPWwyG+7+wu81qW2rdvFV/ucG21bt6v3saCm7Jc0Nx/ep5Nun4y3ju0XnSOJ9780LLr36xfx3e9Ey44dq9wuPz8/jj766MjPz4+IqPR7Gnx0/vvaBupDfR9rHMvSqSbbrTlv2+Z83wCaujTV4LTMtVf79vEfh74cvdq3b+yp0EjaF+bWa/9ZSZIk9dHxhg0boqSkJEpLS6O4uLg+hgAAAAAAAFKivnMDp7QCAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AI+XWla+L3780JdaVr2uS/QEN472NW+OuJ16J9zZubeypANBMNYdjTXO4DzQt9ikA2HfrytfFxCV3x8Qld3svkjoj8Ei59eXrYurS38f6OioKdd0f0DDe27g1Js561T/bANSb5nCsaQ73gabFPgUA+259+br486vT48+vTvdeJHVG4AEAAAAAAKSewAMAAAAAAEi97MaeAHWjbFtZlG4trZN+gPTauGV7rN+0rbGnAUAztHHL9saeQp1xvKSuNKfnBQBAcyDwaCZ+OO8HjT0FoAm45L7nGnsKANDkOV4CAEDz5JRWAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqecaHs3E9Z+5IXqVHLTf/bxeutz1QCDFfnH+wDi4c1FjTwOAZuiV1RubzbUvHC+pK83peQEA0BwIPJqJwpzCKMktqZN+gPQqymsVbQtyGnsaADRDRXmtGnsKdcbxkrrSnJ4XAADNgVNaAQAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD0XLU+5tq3bxVf7nBttW7drkv0BDaNDUW58/fOfjA5FuY09FQCaqeZwrGkO94GmxT4FAPuubet2MeyTZ2R+h7qQlSRJUh8db9iwIUpKSqK0tDSKi4vrYwgAAAAAACAl6js3cEorAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9QQeAAAAAABA6gk8AAAAAACA1BN4AAAAAAAAqSfwAAAAAAAAUk/gAQAAAAAApJ7AAwAAAAAASD2BBwAAAAAAkHoCDwAAAAAAIPUEHgAAAAAAQOoJPAAAAAAAgNQTeAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1suur4yRJIiJiw4YN9TUEAAAAAACQErvygl35QV2rt8Bj7dq1ERHRvXv3+hoCAAAAAABImbVr10ZJSUmd91tvgUe7du0iImLFihX1MnEgHTZs2BDdu3ePlStXRnFxcWNPB2gE6gCgDgARagGgDgARpaWl0aNHj0x+UNfqLfBo0eKDy4OUlJQoYEAUFxerBfAxpw4A6gAQoRYA6gDwf/lBnfdbL70CAAAAAAA0IIEHAAAAAACQevUWeOTm5sY111wTubm59TUEkAJqAaAOAOoAEKEWAOoAUP91ICtJkqReegYAAAAAAGggTmkFAAAAAACknsADAAAAAABIPYEHAAAAAACQegIPAAAAAAAg9WodeLz11ltx3nnnRfv27SM/Pz+OPPLIWLhwYWZ9kiRx7bXXRteuXSMvLy8+//nPx7///e9KfWzdujUuueSS6NChQxQUFMTQoUPjzTff3P97AzSI6urAtGnT4uSTT44OHTpEVlZWLF68uEof6gCk395qwfbt2+Oyyy6Lww47LAoKCqJr165x/vnnx9tvv12pD7UA0q261wTXXntt9O3bNwoKCqJt27bxhS98IRYsWFCpD3UA0q26OvBhY8aMiaysrLj11lsrLVcHIP2qqwUXXHBBZGVlVfo55phjKvWhFkC61eQ1wUsvvRRDhw6NkpKSKCoqimOOOSZWrFiRWV8XdaBWgcf69etj8ODB0apVq/j73/8eL774YowfPz7atGmTaXPzzTfHLbfcEr/85S/j2Wefjc6dO8eJJ54YGzduzLT59re/HdOnT4+pU6fG3Llzo6ysLE4//fTYuXNnrSYPNLya1IFNmzbF4MGD48Ybb9xjP+oApFt1tWDz5s3x/PPPxw9/+MN4/vnnY9q0afHyyy/H0KFDK/WjFkB61eQ1Qe/eveOXv/xlLFmyJObOnRu9evWKk046Kd59991MG3UA0qsmdWCXGTNmxIIFC6Jr165V1qkDkG41rQVDhgyJVatWZX7+9re/VVqvFkB61aQOvPrqq/HZz342+vbtG7NmzYr/+Z//iR/+8IfRunXrTJs6qQNJLVx22WXJZz/72T2ur6ioSDp37pzceOONmWXl5eVJSUlJ8utf/zpJkiR5//33k1atWiVTp07NtHnrrbeSFi1aJDNnzqzNdIBGUF0d+LDly5cnEZEsWrSo0nJ1ANKvNrVgl2eeeSaJiOSNN95IkkQtgLTblzpQWlqaRETy2GOPJUmiDkDa1bQOvPnmm8mBBx6YvPDCC0nPnj2TCRMmZNapA5B+NakFo0aNSoYNG7bH9WoBpFtN6sDw4cOT8847b4/r66oO1OobHg899FAMHDgwvvKVr0THjh3jqKOOirvuuiuzfvny5bF69eo46aSTMstyc3Pj2GOPjXnz5kVExMKFC2P79u2V2nTt2jX69++faQM0XdXVgZpQByD99qUWlJaWRlZWVuYTHmoBpFtt68C2bdvizjvvjJKSkjjiiCMiQh2AtKtJHaioqIiRI0fGuHHj4tBDD63ShzoA6VfT1wSzZs2Kjh07Ru/evePCCy+MNWvWZNapBZBu1dWBioqKePjhh6N3795x8sknR8eOHePTn/50zJgxI9OmrupArQKP1157Le6444741Kc+Ff/4xz9i7Nixcemll8Z9990XERGrV6+OiIhOnTpVul2nTp0y61avXh05OTnRtm3bPbYBmq7q6kBNqAOQfrWtBeXl5XH55ZfHueeeG8XFxRGhFkDa1bQO/PWvf43CwsJo3bp1TJgwIR599NHo0KFDRKgDkHY1qQM33XRTZGdnx6WXXrrbPtQBSL+a1IJTTjklpkyZEv/85z9j/Pjx8eyzz8bxxx8fW7dujQi1ANKuujqwZs2aKCsrixtvvDGGDBkSjzzySJxxxhlx5plnxuzZsyOi7upAdm0mXlFREQMHDoyf/OQnERFx1FFHxb///e+444474vzzz8+0y8rKqnS7JEmqLPuomrQBGl9N68C+UAcgPWpTC7Zv3x5f/epXo6KiIm6//fZq+1YLIB1qWgeOO+64WLx4cbz33ntx1113xdlnnx0LFiyIjh077rFvdQDSobo6sHDhwvj5z38ezz//fK2f0+oApEdNXhMMHz48075///4xcODA6NmzZzz88MNx5pln7rFvtQDSobo6UFFRERERw4YNi+985zsREXHkkUfGvHnz4te//nUce+yxe+y7tnWgVt/w6NKlS/Tr16/SskMOOSRzJfXOnTtHRFRJXNasWZP51kfnzp1j27ZtsX79+j22AZqu6upATagDkH41rQXbt2+Ps88+O5YvXx6PPvpo5tsdEWoBpF1N60BBQUEcfPDBccwxx8TEiRMjOzs7Jk6cGBHqAKRddXVgzpw5sWbNmujRo0dkZ2dHdnZ2vPHGG/G9730vevXqFRHqADQH+/I+QZcuXaJnz56xbNmyiFALIO2qqwMdOnSI7OzsarOFuqgDtQo8Bg8eHEuXLq207OWXX46ePXtGRMRBBx0UnTt3jkcffTSzftu2bTF79uz4zGc+ExERAwYMiFatWlVqs2rVqnjhhRcybYCmq7o6UBPqAKRfTWrBrrBj2bJl8dhjj0X79u0rtVcLIN329TVBkiSZ01eoA5Bu1dWBkSNHxr/+9a9YvHhx5qdr164xbty4+Mc//hER6gA0B/vymmDt2rWxcuXK6NKlS0SoBZB21dWBnJyc+H//7//ttU2d1YEaX948SZJnnnkmyc7OTm644YZk2bJlyZQpU5L8/Pzkd7/7XabNjTfemJSUlCTTpk1LlixZkpxzzjlJly5dkg0bNmTajB07NunWrVvy2GOPJc8//3xy/PHHJ0cccUSyY8eO2kwHaAQ1qQNr165NFi1alDz88MNJRCRTp05NFi1alKxatSrTRh2AdKuuFmzfvj0ZOnRo0q1bt2Tx4sXJqlWrMj9bt27N9KMWQHpVVwfKysqSK664Ipk/f37y+uuvJwsXLky+/vWvJ7m5uckLL7yQ6UcdgPSqyf8GH9WzZ89kwoQJlZapA5Bu1dWCjRs3Jt/73veSefPmJcuXL0+eeOKJZNCgQcmBBx7o/UJoJmrymmDatGlJq1atkjvvvDNZtmxZ8otf/CJp2bJlMmfOnEybuqgDtQo8kiRJ/vKXvyT9+/dPcnNzk759+yZ33nlnpfUVFRXJNddck3Tu3DnJzc1NPve5zyVLliyp1GbLli3JxRdfnLRr1y7Jy8tLTj/99GTFihW1nQrQSKqrA5MmTUoiosrPNddck2mjDkD67a0WLF++fLd1ICKSJ554ItNOLYB021sd2LJlS3LGGWckXbt2TXJycpIuXbokQ4cOTZ555plKfagDkG7V/W/wUbsLPNQBSL+91YLNmzcnJ510UnLAAQckrVq1Snr06JGMGjWqyvNcLYB0q8lrgokTJyYHH3xw0rp16+SII45IZsyYUWl9XdSBrCRJklp8OwUAAAAAAKDJqdU1PAAAAAAAAJoigQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACknsADAADYb9dee20ceeSRjT0NAADgYywrSZKksScBAAA0XVlZWXtdP2rUqPjlL38ZW7dujfbt2zfQrAAAACoTeAAAAHu1evXqzO9//OMf4+qrr46lS5dmluXl5UVJSUljTA0AACDDKa0AAIC96ty5c+anpKQksrKyqiz76CmtLrjggvjSl74UP/nJT6JTp07Rpk2buO6662LHjh0xbty4aNeuXXTr1i3uueeeSmO99dZbMXz48Gjbtm20b98+hg0bFq+//nrD3mEAACCVBB4AAEC9+Oc//xlvv/12PPnkk3HLLbfEtddeG6effnq0bds2FixYEGPHjo2xY8fGypUrIyJi8+bNcdxxx0VhYWE8+eSTMXfu3CgsLIwhQ4bEtm3bGvneAAAATZ3AAwAAqBft2rWL2267Lfr06ROjR4+OPn36xObNm+PKK6+MT33qU3HFFVdETk5OPPXUUxERMXXq1GjRokXcfffdcdhhh8UhhxwSkyZNihUrVsSsWbMa984AAABNXnZjTwAAAGieDj300GjR4v8+Y9WpU6fo379/5u+WLVtG+/btY82aNRERsXDhwnjllVeiqKioUj/l5eXx6quvNsykAQCA1BJ4AAAA9aJVq1aV/s7KytrtsoqKioiIqKioiAEDBsSUKVOq9HXAAQfU30QBAIBmQeABAAA0CUcffXT88Y9/jI4dO0ZxcXFjTwcAAEgZ1/AAAACahBEjRkSHDh1i2LBhMWfOnFi+fHnMnj07vvWtb8Wbb77Z2NMDAACaOIEHAADQJOTn58eTTz4ZPXr0iDPPPDMOOeSQGD16dGzZssU3PgAAgGplJUmSNPYkAAAAAAAA9odveAAAAAAAAKkn8AAAAAAAAFJP4AEAAAAAAKSewAMAAAAAAEg9gQcAAAAAAJB6Ag8AAAAAACD1BB4AAAAAAEDqCTwAAAAAAIDUE3gAAAAAAACpJ/AAAAAAAABST+ABAAAAAACk3v8HUEYGyV77YKkAAAAASUVORK5CYII=", "text/plain": [ "" ] @@ -573,7 +573,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -604,8 +604,8 @@ "metadata": { "accelerator": "GPU", "colab": { - "provenance": [], - "include_colab_link": true + "include_colab_link": true, + "provenance": [] }, "kernelspec": { "display_name": "Python 3 (ipykernel)", @@ -1062,4 +1062,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/version.txt b/version.txt index fd2a01863..94ff29cc4 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -3.1.0 +3.1.1 From c657362cccc9baa74106d0413d0a4527669874e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 1 Dec 2023 14:21:52 +0100 Subject: [PATCH 26/57] doc: update changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3e0a93dbe..777f41f38 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## `develop` branch +## Version 3.1.1 (2023-12-01) ### TL;DR From 66dd72bb2b807aaf6d011c89678d85b51fb3b859 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 15 Dec 2023 16:10:51 +0100 Subject: [PATCH 27/57] feat(model): add `num_frames` and `receptive_field` to segmentation models Co-authored-by: Bilal Rahou --- CHANGELOG.md | 6 ++ pyannote/audio/models/blocks/sincnet.py | 89 ++++++++++++++++++- pyannote/audio/models/segmentation/PyanNet.py | 31 +++++++ .../audio/models/segmentation/SSeRiouSS.py | 78 ++++++++++++++++ pyannote/audio/models/segmentation/debug.py | 77 ++++++++++++++++ pyannote/audio/utils/frame.py | 80 +++++++++++++++++ 6 files changed, 359 insertions(+), 2 deletions(-) create mode 100644 pyannote/audio/utils/frame.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 777f41f38..ed30b980a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,11 @@ # Changelog +## develop branch + +### New features + +- feat(model): add `num_frames` and `receptive_field` to segmentation models + ## Version 3.1.1 (2023-12-01) ### TL;DR diff --git a/pyannote/audio/models/blocks/sincnet.py b/pyannote/audio/models/blocks/sincnet.py index 65bd6e57f..33e312ba5 100644 --- a/pyannote/audio/models/blocks/sincnet.py +++ b/pyannote/audio/models/blocks/sincnet.py @@ -28,6 +28,9 @@ import torch.nn as nn import torch.nn.functional as F from asteroid_filterbanks import Encoder, ParamSincFB +from pyannote.core import SlidingWindow + +from pyannote.audio.utils.frame import conv1d_num_frames, conv1d_receptive_field_size class SincNet(nn.Module): @@ -35,10 +38,11 @@ def __init__(self, sample_rate: int = 16000, stride: int = 1): super().__init__() if sample_rate != 16000: - raise NotImplementedError("PyanNet only supports 16kHz audio for now.") + raise NotImplementedError("SincNet only supports 16kHz audio for now.") # TODO: add support for other sample rate. it should be enough to multiply # kernel_size by (sample_rate / 16000). but this needs to be double-checked. + self.sample_rate = sample_rate self.stride = stride self.wav_norm1d = nn.InstanceNorm1d(1, affine=True) @@ -70,6 +74,88 @@ def __init__(self, sample_rate: int = 16000, stride: int = 1): self.pool1d.append(nn.MaxPool1d(3, stride=3, padding=0, dilation=1)) self.norm1d.append(nn.InstanceNorm1d(60, affine=True)) + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames for a given number of input samples + + Parameters + ---------- + num_samples : int + Number of input samples + + Returns + ------- + num_frames : int + Number of output frames + """ + + kernel_size = [251, 3, 5, 3, 5, 3] + stride = [self.stride, 3, 1, 3, 1, 3] + padding = [0, 0, 0, 0, 0, 0] + dilation = [1, 1, 1, 1, 1, 1] + + num_frames = num_samples + for k, s, p, d in zip(kernel_size, stride, padding, dilation): + num_frames = conv1d_num_frames( + num_frames, kernel_size=k, stride=s, padding=p, dilation=d + ) + + return num_frames + + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute receptive field size + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + + Returns + ------- + receptive_field_size : int + Receptive field size + """ + + kernel_size = [251, 3, 5, 3, 5, 3] + stride = [self.stride, 3, 1, 3, 1, 3] + padding = [0, 0, 0, 0, 0, 0] + dilation = [1, 1, 1, 1, 1, 1] + + receptive_field_size = num_frames + for k, s, p, d in reversed(list(zip(kernel_size, stride, padding, dilation))): + receptive_field_size = conv1d_receptive_field_size( + num_frames=receptive_field_size, + kernel_size=k, + stride=s, + padding=p, + dilation=d, + ) + + return receptive_field_size + + def receptive_field(self) -> SlidingWindow: + """Compute receptive field + + Returns + ------- + receptive field : SlidingWindow + + Source + ------ + https://distill.pub/2019/computing-receptive-fields/ + + """ + + # duration of the receptive field of each output frame + duration = self.receptive_field_size() / self.sample_rate + + # step between the receptive field region of two consecutive output frames + step = ( + self.receptive_field_size(num_frames=2) + - self.receptive_field_size(num_frames=1) + ) / self.sample_rate + + return SlidingWindow(start=0.0, duration=duration, step=step) + def forward(self, waveforms: torch.Tensor) -> torch.Tensor: """Pass forward @@ -83,7 +169,6 @@ def forward(self, waveforms: torch.Tensor) -> torch.Tensor: for c, (conv1d, pool1d, norm1d) in enumerate( zip(self.conv1d, self.pool1d, self.norm1d) ): - outputs = conv1d(outputs) # https://github.com/mravanelli/SincNet/issues/4 diff --git a/pyannote/audio/models/segmentation/PyanNet.py b/pyannote/audio/models/segmentation/PyanNet.py index 5af3734b1..2c4443e06 100644 --- a/pyannote/audio/models/segmentation/PyanNet.py +++ b/pyannote/audio/models/segmentation/PyanNet.py @@ -27,6 +27,7 @@ import torch.nn as nn import torch.nn.functional as F from einops import rearrange +from pyannote.core import SlidingWindow from pyannote.core.utils.generators import pairwise from pyannote.audio.core.model import Model @@ -157,6 +158,36 @@ def build(self): self.classifier = nn.Linear(in_features, out_features) self.activation = self.default_activation() + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames for a given number of input samples + + Parameters + ---------- + num_samples : int + Number of input samples + + Returns + ------- + num_frames : int + Number of output frames + """ + + return self.sincnet.num_frames(num_samples) + + def receptive_field(self) -> SlidingWindow: + """Compute receptive field + + Returns + ------- + receptive field : SlidingWindow + + Source + ------ + https://distill.pub/2019/computing-receptive-fields/ + + """ + return self.sincnet.receptive_field() + def forward(self, waveforms: torch.Tensor) -> torch.Tensor: """Pass forward diff --git a/pyannote/audio/models/segmentation/SSeRiouSS.py b/pyannote/audio/models/segmentation/SSeRiouSS.py index 7cd545177..9ba656182 100644 --- a/pyannote/audio/models/segmentation/SSeRiouSS.py +++ b/pyannote/audio/models/segmentation/SSeRiouSS.py @@ -27,10 +27,12 @@ import torch.nn as nn import torch.nn.functional as F import torchaudio +from pyannote.core import SlidingWindow 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.frame import conv1d_num_frames, conv1d_receptive_field_size from pyannote.audio.utils.params import merge_dict @@ -191,6 +193,82 @@ def build(self): self.classifier = nn.Linear(in_features, out_features) self.activation = self.default_activation() + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames for a given number of input samples + + Parameters + ---------- + num_samples : int + Number of input samples + + Returns + ------- + num_frames : int + Number of output frames + """ + + num_frames = num_samples + for conv_layer in self.wav2vec.feature_extractor.conv_layers: + num_frames = conv1d_num_frames( + num_frames, + kernel_size=conv_layer.kernel_size, + stride=conv_layer.stride, + padding=conv_layer.conv.padding[0], + dilation=conv_layer.conv.dilation[0], + ) + + return num_frames + + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute receptive field size + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + + Returns + ------- + receptive_field_size : int + Receptive field size + """ + + receptive_field_size = num_frames + for conv_layer in reversed(self.wav2vec.feature_extractor.conv_layers): + receptive_field_size = conv1d_receptive_field_size( + num_frames=receptive_field_size, + kernel_size=conv_layer.kernel_size, + stride=conv_layer.stride, + padding=conv_layer.conv.padding[0], + dilation=conv_layer.conv.dilation[0], + ) + + return receptive_field_size + + def receptive_field(self) -> SlidingWindow: + """Compute receptive field + + Returns + ------- + receptive field : SlidingWindow + + Source + ------ + https://distill.pub/2019/computing-receptive-fields/ + + """ + + # duration of the receptive field of each output frame + duration = self.receptive_field_size() / self.hparams.sample_rate + + # step between the receptive field region of two consecutive output frames + step = ( + self.receptive_field_size(num_frames=2) + - self.receptive_field_size(num_frames=1) + ) / self.hparams.sample_rate + + return SlidingWindow(start=0.0, duration=duration, step=step) + def forward(self, waveforms: torch.Tensor) -> torch.Tensor: """Pass forward diff --git a/pyannote/audio/models/segmentation/debug.py b/pyannote/audio/models/segmentation/debug.py index 89512320c..a230bf768 100644 --- a/pyannote/audio/models/segmentation/debug.py +++ b/pyannote/audio/models/segmentation/debug.py @@ -26,6 +26,7 @@ import torch import torch.nn as nn from einops import rearrange +from pyannote.core import SlidingWindow from torchaudio.transforms import MFCC from pyannote.audio.core.model import Model @@ -57,6 +58,82 @@ def __init__( bidirectional=True, ) + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames for a given number of input samples + + Parameters + ---------- + num_samples : int + Number of input samples + + Returns + ------- + num_frames : int + Number of output frames + + Source + ------ + https://pytorch.org/docs/stable/generated/torch.stft.html#torch.stft + + """ + + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + center = self.mfcc.MelSpectrogram.spectrogram.center + return ( + 1 + num_samples // hop_length + if center + else 1 + (num_samples - n_fft) // hop_length + ) + + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute receptive field size + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + + Returns + ------- + receptive_field_size : int + Receptive field size + """ + + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + center = self.mfcc.MelSpectrogram.spectrogram.center + + if center: + return (num_frames - 1) * hop_length + else: + return (num_frames - 1) * hop_length + n_fft + + def receptive_field(self) -> SlidingWindow: + """Compute receptive field + + Returns + ------- + receptive field : SlidingWindow + + Source + ------ + https://distill.pub/2019/computing-receptive-fields/ + + """ + + # duration of the receptive field of each output frame + duration = ( + self.mfcc.MelSpectrogram.spectrogram.win_length / self.hparams.sample_rate + ) + + # step between the receptive field region of two consecutive output frames + step = ( + self.mfcc.MelSpectrogram.spectrogram.hop_length / self.hparams.sample_rate + ) + + return SlidingWindow(start=0.0, duration=duration, step=step) + def build(self): # define task-dependent layers diff --git a/pyannote/audio/utils/frame.py b/pyannote/audio/utils/frame.py new file mode 100644 index 000000000..e3987873d --- /dev/null +++ b/pyannote/audio/utils/frame.py @@ -0,0 +1,80 @@ +# 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 math + + +def conv1d_num_frames(num_samples, kernel_size=5, stride=1, padding=0, dilation=1): + """Compute expected number of frames after 1D convolution + + Parameters + ---------- + num_samples : int + Number of samples in the input signal + kernel_size : int + Kernel size + stride : int + Stride + padding : int + Padding + dilation : int + Dilation + + Returns + ------- + num_frames : int + Number of frames in the output signal + + Source + ------ + https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html#torch.nn.Conv1d + """ + return math.floor( + 1 + (num_samples + 2 * padding - dilation * (kernel_size - 1) - 1) / stride + ) + + +def conv1d_receptive_field_size( + num_frames=1, kernel_size=5, stride=1, padding=0, dilation=1 +): + """Compute receptive field size for `num_frames` frames after 1D convolution + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + kernel_size : int + Kernel size + stride : int + Stride + padding : int + Padding + dilation : int + Dilation + + Returns + ------- + receptive_field : int + Receptive field size + """ + return (num_frames - 1) * stride - 2 * padding + dilation * (kernel_size - 1) + 1 From 4d2d16bd6101899171013dcb014b17418ed50d88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 20 Dec 2023 16:03:13 +0100 Subject: [PATCH 28/57] doc: update benchmark section (#1592) --- README.md | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index a82a2488f..696fb219d 100644 --- a/README.md +++ b/README.md @@ -78,18 +78,20 @@ Out of the box, `pyannote.audio` speaker diarization [pipeline](https://hf.co/py Those numbers are diarization error rates (in %): | Benchmark | [v2.1](https://hf.co/pyannote/speaker-diarization-2.1) | [v3.1](https://hf.co/pyannote/speaker-diarization-3.1) | [Premium](https://forms.gle/eKhn7H2zTa68sMMx8) | -| ---------------------- | ------------------------------------------------------ | ------------------------------------------------------ | ---------------------------------------------- | -| AISHELL-4 | 14.1 | 12.3 | 11.9 | -| AliMeeting (channel 1) | 27.4 | 24.5 | 22.5 | -| AMI (IHM) | 18.9 | 18.8 | 16.6 | -| AMI (SDM) | 27.1 | 22.6 | 20.9 | -| AVA-AVD | 66.3 | 50.0 | 39.8 | -| CALLHOME (part 2) | 31.6 | 28.4 | 22.2 | -| DIHARD 3 (full) | 26.9 | 21.4 | 17.2 | -| Ego4D (dev.) | 61.5 | 51.2 | 43.8 | -| MSDWild | 32.8 | 25.4 | 19.8 | -| REPERE (phase2) | 8.2 | 7.8 | 7.6 | -| VoxConverse (v0.3) | 11.2 | 11.2 | 9.4 | +| ---------------------- | ------ | ------ | --------- | +| [AISHELL-4](https://arxiv.org/abs/2104.03603) | 14.1 | 12.2 | 11.9 | +| [AliMeeting](https://www.openslr.org/119/) (channel 1) | 27.4 | 24.4 | 22.5 | +| [AMI](https://groups.inf.ed.ac.uk/ami/corpus/) (IHM) | 18.9 | 18.8 | 16.6 | +| [AMI](https://groups.inf.ed.ac.uk/ami/corpus/) (SDM) | 27.1 | 22.4 | 20.9 | +| [AVA-AVD](https://arxiv.org/abs/2111.14448) | 66.3 | 50.0 | 39.8 | +| [CALLHOME](https://catalog.ldc.upenn.edu/LDC2001S97) ([part 2](https://github.com/BUTSpeechFIT/CALLHOME_sublists/issues/1)) | 31.6 | 28.4 | 22.2 | +| [DIHARD 3](https://catalog.ldc.upenn.edu/LDC2022S14) ([full](https://arxiv.org/abs/2012.01477)) | 26.9 | 21.7 | 17.2 | +| [Earnings21](https://github.com/revdotcom/speech-datasets) | 17.0 | 9.4 | 9.0 | +| [Ego4D](https://arxiv.org/abs/2110.07058) (dev.) | 61.5 | 51.2 | 43.8 | +| [MSDWild](https://github.com/X-LANCE/MSDWILD) | 32.8 | 25.3 | 19.8 | +| [RAMC](https://www.openslr.org/123/) | 22.5 | 22.2 | 18.4 | +| [REPERE](https://www.islrn.org/resources/360-758-359-485-0/) (phase2) | 8.2 | 7.8 | 7.6 | +| [VoxConverse](https://github.com/joonson/voxconverse) (v0.3) | 11.2 | 11.3 | 9.4 | [Diarization error rate](http://pyannote.github.io/pyannote-metrics/reference.html#diarization) (in %) From 7bd88d5f13063c2aaa0969e9adc7760c389860f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 20 Dec 2023 21:26:42 +0100 Subject: [PATCH 29/57] feat(pipeline): add Waveform and SampleRate preprocessors (#1593) --- CHANGELOG.md | 3 ++- pyannote/audio/utils/preprocessors.py | 18 ++++++++++++++++-- 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ed30b980a..4bcaa93b6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,9 +1,10 @@ # Changelog -## develop branch +## develop ### New features +- feat(pipeline): add `Waveform` and `SampleRate` preprocessors - feat(model): add `num_frames` and `receptive_field` to segmentation models ## Version 3.1.1 (2023-12-01) diff --git a/pyannote/audio/utils/preprocessors.py b/pyannote/audio/utils/preprocessors.py index ce4685d1f..b26553bf9 100644 --- a/pyannote/audio/utils/preprocessors.py +++ b/pyannote/audio/utils/preprocessors.py @@ -27,12 +27,13 @@ # Hervé BREDIN - http://herve.niderb.fr from functools import reduce -from itertools import chain from typing import Dict, List, Optional, Set from pyannote.core import Annotation, Segment from pyannote.database import ProtocolFile +from pyannote.audio.core.io import Audio, get_torchaudio_info + class LowerTemporalResolution: """Artificially degrade temporal resolution of reference annotation @@ -50,7 +51,6 @@ def __init__(self, resolution: float = 0.1): self.resolution = resolution def __call__(self, current_file: ProtocolFile) -> Annotation: - annotation = current_file["annotation"] new_annotation = annotation.empty() @@ -128,3 +128,17 @@ def __call__(self, current_file: ProtocolFile) -> Annotation: derived[seg] = intersect_label return derived + + +class Waveform: + def __init__(self): + self._audio = Audio() + + def __call__(self, file: ProtocolFile): + waveform, _ = self._audio(file) + return waveform + + +class SampleRate: + def __call__(self, file: ProtocolFile): + return get_torchaudio_info(file).sample_rate From 80634c9029743780cc959e0d249cbbb085959545 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Fri, 22 Dec 2023 09:16:12 +0100 Subject: [PATCH 30/57] fix: update `isort` version to 5.12.0 in pre-commit-config (#1596) Co-authored-by: clement-pages --- .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 549e46ad0..92c952bdc 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -14,7 +14,7 @@ repos: # Sort imports - repo: https://github.com/PyCQA/isort - rev: 5.10.1 + rev: 5.12.0 hooks: - id: isort args: ["--profile", "black"] From e21e7bb35ff7e830f47e6cbfd7923549c2b26a9b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 8 Jan 2024 09:52:19 +0100 Subject: [PATCH 31/57] ci: deactivate FAQtory --- .github/workflows/new_issue.yml | 29 ----------------------------- 1 file changed, 29 deletions(-) delete mode 100644 .github/workflows/new_issue.yml diff --git a/.github/workflows/new_issue.yml b/.github/workflows/new_issue.yml deleted file mode 100644 index b8477dc16..000000000 --- a/.github/workflows/new_issue.yml +++ /dev/null @@ -1,29 +0,0 @@ -name: issues -on: - issues: - types: [opened] -jobs: - add-comment: - runs-on: ubuntu-latest - permissions: - issues: write - steps: - - uses: actions/checkout@v3 - with: - ref: develop - - name: Install FAQtory - run: pip install FAQtory - - name: Run Suggest - env: - TITLE: ${{ github.event.issue.title }} - run: faqtory suggest "$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 }} From 808b170bd6be9581e6763c2bb6d85ab78f5d229f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 8 Jan 2024 16:36:24 +0100 Subject: [PATCH 32/57] feat: add MRE template --- tutorials/MRE_template.ipynb | 2220 ++++++++++++++++++++++++++++++++++ 1 file changed, 2220 insertions(+) create mode 100644 tutorials/MRE_template.ipynb diff --git a/tutorials/MRE_template.ipynb b/tutorials/MRE_template.ipynb new file mode 100644 index 000000000..7a44c1449 --- /dev/null +++ b/tutorials/MRE_template.ipynb @@ -0,0 +1,2220 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4", + "authorship_tag": "ABX9TyNUZLZoYLpzG6gIYECEOuiV", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "3d0fe95350234ab599497683ae6d4ce6": { + "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_239beda16fde4b1d9e6abfb47f036040", + "IPY_MODEL_2d6f5fe6f9ab4a8b853e7b023aaee35f", + "IPY_MODEL_771629a0fbab4b0e9ad6425b5affe380" + ], + "layout": "IPY_MODEL_8763b8e4c8104b879d4324257a810c0f" + } + }, + "239beda16fde4b1d9e6abfb47f036040": { + "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_22536aef3997408dbf5ea58241f01e3e", + "placeholder": "​", + "style": "IPY_MODEL_2a6a5f33d7c34b6b996ab7a5b7c2f11d", + "value": "config.yaml: 100%" + } + }, + "2d6f5fe6f9ab4a8b853e7b023aaee35f": { + "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_c348b2f57c6c437fa8a9a2688bf17f4f", + "max": 469, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7526127b349a4467a6d3083d92bef5ec", + "value": 469 + } + }, + "771629a0fbab4b0e9ad6425b5affe380": { + "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_30efc0ed76fb496483d4bb425a930636", + "placeholder": "​", + "style": "IPY_MODEL_e760e231084f4889bb489bc550b7a816", + "value": " 469/469 [00:00<00:00, 21.8kB/s]" + } + }, + "8763b8e4c8104b879d4324257a810c0f": { + "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 + } + }, + "22536aef3997408dbf5ea58241f01e3e": { + "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 + } + }, + "2a6a5f33d7c34b6b996ab7a5b7c2f11d": { + "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": "" + } + }, + "c348b2f57c6c437fa8a9a2688bf17f4f": { + "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 + } + }, + "7526127b349a4467a6d3083d92bef5ec": { + "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": "" + } + }, + "30efc0ed76fb496483d4bb425a930636": { + "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 + } + }, + "e760e231084f4889bb489bc550b7a816": { + "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": "" + } + }, + "9951dce8a6c947dd9a2ed6106cb68f30": { + "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_d68c24e62487484b83bbb06271a6981c", + "IPY_MODEL_467f3c9f15184784aa913cb3ae46700f", + "IPY_MODEL_c87055ce8cef498f999a20ff2b34e1b8" + ], + "layout": "IPY_MODEL_63d957e24276476b9bf1be150675217c" + } + }, + "d68c24e62487484b83bbb06271a6981c": { + "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_afe35fd2ea654d7b861046e847f82e51", + "placeholder": "​", + "style": "IPY_MODEL_c5f4f5f5fbad4d14973dc21eae2358d4", + "value": "pytorch_model.bin: 100%" + } + }, + "467f3c9f15184784aa913cb3ae46700f": { + "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_b4faa4c7fd01498abe07fef6189de4d4", + "max": 5905440, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_35ab2642d8a5481780c43eaef7044f3c", + "value": 5905440 + } + }, + "c87055ce8cef498f999a20ff2b34e1b8": { + "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_37de7e413b25451ca5288ea5f43dd2d5", + "placeholder": "​", + "style": "IPY_MODEL_47012c0ff9394d77b8d857a933b4082e", + "value": " 5.91M/5.91M [00:00<00:00, 66.3MB/s]" + } + }, + "63d957e24276476b9bf1be150675217c": { + "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 + } + }, + "afe35fd2ea654d7b861046e847f82e51": { + "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 + } + }, + "c5f4f5f5fbad4d14973dc21eae2358d4": { + "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": "" + } + }, + "b4faa4c7fd01498abe07fef6189de4d4": { + "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 + } + }, + "35ab2642d8a5481780c43eaef7044f3c": { + "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": "" + } + }, + "37de7e413b25451ca5288ea5f43dd2d5": { + "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 + } + }, + "47012c0ff9394d77b8d857a933b4082e": { + "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": "" + } + }, + "d3ca3e02944c49f88d2b232295b19293": { + "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_392a6347341f4dac94cad19e1f0bf02b", + "IPY_MODEL_ba0102afa62c443eb9de89412301bb46", + "IPY_MODEL_b71a286118004001a9a65ece5ba352d2" + ], + "layout": "IPY_MODEL_29b969a7441d41059969962f338d0def" + } + }, + "392a6347341f4dac94cad19e1f0bf02b": { + "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_3d0be590ca374ef1a768b8d3577d3105", + "placeholder": "​", + "style": "IPY_MODEL_c0ac81654e1c4904a87a2c777b520c09", + "value": "config.yaml: 100%" + } + }, + "ba0102afa62c443eb9de89412301bb46": { + "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_36f8eb5005864f779aa8185acf55e2c5", + "max": 399, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5cbb5cf6a37d451c87215851ee8b0b65", + "value": 399 + } + }, + "b71a286118004001a9a65ece5ba352d2": { + "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_ca3ee9d356bc464e82ee061375cc4ef2", + "placeholder": "​", + "style": "IPY_MODEL_67e4c4a2768b40eca34e8add6265c40c", + "value": " 399/399 [00:00<00:00, 28.2kB/s]" + } + }, + "29b969a7441d41059969962f338d0def": { + "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 + } + }, + "3d0be590ca374ef1a768b8d3577d3105": { + "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 + } + }, + "c0ac81654e1c4904a87a2c777b520c09": { + "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": "" + } + }, + "36f8eb5005864f779aa8185acf55e2c5": { + "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 + } + }, + "5cbb5cf6a37d451c87215851ee8b0b65": { + "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": "" + } + }, + "ca3ee9d356bc464e82ee061375cc4ef2": { + "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 + } + }, + "67e4c4a2768b40eca34e8add6265c40c": { + "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": "" + } + }, + "2149e37d14e94f82a77386682ba29195": { + "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_501eb1f4c1a8458a86c917d7dac5eeb5", + "IPY_MODEL_7a115cf3065f4acdb0ae13577447a333", + "IPY_MODEL_532d713a67c94b0d8cf0d61be72c73e7" + ], + "layout": "IPY_MODEL_3f36703cc5bc4fbcbeb97ab722e573cc" + } + }, + "501eb1f4c1a8458a86c917d7dac5eeb5": { + "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_8088c86a3d394f9e88267196b369dfb9", + "placeholder": "​", + "style": "IPY_MODEL_46c5a63bcc3a472284869bcb11407bed", + "value": "pytorch_model.bin: 100%" + } + }, + "7a115cf3065f4acdb0ae13577447a333": { + "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_754c1729ba074d518557bd53c01e3787", + "max": 26645418, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bbe45325b7b74832bf6fe4a9769e0565", + "value": 26645418 + } + }, + "532d713a67c94b0d8cf0d61be72c73e7": { + "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_9261da2864ce4fd9b0f05f2a2efc54a3", + "placeholder": "​", + "style": "IPY_MODEL_940ed223c43d40e5b85eadf3a5ef0382", + "value": " 26.6M/26.6M [00:00<00:00, 172MB/s]" + } + }, + "3f36703cc5bc4fbcbeb97ab722e573cc": { + "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 + } + }, + "8088c86a3d394f9e88267196b369dfb9": { + "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 + } + }, + "46c5a63bcc3a472284869bcb11407bed": { + "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": "" + } + }, + "754c1729ba074d518557bd53c01e3787": { + "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 + } + }, + "bbe45325b7b74832bf6fe4a9769e0565": { + "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": "" + } + }, + "9261da2864ce4fd9b0f05f2a2efc54a3": { + "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 + } + }, + "940ed223c43d40e5b85eadf3a5ef0382": { + "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": "" + } + }, + "ef97ca55c62b40f7bb233120f8efba62": { + "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_2da74c40ebd44b61adaf840b9e7ce343", + "IPY_MODEL_c9517e2631c247b6ba083da05cfd0399", + "IPY_MODEL_29b6d0dc6624409c8c8a8e0565c2bc08" + ], + "layout": "IPY_MODEL_7b6f8f9b2eee485f8defe25d2a9afc4a" + } + }, + "2da74c40ebd44b61adaf840b9e7ce343": { + "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_fbaa859f9a8d4d5fb15667ede53a2cfb", + "placeholder": "​", + "style": "IPY_MODEL_1840bc4e8cb54d3d89d5b1f199065c77", + "value": "config.yaml: 100%" + } + }, + "c9517e2631c247b6ba083da05cfd0399": { + "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_3f955f5b7421415bb79319058d0d094d", + "max": 221, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_849cf4fb4ac249368fb8a5c837f8430a", + "value": 221 + } + }, + "29b6d0dc6624409c8c8a8e0565c2bc08": { + "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_0411eb97e38b4fa081e05f87076ba129", + "placeholder": "​", + "style": "IPY_MODEL_34842bb9a73048caace624929cfc2b03", + "value": " 221/221 [00:00<00:00, 10.8kB/s]" + } + }, + "7b6f8f9b2eee485f8defe25d2a9afc4a": { + "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 + } + }, + "fbaa859f9a8d4d5fb15667ede53a2cfb": { + "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 + } + }, + "1840bc4e8cb54d3d89d5b1f199065c77": { + "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": "" + } + }, + "3f955f5b7421415bb79319058d0d094d": { + "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 + } + }, + "849cf4fb4ac249368fb8a5c837f8430a": { + "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": "" + } + }, + "0411eb97e38b4fa081e05f87076ba129": { + "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 + } + }, + "34842bb9a73048caace624929cfc2b03": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Sharing a minimal reproduction example (MRE) is a prerequisite for `pyannote.audio` contributors to be able to solve them.\n", + "\n", + "Having an MRE is very important for contributors to be able to reproduce the bug in the same way that you are experiencing it. When testing a potential fix for the issue, contributors will use the MRE to validate that the fix is working as intended.\n", + "\n", + "This notebook provides a template that should help you create such a MRE.\n", + "\n", + "Duplicate it, edit it, and share it as a link within your `pyannote.audio` bug report." + ], + "metadata": { + "id": "SWidE_E7ol-U" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Setup\n", + "\n", + "Before anything, make sure to run this section." + ], + "metadata": { + "id": "k1vex_KZTDFm" + } + }, + { + "cell_type": "markdown", + "source": [ + "Specify the `pyannote.audio` version you found the issue in (including the Git commit hash if using a non-released version)." + ], + "metadata": { + "id": "XRNSJ2omranm" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install -qqq pyannote.audio==3.1.1" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "THKj6xjdSv9k", + "outputId": "719baaf8-2028-4b8e-8e46-e6a813aaf6f8" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m208.7/208.7 kB\u001b[0m \u001b[31m4.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.6/44.6 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.5/79.5 kB\u001b[0m \u001b[31m10.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.5/58.5 kB\u001b[0m \u001b[31m8.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m48.1/48.1 kB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m51.4/51.4 kB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m118.6/118.6 kB\u001b[0m \u001b[31m16.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m630.6/630.6 kB\u001b[0m \u001b[31m21.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.7/101.7 kB\u001b[0m \u001b[31m14.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m47.9/47.9 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m806.1/806.1 kB\u001b[0m \u001b[31m25.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m777.7/777.7 kB\u001b[0m \u001b[31m29.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m117.0/117.0 kB\u001b[0m \u001b[31m18.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m413.4/413.4 kB\u001b[0m \u001b[31m29.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m39.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m59.6/59.6 kB\u001b[0m \u001b[31m9.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m233.4/233.4 kB\u001b[0m \u001b[31m27.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.4/116.4 kB\u001b[0m \u001b[31m14.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.6/78.6 kB\u001b[0m \u001b[31m12.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m526.7/526.7 kB\u001b[0m \u001b[31m45.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\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" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Declare your [Huggingface token](https://huggingface.co/settings/tokens) as `HF_TOKEN` secret by clicking on the 🔑 icon on the left:\n", + "\n", + "* **Name**: `HF_TOKEN` \n", + "* **Value**: your Huggingface token (e.g. `hf_ABCdzRFTkglhlcalBAPGHSQvxLmQs`)" + ], + "metadata": { + "id": "ZLhE8e7iTpTu" + } + }, + { + "cell_type": "markdown", + "source": [ + "Check that you can load the pretrained pipeline." + ], + "metadata": { + "id": "Mogy5_qYUoXs" + } + }, + { + "cell_type": "code", + "source": [ + "# access your HF token\n", + "from google.colab import userdata\n", + "hf_token = userdata.get('HF_TOKEN')\n", + "\n", + "# load the pretrained pipeline\n", + "from pyannote.audio import Pipeline\n", + "pipeline = Pipeline.from_pretrained(\n", + " \"pyannote/speaker-diarization-3.1\",\n", + " use_auth_token=hf_token)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 307, + "referenced_widgets": [ + "3d0fe95350234ab599497683ae6d4ce6", + "239beda16fde4b1d9e6abfb47f036040", + "2d6f5fe6f9ab4a8b853e7b023aaee35f", + "771629a0fbab4b0e9ad6425b5affe380", + "8763b8e4c8104b879d4324257a810c0f", + "22536aef3997408dbf5ea58241f01e3e", + "2a6a5f33d7c34b6b996ab7a5b7c2f11d", + "c348b2f57c6c437fa8a9a2688bf17f4f", + "7526127b349a4467a6d3083d92bef5ec", + "30efc0ed76fb496483d4bb425a930636", + "e760e231084f4889bb489bc550b7a816", + "9951dce8a6c947dd9a2ed6106cb68f30", + "d68c24e62487484b83bbb06271a6981c", + "467f3c9f15184784aa913cb3ae46700f", + "c87055ce8cef498f999a20ff2b34e1b8", + "63d957e24276476b9bf1be150675217c", + "afe35fd2ea654d7b861046e847f82e51", + "c5f4f5f5fbad4d14973dc21eae2358d4", + "b4faa4c7fd01498abe07fef6189de4d4", + "35ab2642d8a5481780c43eaef7044f3c", + "37de7e413b25451ca5288ea5f43dd2d5", + "47012c0ff9394d77b8d857a933b4082e", + "d3ca3e02944c49f88d2b232295b19293", + "392a6347341f4dac94cad19e1f0bf02b", + "ba0102afa62c443eb9de89412301bb46", + "b71a286118004001a9a65ece5ba352d2", + "29b969a7441d41059969962f338d0def", + "3d0be590ca374ef1a768b8d3577d3105", + "c0ac81654e1c4904a87a2c777b520c09", + "36f8eb5005864f779aa8185acf55e2c5", + "5cbb5cf6a37d451c87215851ee8b0b65", + "ca3ee9d356bc464e82ee061375cc4ef2", + "67e4c4a2768b40eca34e8add6265c40c", + "2149e37d14e94f82a77386682ba29195", + "501eb1f4c1a8458a86c917d7dac5eeb5", + "7a115cf3065f4acdb0ae13577447a333", + "532d713a67c94b0d8cf0d61be72c73e7", + "3f36703cc5bc4fbcbeb97ab722e573cc", + "8088c86a3d394f9e88267196b369dfb9", + "46c5a63bcc3a472284869bcb11407bed", + "754c1729ba074d518557bd53c01e3787", + "bbe45325b7b74832bf6fe4a9769e0565", + "9261da2864ce4fd9b0f05f2a2efc54a3", + "940ed223c43d40e5b85eadf3a5ef0382", + "ef97ca55c62b40f7bb233120f8efba62", + "2da74c40ebd44b61adaf840b9e7ce343", + "c9517e2631c247b6ba083da05cfd0399", + "29b6d0dc6624409c8c8a8e0565c2bc08", + "7b6f8f9b2eee485f8defe25d2a9afc4a", + "fbaa859f9a8d4d5fb15667ede53a2cfb", + "1840bc4e8cb54d3d89d5b1f199065c77", + "3f955f5b7421415bb79319058d0d094d", + "849cf4fb4ac249368fb8a5c837f8430a", + "0411eb97e38b4fa081e05f87076ba129", + "34842bb9a73048caace624929cfc2b03" + ] + }, + "id": "i8rs3XylTTys", + "outputId": "b1b7445e-6f29-4ce0-c111-f5ffcb488c47" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "config.yaml: 0%| | 0.00/469 [00:00] 937.60K --.-KB/s in 0.04s \n", + "\n", + "2024-01-08 15:31:42 (25.7 MB/s) - ‘sample.wav’ saved [960104/960104]\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Apply the pretrained pipeline and visualize the output." + ], + "metadata": { + "id": "RH6AEClgaAgU" + } + }, + { + "cell_type": "code", + "source": [ + "diarization = pipeline(\"sample.wav\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AoCal-3UXK0z", + "outputId": "59428f0f-af42-4e78-fc04-abd6324c73db" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/pyannote/audio/utils/reproducibility.py:74: 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", + "\n", + " warnings.warn(\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "diarization" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 259 + }, + "id": "iIKvKZoZXN_M", + "outputId": "e7dcd7e1-0512-425c-b46a-6dc18d7a67b1" + }, + "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", + "source": [ + "# MRE\n", + "\n", + "Now that things are setup, edit the following cells with the piece of code allowing to reproduce the bug report.\n" + ], + "metadata": { + "id": "qHxFJZDxr5O1" + } + }, + { + "cell_type": "code", + "source": [ + "from pyannote.audio import Model\n", + "model = Model.from_pretrained(\n", + " \"pyannote/speaker-diarization-3.1\",\n", + " use_auth_token=hf_token)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 499 + }, + "id": "gVrDtBcusDbK", + "outputId": "25823c18-bff7-43b5-ef30-f5e8b2e43e2b" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "error", + "ename": "EntryNotFoundError", + "evalue": "404 Client Error. (Request ID: Root=1-659c1570-229842ad49cdd505022bd7b3;3b3426ec-0f8e-49a4-8783-f5740d92a8ed)\n\nEntry Not Found for url: https://huggingface.co/pyannote/speaker-diarization-3.1/resolve/main/pytorch_model.bin.", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mHTTPError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_errors.py\u001b[0m in \u001b[0;36mhf_raise_for_status\u001b[0;34m(response, endpoint_name)\u001b[0m\n\u001b[1;32m 285\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 286\u001b[0;31m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_for_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 287\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mHTTPError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/requests/models.py\u001b[0m in \u001b[0;36mraise_for_status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1020\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhttp_error_msg\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1021\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mHTTPError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhttp_error_msg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1022\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mHTTPError\u001b[0m: 404 Client Error: Not Found for url: https://huggingface.co/pyannote/speaker-diarization-3.1/resolve/main/pytorch_model.bin", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mEntryNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpyannote\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maudio\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mModel\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m model = Model.from_pretrained(\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;34m\"pyannote/speaker-diarization-3.1\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m use_auth_token=hf_token)\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pyannote/audio/core/model.py\u001b[0m in \u001b[0;36mfrom_pretrained\u001b[0;34m(cls, checkpoint, map_location, hparams_file, strict, use_auth_token, cache_dir, **kwargs)\u001b[0m\n\u001b[1;32m 622\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 623\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 624\u001b[0;31m path_for_pl = hf_hub_download(\n\u001b[0m\u001b[1;32m 625\u001b[0m \u001b[0mmodel_id\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 626\u001b[0m \u001b[0mHF_PYTORCH_WEIGHTS_NAME\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_validators.py\u001b[0m in \u001b[0;36m_inner_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msmoothly_deprecate_use_auth_token\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhas_token\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mhas_token\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 118\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_inner_fn\u001b[0m \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/huggingface_hub/file_download.py\u001b[0m in \u001b[0;36mhf_hub_download\u001b[0;34m(repo_id, filename, subfolder, repo_type, revision, library_name, library_version, cache_dir, local_dir, local_dir_use_symlinks, user_agent, force_download, force_filename, proxies, etag_timeout, resume_download, token, local_files_only, legacy_cache_layout, endpoint)\u001b[0m\n\u001b[1;32m 1236\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1237\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1238\u001b[0;31m metadata = get_hf_file_metadata(\n\u001b[0m\u001b[1;32m 1239\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1240\u001b[0m \u001b[0mtoken\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtoken\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_validators.py\u001b[0m in \u001b[0;36m_inner_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msmoothly_deprecate_use_auth_token\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhas_token\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mhas_token\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 118\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_inner_fn\u001b[0m \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/huggingface_hub/file_download.py\u001b[0m in \u001b[0;36mget_hf_file_metadata\u001b[0;34m(url, token, proxies, timeout, library_name, library_version, user_agent)\u001b[0m\n\u001b[1;32m 1629\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1630\u001b[0m \u001b[0;31m# Retrieve metadata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1631\u001b[0;31m r = _request_wrapper(\n\u001b[0m\u001b[1;32m 1632\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"HEAD\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1633\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/huggingface_hub/file_download.py\u001b[0m in \u001b[0;36m_request_wrapper\u001b[0;34m(method, url, follow_relative_redirects, **params)\u001b[0m\n\u001b[1;32m 383\u001b[0m \u001b[0;31m# Recursively follow relative redirects\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 384\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfollow_relative_redirects\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 385\u001b[0;31m response = _request_wrapper(\n\u001b[0m\u001b[1;32m 386\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 387\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/huggingface_hub/file_download.py\u001b[0m in \u001b[0;36m_request_wrapper\u001b[0;34m(method, url, follow_relative_redirects, **params)\u001b[0m\n\u001b[1;32m 407\u001b[0m \u001b[0;31m# Perform request and return if status_code is not in the retry list.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 408\u001b[0m \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_session\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 409\u001b[0;31m \u001b[0mhf_raise_for_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresponse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 410\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 411\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_errors.py\u001b[0m in \u001b[0;36mhf_raise_for_status\u001b[0;34m(response, endpoint_name)\u001b[0m\n\u001b[1;32m 294\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0merror_code\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"EntryNotFound\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 295\u001b[0m \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{response.status_code} Client Error.\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"\\n\\n\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34mf\"Entry Not Found for url: {response.url}.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 296\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mEntryNotFoundError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 297\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0merror_code\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"GatedRepo\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mEntryNotFoundError\u001b[0m: 404 Client Error. (Request ID: Root=1-659c1570-229842ad49cdd505022bd7b3;3b3426ec-0f8e-49a4-8783-f5740d92a8ed)\n\nEntry Not Found for url: https://huggingface.co/pyannote/speaker-diarization-3.1/resolve/main/pytorch_model.bin." + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# this does not work because `pyannote/speaker-diarization-3.1` is a not a `Model`, it is a `Pipeline`." + ], + "metadata": { + "id": "e4GWU8Sbsy9u" + }, + "execution_count": 9, + "outputs": [] + } + ] +} \ No newline at end of file From 42ef141298e51147f93b18f8caef2049fadcdd4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 8 Jan 2024 16:53:52 +0100 Subject: [PATCH 33/57] github: add bug_report.yml template --- .github/ISSUE_TEMPLATE/bug_report.yml | 56 +++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 .github/ISSUE_TEMPLATE/bug_report.yml diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml new file mode 100644 index 000000000..f75e050bf --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -0,0 +1,56 @@ +name: Bug report +description: Report a bug in pyannote.audio +body: + +- type: markdown + attributes: + value: | + When reporting bugs, please follow the guidelines in this template. This helps identify the problem precisely and thus enables contributors to fix it faster. + - Write a descriptive issue title above. + - The golden rule is to **always open *one* issue for *one* bug**. If you notice several bugs and want to report them, make sure to create one new issue for each of them. + - Search [open](https://github.com/pyannote/pyannote-audio/issues) and [closed](https://github.com/pyannote/pyannote-audio/issues?q=is%3Aissue+is%3Aclosed) issues to ensure it has not already been reported. If you don't find a relevant match or if you're unsure, don't hesitate to **open a new issue**. The bugsquad will handle it from there if it's a duplicate. + - Please always check if your issue is reproducible in the latest version – it may already have been fixed! + - If you use a custom build, please test if your issue is reproducible in official releases too. + +- type: textarea + attributes: + label: Tested versions + description: | + To properly fix a bug, we need to identify if the bug was recently introduced in the engine, or if it was always present. + - Please specify the pyannote.audio version you found the issue in, including the **Git commit hash** if using a development build. + - If you can, **please test earlier pyannote.audio versions** and, if applicable, newer versions (development branch). Mention whether the bug is reproducible or not in the versions you tested. + - The aim is for us to identify whether a bug is a **regression**, i.e. an issue that didn't exist in a previous version, but was introduced later on, breaking existing functionality. For example, if a bug is reproducible in 3.2 but not in 3.0, we would like you to test intermediate 3.1 to find which version is the first one where the issue can be reproduced. + placeholder: | + - Reproducible in: 3.1, 3.2, and later + - Not reproducible in: 3.0 + validations: + required: true + +- type: input + attributes: + label: System information + description: | + - Specify the OS version, and when relevant hardware information. + - For issues that are likely OS-specific and/or GPU-related, please specify the GPU model and architecture. + - **Bug reports not including the required information may be closed at the maintainers' discretion.** If in doubt, always include all the requested information; it's better to include too much information than not enough information. + placeholder: macOS 13.6 - pyannote.audio 3.1.1 - M1 Pro + validations: + required: true + +- type: textarea + attributes: + label: Issue description + description: | + Describe your issue briefly. What doesn't work, and how do you expect it to work instead? + You can include audio, images or videos with drag and drop, and format code blocks or logs with ``` tags. + validations: + required: true + +- type: input + attributes: + label: Minimal reproduction example (MRE) + description: | + Having reproducible issues is a prerequisite for contributors to be able to solve them. + Include a link to minimal reproduction example using [this Google Colab notebook](https://colab.research.google.com/github/pyannote/pyannote-audio/blob/develop/tutorials/MRE_template.ipynb) as a starting point. + validations: + required: true From 27cd91f87ce1b31f95995d7f7ca93e20cd76c1b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 8 Jan 2024 17:02:40 +0100 Subject: [PATCH 34/57] github: create config.yml --- .github/ISSUE_TEMPLATE/config.yml | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 .github/ISSUE_TEMPLATE/config.yml diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 000000000..764d5828a --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,16 @@ +blank_issues_enabled: false + +contact_links: + + - name: Feature request + url: https://github.com/pyannote/pyannote-audio/discussions + about: Please use Github Discussions. + + - name: Consulting + url: https://herve.niderb.fr/consulting + about: Using pyannote.audio in production? Make the most of it thanks to our consulting services. + + - name: Premium models + url: https://forms.gle/eKhn7H2zTa68sMMx8 + about: We are considering selling premium models, extensions, or services around pyannote.audio. + From eb2e813b36cfe611b0b8ca275b4aba27349a510d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 8 Jan 2024 17:04:22 +0100 Subject: [PATCH 35/57] github: update config.yml (#1607) --- .github/ISSUE_TEMPLATE/config.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index 764d5828a..70e131dc2 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -4,7 +4,7 @@ contact_links: - name: Feature request url: https://github.com/pyannote/pyannote-audio/discussions - about: Please use Github Discussions. + about: Suggest an idea for this project. - name: Consulting url: https://herve.niderb.fr/consulting From eda0c51b134c3c0db414b87ce0e773bdd682c3e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Mon, 8 Jan 2024 17:05:05 +0100 Subject: [PATCH 36/57] Delete .github/ISSUE_TEMPLATE/feature_request.md --- .github/ISSUE_TEMPLATE/feature_request.md | 20 -------------------- 1 file changed, 20 deletions(-) delete mode 100644 .github/ISSUE_TEMPLATE/feature_request.md diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md deleted file mode 100644 index 4ead48053..000000000 --- a/.github/ISSUE_TEMPLATE/feature_request.md +++ /dev/null @@ -1,20 +0,0 @@ ---- -name: Feature request -about: Suggest an idea for this project -title: '' -labels: '' -assignees: '' - ---- - -**Is your feature request related to a problem? Please describe.** -A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] - -**Describe the solution you'd like** -A clear and concise description of what you want to happen. - -**Describe alternatives you've considered** -A clear and concise description of any alternative solutions or features you've considered. - -**Additional context** -Add any other context about the feature request here. From 8f477fada9a595dc0c0e54de92e8c43cd9b1a7ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Tue, 9 Jan 2024 13:06:09 +0100 Subject: [PATCH 37/57] fix(task): fix random generators (#1594) Before this change, each worker would select the same files, resulting in less randomness than expected. --- CHANGELOG.md | 4 +++ pyannote/audio/tasks/embedding/mixins.py | 2 +- pyannote/audio/tasks/segmentation/mixins.py | 27 +++++++++++++-------- pyannote/audio/utils/random.py | 23 +++++++++++------- tutorials/add_your_own_task.ipynb | 2 +- 5 files changed, 37 insertions(+), 21 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4bcaa93b6..75f4fab62 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,10 @@ - feat(pipeline): add `Waveform` and `SampleRate` preprocessors - feat(model): add `num_frames` and `receptive_field` to segmentation models +### Fixes + +- fix(task): fix random generators + ## Version 3.1.1 (2023-12-01) ### TL;DR diff --git a/pyannote/audio/tasks/embedding/mixins.py b/pyannote/audio/tasks/embedding/mixins.py index da164f04e..03875256e 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -145,7 +145,7 @@ def train__iter__(self): """ # create worker-specific random number generator - rng = create_rng_for_worker(self.model.current_epoch) + rng = create_rng_for_worker(self.model) classes = list(self.specifications.classes) diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 018e8db70..94c6da506 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -421,12 +421,16 @@ 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] == self.metadata_unique_values[key].index(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 annotated_duration = self.annotated_duration[file_ids] - prob_annotated_duration = annotated_duration / np.sum(annotated_duration) + cum_prob_annotated_duration = np.cumsum( + annotated_duration / np.sum(annotated_duration) + ) duration = self.duration @@ -434,7 +438,7 @@ def train__iter__helper(self, rng: random.Random, **filters): 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) + file_id = file_ids[cum_prob_annotated_duration.searchsorted(rng.random())] # generate `num_chunks_per_file` chunks from this file for _ in range(num_chunks_per_file): @@ -444,14 +448,17 @@ def train__iter__helper(self, rng: random.Random, **filters): )[0] # 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]) + cum_prob_annotated_regions_duration = np.cumsum( + 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 - ) + annotated_region_index = annotated_region_indices[ + cum_prob_annotated_regions_duration.searchsorted(rng.random()) + ] # select one chunk at random in this annotated region _, _, start, end = self.annotated_regions[annotated_region_index] @@ -475,7 +482,7 @@ def train__iter__(self): """ # create worker-specific random number generator - rng = create_rng_for_worker(self.model.current_epoch) + rng = create_rng_for_worker(self.model) balance = getattr(self, "balance", None) if balance is None: diff --git a/pyannote/audio/utils/random.py b/pyannote/audio/utils/random.py index 97d50c362..4980d3520 100644 --- a/pyannote/audio/utils/random.py +++ b/pyannote/audio/utils/random.py @@ -27,7 +27,7 @@ import torch -def create_rng_for_worker(epoch: int) -> Random: +def create_rng_for_worker(model) -> Random: """Create worker-specific random number generator This makes sure that @@ -43,19 +43,24 @@ def create_rng_for_worker(epoch: int) -> Random: # create random number generator rng = Random() - #  create seed as a combination of PL_GLOBAL_SEED (set by pl.seed_everything()) - #  and other PL multi-processing variables - 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")) - + global_seed = os.environ.get("PL_GLOBAL_SEED", "unset") worker_info = torch.utils.data.get_worker_info() if worker_info is None: - worker_id = 0 + worker_id = None else: worker_id = worker_info.id - rng.seed(hash((global_seed, worker_id, local_rank, node_rank, epoch))) + seed = hash( + ( + global_seed, + worker_id, + model.local_rank, + model.global_rank, + model.current_epoch, + ) + ) + + rng.seed(seed) return rng diff --git a/tutorials/add_your_own_task.ipynb b/tutorials/add_your_own_task.ipynb index 251846957..6e1575dc8 100644 --- a/tutorials/add_your_own_task.ipynb +++ b/tutorials/add_your_own_task.ipynb @@ -236,7 +236,7 @@ "\n", " # create worker-specific random number generator (RNG) to avoid this common bug:\n", " # tanelp.github.io/posts/a-bug-that-plagues-thousands-of-open-source-ml-projects/\n", - " rng = create_rng_for_worker(self.model.current_epoch)\n", + " rng = create_rng_for_worker(self.model)\n", "\n", " # load list and number of classes\n", " classes = self.specifications.classes\n", From d41ce0a73d8c21208fddccbfd51804b9b78de2f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 11 Jan 2024 13:04:18 +0100 Subject: [PATCH 38/57] doc: fix typo in README --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 696fb219d..2c6a889f1 100644 --- a/README.md +++ b/README.md @@ -70,7 +70,7 @@ for turn, _, speaker in diarization.itertracks(yield_label=True): - Videos - [Introduction to speaker diarization](https://umotion.univ-lemans.fr/video/9513-speech-segmentation-and-speaker-diarization/) / JSALT 2023 summer school / 90 min - [Speaker segmentation model](https://www.youtube.com/watch?v=wDH2rvkjymY) / Interspeech 2021 / 3 min - - [First releaase of pyannote.audio](https://www.youtube.com/watch?v=37R_R82lfwA) / ICASSP 2020 / 8 min + - [First release of pyannote.audio](https://www.youtube.com/watch?v=37R_R82lfwA) / ICASSP 2020 / 8 min ## Benchmark From 9e4ec5f6e0b0f5d60c557981fc680e8cebf78f5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Fri, 12 Jan 2024 10:46:46 +0100 Subject: [PATCH 39/57] feat(task): add option to cache training metadata to disk Co-authored-by: Herve Bredin --- .github/ISSUE_TEMPLATE/bug_report.yml | 6 +- .github/ISSUE_TEMPLATE/config.yml | 5 +- CHANGELOG.md | 5 + pyannote/audio/core/model.py | 23 +- pyannote/audio/core/task.py | 423 ++++++++++++++++-- pyannote/audio/tasks/embedding/mixins.py | 16 +- pyannote/audio/tasks/segmentation/mixins.py | 400 +++-------------- .../audio/tasks/segmentation/multilabel.py | 141 +++++- .../overlapped_speech_detection.py | 23 +- .../tasks/segmentation/speaker_diarization.py | 47 +- .../segmentation/voice_activity_detection.py | 23 +- tests/tasks/test_reproducibility.py | 48 +- tests/test_train.py | 172 ++++++- tutorials/MRE_template.ipynb | 2 +- tutorials/adapting_pretrained_pipeline.ipynb | 1 + tutorials/add_your_own_task.ipynb | 110 +++-- 16 files changed, 949 insertions(+), 496 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml index f75e050bf..6f024c73b 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.yml +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -10,7 +10,7 @@ body: - The golden rule is to **always open *one* issue for *one* bug**. If you notice several bugs and want to report them, make sure to create one new issue for each of them. - Search [open](https://github.com/pyannote/pyannote-audio/issues) and [closed](https://github.com/pyannote/pyannote-audio/issues?q=is%3Aissue+is%3Aclosed) issues to ensure it has not already been reported. If you don't find a relevant match or if you're unsure, don't hesitate to **open a new issue**. The bugsquad will handle it from there if it's a duplicate. - Please always check if your issue is reproducible in the latest version – it may already have been fixed! - - If you use a custom build, please test if your issue is reproducible in official releases too. + - If you use a custom build, please test if your issue is reproducible in official releases too. - type: textarea attributes: @@ -18,7 +18,7 @@ body: description: | To properly fix a bug, we need to identify if the bug was recently introduced in the engine, or if it was always present. - Please specify the pyannote.audio version you found the issue in, including the **Git commit hash** if using a development build. - - If you can, **please test earlier pyannote.audio versions** and, if applicable, newer versions (development branch). Mention whether the bug is reproducible or not in the versions you tested. + - If you can, **please test earlier pyannote.audio versions** and, if applicable, newer versions (development branch). Mention whether the bug is reproducible or not in the versions you tested. - The aim is for us to identify whether a bug is a **regression**, i.e. an issue that didn't exist in a previous version, but was introduced later on, breaking existing functionality. For example, if a bug is reproducible in 3.2 but not in 3.0, we would like you to test intermediate 3.1 to find which version is the first one where the issue can be reproduced. placeholder: | - Reproducible in: 3.1, 3.2, and later @@ -33,7 +33,7 @@ body: - Specify the OS version, and when relevant hardware information. - For issues that are likely OS-specific and/or GPU-related, please specify the GPU model and architecture. - **Bug reports not including the required information may be closed at the maintainers' discretion.** If in doubt, always include all the requested information; it's better to include too much information than not enough information. - placeholder: macOS 13.6 - pyannote.audio 3.1.1 - M1 Pro + placeholder: macOS 13.6 - pyannote.audio 3.1.1 - M1 Pro validations: required: true diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index 70e131dc2..6d6ee3543 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -2,7 +2,7 @@ blank_issues_enabled: false contact_links: - - name: Feature request + - name: Feature request url: https://github.com/pyannote/pyannote-audio/discussions about: Suggest an idea for this project. @@ -12,5 +12,4 @@ contact_links: - name: Premium models url: https://forms.gle/eKhn7H2zTa68sMMx8 - about: We are considering selling premium models, extensions, or services around pyannote.audio. - + about: We are considering selling premium models, extensions, or services around pyannote.audio. diff --git a/CHANGELOG.md b/CHANGELOG.md index 75f4fab62..1cff92eb4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,7 @@ ### New features +- feat(task): add option to cache task training metadata to speed up training - feat(pipeline): add `Waveform` and `SampleRate` preprocessors - feat(model): add `num_frames` and `receptive_field` to segmentation models @@ -11,6 +12,10 @@ - fix(task): fix random generators +## Breaking changes + +- BREAKING(task): custom tasks need to be updated (see "Add your own task" tutorial) + ## Version 3.1.1 (2023-12-01) ### TL;DR diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index bedb7f6c4..098c15c02 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -142,8 +142,8 @@ def specifications(self) -> Union[Specifications, Tuple[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)`." + "the content of the training subset. Use `model.prepare_data()` and `model.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 @@ -217,9 +217,19 @@ def __example_output( self.specifications, __example_output, example_output ) + def prepare_data(self): + self.task.prepare_data() + def setup(self, stage=None): if stage == "fit": - self.task.setup_metadata() + # let the task know about the trainer (e.g for broadcasting + # cache path between multi-GPU training processes). + self.task.trainer = self.trainer + + # setup the task if defined (only on training and validation stages, + # but not for basic inference) + if self.task: + self.task.setup(stage) # list of layers before adding task-dependent layers before = set((name, id(module)) for name, module in self.named_modules()) @@ -252,7 +262,7 @@ def setup(self, stage=None): module.to(self.device) # add (trainable) loss function (e.g. ArcFace has its own set of trainable weights) - if stage == "fit": + if self.task: # let task know about the model self.task.model = self # setup custom loss function @@ -468,9 +478,8 @@ def __by_name( if isinstance(modules, str): modules = [modules] - for name, module in ModelSummary(self, max_depth=-1).named_modules: - if name not in modules: - continue + for name in modules: + module = getattr(self, name) for parameter in module.parameters(recurse=True): parameter.requires_grad = requires_grad diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index 1edfbc35c..5c0b16f29 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -23,19 +23,25 @@ from __future__ import annotations +import itertools import multiprocessing import sys import warnings +from collections import defaultdict from dataclasses import dataclass from enum import Enum from functools import cached_property, partial from numbers import Number +from pathlib import Path +from tempfile import mkstemp from typing import Dict, List, Literal, Optional, Sequence, Text, Tuple, Union +import numpy as np import pytorch_lightning as pl import scipy.special import torch from pyannote.database import Protocol +from pyannote.database.protocol.protocol import Scope, Subset from torch.utils.data import DataLoader, Dataset, IterableDataset from torch_audiomentations import Identity from torch_audiomentations.core.transforms_interface import BaseWaveformTransform @@ -44,6 +50,9 @@ from pyannote.audio.utils.loss import binary_cross_entropy, nll_loss from pyannote.audio.utils.protocol import check_protocol +Subsets = list(Subset.__args__) +Scopes = list(Scope.__args__) + # Type of machine learning problem class Problem(Enum): @@ -151,6 +160,41 @@ def __len__(self): return self.task.val__len__() +def get_dtype(value: int, unsigned: Optional[bool] = False) -> str: + """Return the most suitable type for storing the + value passed in parameter in memory. + + Parameters + ---------- + value: int + value whose type is best suited to storage in memory + unsigned: bool, optional + positive integer mode only. Default to False + + Returns + ------- + str: + numpy formatted type + (see https://numpy.org/doc/stable/reference/arrays.dtypes.html) + """ + if unsigned: + if value < 0: + raise ValueError( + f"negative value ({value}) is incompatible with unsigned types" + ) + # unsigned byte (8 bits), unsigned short (16 bits), unsigned int (32 bits) + types_list = [(255, "B"), (65_535, "u2"), (4_294_967_296, "u4")] + else: + # signe byte (8 bits), signed short (16 bits), signed int (32 bits): + types_list = [(127, "b"), (32_768, "i2"), (2_147_483_648, "i")] + filtered_list = [ + (max_val, type) for max_val, type in types_list if max_val > abs(value) + ] + if not filtered_list: + return "u8" if unsigned else "i8" # unsigned or signed long (64 bits) + return filtered_list[0][1] + + class Task(pl.LightningDataModule): """Base task class @@ -169,6 +213,13 @@ class Task(pl.LightningDataModule): ---------- protocol : Protocol pyannote.database protocol + cache : str, optional + As (meta-)data preparation might take a very long time for large datasets, + it can be cached to disk for later (and faster!) re-use. + When `cache` does not exist, `Task.prepare_data()` generates training + and validation metadata from `protocol` and save them to disk. + When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data + are loaded from disk. Defaults to a temporary path. duration : float, optional Chunks duration in seconds. Defaults to two seconds (2.). min_duration : float, optional @@ -201,11 +252,13 @@ class Task(pl.LightningDataModule): ---------- specifications : Specifications or tuple of Specifications Task specifications (available after `Task.setup` has been called.) + """ def __init__( self, protocol: Protocol, + cache: Optional[Union[str, None]] = None, duration: float = 2.0, min_duration: float = None, warm_up: Union[float, Tuple[float, float]] = 0.0, @@ -221,8 +274,16 @@ def __init__( self.protocol, checks = check_protocol(protocol) self.has_validation = checks["has_validation"] self.has_scope = checks["has_scope"] + if not self.has_scope: + raise ValueError( + "Protocol must provide 'scope' information (e.g. 'file', 'database', or 'global')." + ) + self.has_classes = checks["has_classes"] + # metadata cache + self.cache = Path(cache) if cache else cache + # batching self.duration = duration self.min_duration = duration if min_duration is None else min_duration @@ -255,24 +316,347 @@ def __init__( self._metric = metric def prepare_data(self): - """Use this to download and prepare data - - This is where we might end up downloading datasets - and transform them so that they are ready to be used - with pyannote.database. but for now, the API assume - that we directly provide a pyannote.database.Protocol. + """Use this to prepare data from task protocol Notes ----- - Called only once. + Called only once on the main process (and only on it), for global_rank 0. + + After this method is called, the task should have a `prepared_data` attribute + with the following dictionary structure: + + prepared_data = { + 'protocol': name of the protocol + 'audio-path': array of N paths to audio + 'audio-metadata': array of N audio infos such as audio subset, scope and database + 'audio-info': array of N audio torchaudio.info struct + 'audio-encoding': array of N audio encodings + 'audio-annotated': array of N annotated duration (usually equals file duration but might be shorter if file is not fully annotated) + 'annotations-regions': array of M annotated regions + 'annotations-segments': array of M' annotated segments + 'metadata-values': dict of lists of values for subset, scope and database + 'metadata-`database-name`-labels': array of `database-name` labels. Each database with "database" scope labels has it own array. + 'metadata-labels': array of global scope labels + } + + """ + + if self.cache: + # check if cache exists and is not empty: + if self.cache.exists() and self.cache.stat().st_size > 0: + # data was already created, nothing to do + return + # create parent directory if needed + self.cache.parent.mkdir(parents=True, exist_ok=True) + else: + # if no cache was provided by user, create a temporary file + # in system directory used for temp files + self.cache = Path(mkstemp()[1]) + + # list of possible values for each metadata key + # (will become .prepared_data[""]) + metadata_unique_values = defaultdict(list) + metadata_unique_values["subset"] = Subsets + metadata_unique_values["scope"] = Scopes + + audios = list() # list of path to audio files + audio_infos = list() + audio_encodings = list() + metadata = list() # list of metadata + + annotated_duration = list() # total duration of annotated regions (per file) + annotated_regions = list() # annotated regions + annotations = list() # actual annotations + unique_labels = list() + database_unique_labels = {} + + 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 label scope (file, database, or global) + metadatum["scope"] = Scopes.index(file["scope"]) + + 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) + + elif isinstance(value, int): + metadatum[key] = value + + else: + warnings.warn( + f"Ignoring '{key}' metadata because of its type ({type(value)}). Only str and int are supported for now.", + category=UserWarning, + ) + + metadata.append(metadatum) + + # 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 < self.duration: + continue + + # append annotated region + annotated_region = ( + file_id, + segment.duration, + segment.start, + ) + 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') + + # 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 + database = file["database"] + if database not in database_unique_labels: + database_unique_labels[database] = [] + if label not in database_unique_labels[database]: + database_unique_labels[database].append(label) + + # and convert label to its (database-scope) index + database_label_idx = database_unique_labels[database].index(label) + + if scope > 1: # 'global' + # 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) + + 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 + ] + metadata_dtype = [ + (key, get_dtype(max(m[i] for m in metadata))) + for i, key in enumerate(metadata_unique_values) + ] + + # turn list of files metadata into a single numpy array + # TODO: improve using https://github.com/pytorch/pytorch/issues/13246#issuecomment-617140519 + info_dtype = [ + ( + "sample_rate", + get_dtype(max(ai[0] for ai in audio_infos), unsigned=True), + ), + ( + "num_frames", + get_dtype(max(ai[1] for ai in audio_infos), unsigned=True), + ), + ("num_channels", "B"), + ("bits_per_sample", "B"), + ] + + # turn list of annotated regions into a single numpy array + region_dtype = [ + ( + "file_id", + get_dtype(max(ar[0] for ar in annotated_regions), unsigned=True), + ), + ("duration", "f"), + ("start", "f"), + ] + + # turn list of annotations into a single numpy array + segment_dtype = [ + ( + "file_id", + get_dtype(max(a[0] for a in annotations), unsigned=True), + ), + ("start", "f"), + ("end", "f"), + ("file_label_idx", get_dtype(max(a[3] for a in annotations))), + ("database_label_idx", get_dtype(max(a[4] for a in annotations))), + ("global_label_idx", get_dtype(max(a[5] for a in annotations))), + ] + + # save all protocol data in a dict + prepared_data = {} + + # keep track of protocol name + prepared_data["protocol"] = self.protocol.name + + prepared_data["audio-path"] = np.array(audios, dtype=np.string_) + audios.clear() + + prepared_data["audio-metadata"] = np.array(metadata, dtype=metadata_dtype) + metadata.clear() + + prepared_data["audio-info"] = np.array(audio_infos, dtype=info_dtype) + audio_infos.clear() + + prepared_data["audio-encoding"] = np.array(audio_encodings, dtype=np.string_) + audio_encodings.clear() + + prepared_data["audio-annotated"] = np.array(annotated_duration) + annotated_duration.clear() + + prepared_data["annotations-regions"] = np.array( + annotated_regions, dtype=region_dtype + ) + annotated_regions.clear() + + prepared_data["annotations-segments"] = np.array( + annotations, dtype=segment_dtype + ) + annotations.clear() + + prepared_data["metadata-values"] = metadata_unique_values + + for database, labels in database_unique_labels.items(): + prepared_data[f"metadata-{database}-labels"] = np.array( + labels, dtype=np.string_ + ) + database_unique_labels.clear() + + prepared_data["metadata-labels"] = np.array(unique_labels, dtype=np.string_) + unique_labels.clear() + + self.prepare_validation(prepared_data) + self.post_prepare_data(prepared_data) + + # save prepared data on the disk + with open(self.cache, "wb") as cache_file: + np.savez_compressed(cache_file, **prepared_data) + + def post_prepare_data(self, prepared_data: Dict): + """Method for completing `prepared_data` with task-specific data. + For instance, for a classification task, this could be a list of + possible classes. + + Parameters + ---------- + prepared_data: dict + dictionnary containing protocol data prepared by + `prepare_data()` + Note + ---- + This method does not return anything. Thus, user have to directly modify + `prepared_data`, for updates to be taken into account """ pass + def setup(self, stage=None): + """Setup data cached by prepare_data into the task on each device""" + + # send cache path on all processes used for the training, + # allowing them to access the cache generated by prepare_data + if stage == "fit": + self.cache = self.trainer.strategy.broadcast(self.cache) + + try: + with open(self.cache, "rb") as cache_file: + self.prepared_data = dict(np.load(cache_file, allow_pickle=True)) + except FileNotFoundError: + print( + "Cached data for protocol not found. Ensure that prepare_data() was called", + " and executed correctly or/and that the path to the task cache is correct.", + ) + raise + + # checks that the task current protocol matches the cached protocol + if self.protocol.name != self.prepared_data["protocol"]: + raise ValueError( + f"Protocol specified for the task ({self.protocol.name}) " + f"does not correspond to the cached one ({self.prepared_data['protocol']})" + ) + @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() + self.setup() return self._specifications @specifications.setter @@ -281,29 +665,6 @@ def 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 - ----- - This hook is called on every process when using DDP. - - If `specifications` attribute has not been set in `__init__`, - `setup` is your last chance to set it. - """ - - 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 03875256e..9b404f9cf 100644 --- a/pyannote/audio/tasks/embedding/mixins.py +++ b/pyannote/audio/tasks/embedding/mixins.py @@ -75,7 +75,7 @@ def batch_size(self) -> int: def batch_size(self, batch_size: int): self.batch_size_ = batch_size - def setup(self): + def setup(self, stage=None): # loop over the training set, remove annotated regions shorter than # chunk duration, and keep track of the reference annotations, per class. @@ -119,12 +119,6 @@ def setup(self): classes=sorted(self._train), ) - if not self.has_validation: - return - - if isinstance(self.protocol, SpeakerVerificationProtocol): - self._validation = list(self.protocol.development_trial()) - def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: @@ -250,9 +244,13 @@ def training_step(self, batch, batch_idx: int): return {"loss": loss} + def prepare_validation(self, prepared_dict: Dict): + if isinstance(self.protocol, SpeakerVerificationProtocol): + prepared_dict["validation"] = list(self.protocol.development_trial()) + def val__getitem__(self, idx): if isinstance(self.protocol, SpeakerVerificationProtocol): - trial = self._validation[idx] + trial = self.prepared_data["validation"][idx] data = dict() for idx in [1, 2]: @@ -281,7 +279,7 @@ def val__getitem__(self, idx): def val__len__(self): if isinstance(self.protocol, SpeakerVerificationProtocol): - return len(self._validation) + return len(self.prepared_data["validation"]) elif isinstance(self.protocol, SpeakerDiarizationProtocol): return 0 diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 94c6da506..1af863d89 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -23,14 +23,11 @@ import itertools import math import random -import warnings -from collections import defaultdict from typing import Dict, Sequence, Union import matplotlib.pyplot as plt import numpy as np import torch -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 @@ -38,23 +35,23 @@ from torchmetrics import Metric from torchmetrics.classification import BinaryAUROC, MulticlassAUROC, MultilabelAUROC -from pyannote.audio.core.task import Problem +from pyannote.audio.core.task import Problem, Task, get_dtype from pyannote.audio.utils.random import create_rng_for_worker Subsets = list(Subset.__args__) Scopes = list(Scope.__args__) -class SegmentationTaskMixin: +class SegmentationTask(Task): """Methods common to most segmentation tasks""" def get_file(self, file_id): file = dict() - file["audio"] = str(self.audios[file_id], encoding="utf-8") + file["audio"] = str(self.prepared_data["audio-path"][file_id], encoding="utf-8") - _audio_info = self.audio_infos[file_id] - _encoding = self.audio_encodings[file_id] + _audio_info = self.prepared_data["audio-info"][file_id] + _encoding = self.prepared_data["audio-encoding"][file_id] sample_rate = _audio_info["sample_rate"] num_frames = _audio_info["num_frames"] @@ -71,319 +68,6 @@ def get_file(self, file_id): return file - def setup(self): - """Setup""" - - # duration of training chunks - # TODO: handle variable duration case - duration = getattr(self, "duration", 0.0) - - # list of possible values for each metadata key - metadata_unique_values = defaultdict(list) - - metadata_unique_values["subset"] = Subsets - - if isinstance(self.protocol, SpeakerDiarizationProtocol): - metadata_unique_values["scope"] = Scopes - - elif isinstance(self.protocol, SegmentationProtocol): - classes = getattr(self, "classes", list()) - - # 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) - - audios = list() # list of path to audio files - audio_infos = list() - audio_encodings = list() - metadata = list() # list of metadata - - 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() - - 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) - ] - ) - - 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) - - elif isinstance(value, int): - metadatum[key] = value - - else: - warnings.warn( - f"Ignoring '{key}' metadata because of its type ({type(value)}). Only str and int are supported for now.", - category=UserWarning, - ) - - metadata.append(metadatum) - - database_unique_labels = list() - - # 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' - # 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 - - validation_chunks = list() - - # obtain indexes of files in the validation subset - validation_file_ids = np.where( - self.metadata["subset"] == Subsets.index("development") - )[0] - - # 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 - ] - - # iterate over annotated regions - for annotated_region in annotated_regions: - # number of chunks in annotated region - num_chunks = round(annotated_region["duration"] // duration) - - # iterate over chunks - for c in range(num_chunks): - start_time = annotated_region["start"] + c * duration - validation_chunks.append((file_id, start_time, duration)) - - dtype = [("file_id", "i"), ("start", "f"), ("duration", "f")] - self.validation_chunks = np.array(validation_chunks, dtype=dtype) - def default_metric( self, ) -> Union[Metric, Sequence[Metric], Dict[str, Metric]]: @@ -419,15 +103,17 @@ def train__iter__helper(self, rng: random.Random, **filters): """ # indices of training files that matches domain filters - training = self.metadata["subset"] == Subsets.index("train") + training = self.prepared_data["audio-metadata"]["subset"] == Subsets.index( + "train" + ) for key, value in filters.items(): - training &= self.metadata[key] == self.metadata_unique_values[key].index( - value - ) + training &= self.prepared_data["audio-metadata"][key] == self.prepared_data[ + "metadata" + ][key].index(value) file_ids = np.where(training)[0] # turn annotated duration into a probability distribution - annotated_duration = self.annotated_duration[file_ids] + annotated_duration = self.prepared_data["audio-annotated"][file_ids] cum_prob_annotated_duration = np.cumsum( annotated_duration / np.sum(annotated_duration) ) @@ -444,14 +130,19 @@ def train__iter__helper(self, rng: random.Random, **filters): 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 + self.prepared_data["annotations-regions"]["file_id"] == file_id )[0] # turn annotated regions duration into a probability distribution + cum_prob_annotated_regions_duration = np.cumsum( - self.annotated_regions["duration"][annotated_region_indices] + self.prepared_data["annotations-regions"]["duration"][ + annotated_region_indices + ] / np.sum( - self.annotated_regions["duration"][annotated_region_indices] + self.prepared_data["annotations-regions"]["duration"][ + annotated_region_indices + ] ) ) @@ -461,8 +152,10 @@ def train__iter__helper(self, rng: random.Random, **filters): ] # select one chunk at random in this annotated region - _, _, start, end = self.annotated_regions[annotated_region_index] - start_time = rng.uniform(start, end - duration) + _, region_duration, start = self.prepared_data["annotations-regions"][ + annotated_region_index + ] + start_time = rng.uniform(start, start + region_duration - duration) yield self.prepare_chunk(file_id, start_time, duration) @@ -492,7 +185,7 @@ 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.prepared_data["metadata"][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: @@ -564,11 +257,48 @@ def collate_fn(self, batch, stage="train"): def train__len__(self): # Number of training samples in one epoch - duration = np.sum(self.annotated_duration) + duration = np.sum(self.prepared_data["audio-annotated"]) return max(self.batch_size, math.ceil(duration / self.duration)) + def prepare_validation(self, prepared_data: Dict): + validation_chunks = list() + + # obtain indexes of files in the validation subset + validation_file_ids = np.where( + prepared_data["audio-metadata"]["subset"] == Subsets.index("development") + )[0] + + # iterate over files in the validation subset + for file_id in validation_file_ids: + # get annotated regions in file + annotated_regions = prepared_data["annotations-regions"][ + prepared_data["annotations-regions"]["file_id"] == file_id + ] + + # iterate over annotated regions + for annotated_region in annotated_regions: + # number of chunks in annotated region + num_chunks = round(annotated_region["duration"] // self.duration) + + # iterate over chunks + for c in range(num_chunks): + start_time = annotated_region["start"] + c * self.duration + validation_chunks.append((file_id, start_time, self.duration)) + + dtype = [ + ( + "file_id", + get_dtype(max(v[0] for v in validation_chunks), unsigned=True), + ), + ("start", "f"), + ("duration", "f"), + ] + + prepared_data["validation"] = np.array(validation_chunks, dtype=dtype) + validation_chunks.clear() + def val__getitem__(self, idx): - validation_chunk = self.validation_chunks[idx] + validation_chunk = self.prepared_data["validation"][idx] return self.prepare_chunk( validation_chunk["file_id"], validation_chunk["start"], @@ -576,7 +306,7 @@ def val__getitem__(self, idx): ) def val__len__(self): - return len(self.validation_chunks) + return len(self.prepared_data["validation"]) def validation_step(self, batch, batch_idx: int): """Compute validation area under the ROC curve diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index c1d58431a..c641b5c3e 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -20,6 +20,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +import itertools +import textwrap from typing import Dict, List, Optional, Sequence, Text, Tuple, Union import numpy as np @@ -31,11 +33,11 @@ from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric -from pyannote.audio.core.task import Problem, Resolution, Specifications, Task -from pyannote.audio.tasks.segmentation.mixins import SegmentationTaskMixin +from pyannote.audio.core.task import Problem, Resolution, Specifications +from pyannote.audio.tasks.segmentation.mixins import SegmentationTask -class MultiLabelSegmentation(SegmentationTaskMixin, Task): +class MultiLabelSegmentation(SegmentationTask): """Generic multi-label segmentation Multi-label segmentation is the process of detecting temporal intervals @@ -47,7 +49,13 @@ class MultiLabelSegmentation(SegmentationTaskMixin, Task): Parameters ---------- protocol : Protocol - pyannote.database protocol + cache : str, optional + As (meta-)data preparation might take a very long time for large datasets, + it can be cached to disk for later (and faster!) re-use. + When `cache` does not exist, `Task.prepare_data()` generates training + and validation metadata from `protocol` and save them to disk. + When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data + are loaded from disk. Defaults to a temporary path. classes : List[str], optional List of classes. Defaults to the list of classes available in the training set. duration : float, optional @@ -84,6 +92,7 @@ class MultiLabelSegmentation(SegmentationTaskMixin, Task): def __init__( self, protocol: Protocol, + cache: Optional[Union[str, None]] = None, classes: Optional[List[str]] = None, duration: float = 2.0, warm_up: Union[float, Tuple[float, float]] = 0.0, @@ -109,6 +118,7 @@ def __init__( pin_memory=pin_memory, augmentation=augmentation, metric=metric, + cache=cache, ) self.balance = balance @@ -119,11 +129,114 @@ def __init__( # classes should be detected. therefore, we postpone the definition of # specifications to setup() - def setup(self): - super().setup() + def post_prepare_data(self, prepared_data: Dict): + # as 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), we keep track of this information. this is used + # to know whether a missing class is considered a negative example (0) or + # simple an unknown example (-1) + + if self.classes is None and not self.has_classes: + msg = textwrap.dedent( + """ + Could not infer list of classes. Either provide a list of classes when + instantiating the task, or make sure that the training protocol provides + a 'classes' entry. See https://github.com/pyannote/pyannote-database#segmentation + for more details. + """ + ) + + if self.has_validation: + files_iter = itertools.chain( + self.protocol.train(), self.protocol.development() + ) + else: + files_iter = self.protocol.train() + + if self.classes is None: + classes = list() # overall list of classes + annotated_classes = list() # list of annotated classes (per file) + + for file in files_iter: + file_classes = file.get("classes", None) + + if not file_classes: + msg = textwrap.dedent( + f""" + File "{file['uri']}" (from {file['database']} database) does not + provide a 'classes' entry. Please make sure the corresponding + training protocol provides a 'classes' entry for all files. See + https://github.com/pyannote/pyannote-database#segmentation for more + details. + """ + ) + raise ValueError(msg) + + for klass in file_classes: + if klass not in classes: + classes.append(klass) + annotated_classes.append( + [classes.index(klass) for klass in file_classes] + ) + + prepared_data["classes-list"] = np.array(classes, dtype=np.string_) + self.classes = classes + + else: + annotated_classes = list() # list of annotated classes (per file) + for file in files_iter: + file_classes = file.get("classes", None) + + if not file_classes: + msg = textwrap.dedent( + f""" + File "{file['uri']}" (from {file['database']} database) does not + provide a 'classes' entry. Please make sure the corresponding + training protocol provides a 'classes' entry for all files. See + https://github.com/pyannote/pyannote-database#segmentation for more + details. + """ + ) + raise ValueError(msg) + + extra_classes = set(file_classes) - set(self.classes) + if extra_classes: + msg = textwrap.dedent( + f""" + File "{file['uri']}" (from {file['database']} database) provides + extra classes ({', '.join(extra_classes)}) that are ignored. + """ + ) + print(msg) + + annotated_classes.append( + [ + self.classes.index(klass) + for klass in set(file_classes) & set(self.classes) + ] + ) + + prepared_data["classes-list"] = np.array(self.classes, dtype=np.string_) + + # 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) + annotated_classes_array = np.zeros( + (len(annotated_classes), len(self.classes)), dtype=np.bool_ + ) + for file_id, classes in enumerate(annotated_classes): + annotated_classes_array[file_id, classes] = True + prepared_data["classes-annotated"] = annotated_classes_array + annotated_classes.clear() + + def setup(self, stage=None): + super().setup(stage) self.specifications = Specifications( - classes=self.classes, + classes=self.prepared_data["classes-list"], problem=Problem.MULTI_LABEL_CLASSIFICATION, resolution=Resolution.FRAME, duration=self.duration, @@ -169,7 +282,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): sample = dict() sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) # gather all annotations of current file - annotations = self.annotations[self.annotations["file_id"] == file_id] + annotations = self.prepared_data["annotations-segments"][ + self.prepared_data["annotations-segments"]["file_id"] == file_id + ] # gather all annotations with non-empty intersection with current chunk chunk_annotations = annotations[ @@ -184,9 +299,13 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): # frame-level targets (-1 for un-annotated classes) y = -np.ones( - (self.model.example_output.num_frames, len(self.classes)), dtype=np.int8 + ( + self.model.example_output.num_frames, + len(self.prepared_data["classes-list"]), + ), + dtype=np.int8, ) - y[:, self.annotated_classes[file_id]] = 0 + y[:, self.prepared_data["classes-annotated"][file_id]] = 0 for start, end, label in zip( start_idx, end_idx, chunk_annotations["global_label_idx"] ): @@ -196,7 +315,7 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): y, self.model.example_output.frames, labels=self.classes ) - metadata = self.metadata[file_id] + metadata = self.prepared_data["audio-metadata"][file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} sample["meta"]["file"] = file_id diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index 0b7209c5c..7249ed0f4 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -21,7 +21,7 @@ # SOFTWARE. -from typing import Dict, Sequence, Text, Tuple, Union +from typing import Dict, Optional, Sequence, Text, Tuple, Union import numpy as np from pyannote.core import Segment, SlidingWindowFeature @@ -29,11 +29,11 @@ from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric -from pyannote.audio.core.task import Problem, Resolution, Specifications, Task -from pyannote.audio.tasks.segmentation.mixins import SegmentationTaskMixin +from pyannote.audio.core.task import Problem, Resolution, Specifications +from pyannote.audio.tasks.segmentation.mixins import SegmentationTask -class OverlappedSpeechDetection(SegmentationTaskMixin, Task): +class OverlappedSpeechDetection(SegmentationTask): """Overlapped speech detection Overlapped speech detection is the task of detecting regions where at least @@ -51,6 +51,13 @@ class OverlappedSpeechDetection(SegmentationTaskMixin, Task): ---------- protocol : Protocol pyannote.database protocol + cache : str, optional + As (meta-)data preparation might take a very long time for large datasets, + it can be cached to disk for later (and faster!) re-use. + When `cache` does not exist, `Task.prepare_data()` generates training + and validation metadata from `protocol` and save them to disk. + When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data + are loaded from disk. Defaults to a temporary path. duration : float, optional Chunks duration. Defaults to 2s. warm_up : float or (float, float), optional @@ -105,6 +112,7 @@ def __init__( pin_memory: bool = False, augmentation: BaseWaveformTransform = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, + cache: Optional[Union[str, None]] = None, ): super().__init__( protocol, @@ -115,6 +123,7 @@ def __init__( pin_memory=pin_memory, augmentation=augmentation, metric=metric, + cache=cache, ) self.specifications = Specifications( @@ -163,7 +172,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) # gather all annotations of current file - annotations = self.annotations[self.annotations["file_id"] == file_id] + annotations = self.prepared_data["annotations-segments"][ + self.prepared_data["annotations-segments"]["file_id"] == file_id + ] # gather all annotations with non-empty intersection with current chunk chunk_annotations = annotations[ @@ -186,7 +197,7 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): y, self.model.example_output.frames, labels=["speech"] ) - metadata = self.metadata[file_id] + metadata = self.prepared_data["audio-metadata"][file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} sample["meta"]["file"] = file_id diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index 1094672ed..47c5adc63 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, Sequence, Text, Tuple, Union +from typing import Dict, Literal, Optional, Sequence, Text, Tuple, Union import numpy as np import torch @@ -37,8 +37,8 @@ from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric -from pyannote.audio.core.task import Problem, Resolution, Specifications, Task -from pyannote.audio.tasks.segmentation.mixins import SegmentationTaskMixin +from pyannote.audio.core.task import Problem, Resolution, Specifications +from pyannote.audio.tasks.segmentation.mixins import SegmentationTask from pyannote.audio.torchmetrics import ( DiarizationErrorRate, FalseAlarmRate, @@ -58,13 +58,20 @@ Scopes = list(Scope.__args__) -class SpeakerDiarization(SegmentationTaskMixin, Task): +class SpeakerDiarization(SegmentationTask): """Speaker diarization Parameters ---------- protocol : SpeakerDiarizationProtocol pyannote.database protocol + cache : str, optional + As (meta-)data preparation might take a very long time for large datasets, + it can be cached to disk for later (and faster!) re-use. + When `cache` does not exist, `Task.prepare_data()` generates training + and validation metadata from `protocol` and save them to disk. + When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data + are loaded from disk. Defaults to a temporary path. duration : float, optional Chunks duration. Defaults to 2s. max_speakers_per_chunk : int, optional @@ -127,6 +134,7 @@ class SpeakerDiarization(SegmentationTaskMixin, Task): def __init__( self, protocol: SpeakerDiarizationProtocol, + cache: Optional[Union[str, None]] = None, duration: float = 2.0, max_speakers_per_chunk: int = None, max_speakers_per_frame: int = None, @@ -152,6 +160,7 @@ def __init__( pin_memory=pin_memory, augmentation=augmentation, metric=metric, + cache=cache, ) if not isinstance(protocol, SpeakerDiarizationProtocol): @@ -186,28 +195,34 @@ def __init__( self.weight = weight self.vad_loss = vad_loss - def setup(self): - super().setup() + def setup(self, stage=None): + super().setup(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") + training = self.prepared_data["audio-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] + annotations = self.prepared_data["annotations-segments"][ + np.where( + self.prepared_data["annotations-segments"]["file_id"] == file_id + )[0] ] - annotated_regions = self.annotated_regions[ - np.where(self.annotated_regions["file_id"] == file_id)[0] + annotated_regions = self.prepared_data["annotations-regions"][ + np.where( + self.prepared_data["annotations-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_end = region["start"] + region["duration"] region_annotations = annotations[ np.where( (annotations["start"] >= region_start) @@ -318,7 +333,7 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): file = self.get_file(file_id) # get label scope - label_scope = Scopes[self.metadata[file_id]["scope"]] + label_scope = Scopes[self.prepared_data["audio-metadata"][file_id]["scope"]] label_scope_key = f"{label_scope}_label_idx" # @@ -328,7 +343,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) # gather all annotations of current file - annotations = self.annotations[self.annotations["file_id"] == file_id] + annotations = self.prepared_data["annotations-segments"][ + self.prepared_data["annotations-segments"]["file_id"] == file_id + ] # gather all annotations with non-empty intersection with current chunk chunk_annotations = annotations[ @@ -364,7 +381,7 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): y, self.model.example_output.frames, labels=labels ) - metadata = self.metadata[file_id] + metadata = self.prepared_data["audio-metadata"][file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} sample["meta"]["file"] = file_id diff --git a/pyannote/audio/tasks/segmentation/voice_activity_detection.py b/pyannote/audio/tasks/segmentation/voice_activity_detection.py index fd9eb8e75..183fa2ffc 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -20,7 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -from typing import Dict, Sequence, Text, Tuple, Union +from typing import Dict, Optional, Sequence, Text, Tuple, Union import numpy as np from pyannote.core import Segment, SlidingWindowFeature @@ -28,11 +28,11 @@ from torch_audiomentations.core.transforms_interface import BaseWaveformTransform from torchmetrics import Metric -from pyannote.audio.core.task import Problem, Resolution, Specifications, Task -from pyannote.audio.tasks.segmentation.mixins import SegmentationTaskMixin +from pyannote.audio.core.task import Problem, Resolution, Specifications +from pyannote.audio.tasks.segmentation.mixins import SegmentationTask -class VoiceActivityDetection(SegmentationTaskMixin, Task): +class VoiceActivityDetection(SegmentationTask): """Voice activity detection Voice activity detection (or VAD) is the task of detecting speech regions @@ -45,6 +45,13 @@ class VoiceActivityDetection(SegmentationTaskMixin, Task): ---------- protocol : Protocol pyannote.database protocol + cache : str, optional + As (meta-)data preparation might take a very long time for large datasets, + it can be cached to disk for later (and faster!) re-use. + When `cache` does not exist, `Task.prepare_data()` generates training + and validation metadata from `protocol` and save them to disk. + When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data + are loaded from disk. Defaults to a temporary path. duration : float, optional Chunks duration. Defaults to 2s. warm_up : float or (float, float), optional @@ -79,6 +86,7 @@ class VoiceActivityDetection(SegmentationTaskMixin, Task): def __init__( self, protocol: Protocol, + cache: Optional[Union[str, None]] = None, duration: float = 2.0, warm_up: Union[float, Tuple[float, float]] = 0.0, balance: Sequence[Text] = None, @@ -98,6 +106,7 @@ def __init__( pin_memory=pin_memory, augmentation=augmentation, metric=metric, + cache=cache, ) self.balance = balance @@ -145,7 +154,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration) # gather all annotations of current file - annotations = self.annotations[self.annotations["file_id"] == file_id] + annotations = self.prepared_data["annotations-segments"][ + self.prepared_data["annotations-segments"]["file_id"] == file_id + ] # gather all annotations with non-empty intersection with current chunk chunk_annotations = annotations[ @@ -167,7 +178,7 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): y, self.model.example_output.frames, labels=["speech"] ) - metadata = self.metadata[file_id] + metadata = self.prepared_data["audio-metadata"][file_id] sample["meta"] = {key: metadata[key] for key in metadata.dtype.names} sample["meta"]["file"] = file_id diff --git a/tests/tasks/test_reproducibility.py b/tests/tasks/test_reproducibility.py index a7307e0cf..88f2b2d8a 100644 --- a/tests/tasks/test_reproducibility.py +++ b/tests/tasks/test_reproducibility.py @@ -3,7 +3,7 @@ from pyannote.database import FileFinder, get_protocol from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel -from pyannote.audio.tasks import MultiLabelSegmentation, VoiceActivityDetection +from pyannote.audio.tasks import VoiceActivityDetection def setup_tasks(task): @@ -16,7 +16,8 @@ def setup_tasks(task): def create_dl(model, task): m = model(task=task) - m.setup("fit") + m.prepare_data() + m.setup() return task.train_dataloader() @@ -31,35 +32,32 @@ 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" - for task in [VoiceActivityDetection, MultiLabelSegmentation]: + seed_everything(1) + protocol, vad = setup_tasks(VoiceActivityDetection) + dl = create_dl(SimpleSegmentationModel, vad) + last5a = get_next5(dl) - seed_everything(1) - protocol, vad = setup_tasks(task) - dl = create_dl(SimpleSegmentationModel, vad) - last5a = get_next5(dl) + seed_everything(1) + protocol, vad = setup_tasks(VoiceActivityDetection) + dl = create_dl(SimpleSegmentationModel, vad) + last5b = get_next5(dl) - seed_everything(1) - protocol, vad = setup_tasks(task) - dl = create_dl(SimpleSegmentationModel, vad) - last5b = get_next5(dl) - - for i in range(len(last5b)): - assert torch.equal(last5a[i]["X"], last5b[i]["X"]) + for i in range(len(last5b)): + assert torch.equal(last5a[i]["X"], last5b[i]["X"]) def test_different_seeds(): "Changing the global seed will change the order of the data that loads" - for task in [VoiceActivityDetection, MultiLabelSegmentation]: - protocol, vad = setup_tasks(task) - seed_everything(4) - dl = create_dl(SimpleSegmentationModel, vad) - last5a = get_next5(dl) + protocol, vad = setup_tasks(VoiceActivityDetection) + seed_everything(4) + dl = create_dl(SimpleSegmentationModel, vad) + last5a = get_next5(dl) - protocol, vad = setup_tasks(task) - seed_everything(5) - dl = create_dl(SimpleSegmentationModel, vad) - last5b = get_next5(dl) + protocol, vad = setup_tasks(VoiceActivityDetection) + seed_everything(5) + dl = create_dl(SimpleSegmentationModel, vad) + last5b = get_next5(dl) - for i in range(5): - assert not torch.equal(last5a[i]["X"], last5b[i]["X"]) + for i in range(5): + assert not torch.equal(last5a[i]["X"], last5b[i]["X"]) diff --git a/tests/test_train.py b/tests/test_train.py index 7a7bfe338..6a7a6c69b 100644 --- a/tests/test_train.py +++ b/tests/test_train.py @@ -1,11 +1,39 @@ +# The MIT License (MIT) +# +# Copyright (c) 2024- 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 tempfile import mkstemp + import pytest from pyannote.database import FileFinder, get_protocol from pytorch_lightning import Trainer +from pyannote.audio.models.embedding.debug import SimpleEmbeddingModel from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel from pyannote.audio.tasks import ( + MultiLabelSegmentation, OverlappedSpeechDetection, SpeakerDiarization, + SupervisedRepresentationLearningWithArcFace, VoiceActivityDetection, ) @@ -17,6 +45,31 @@ def protocol(): ) +@pytest.fixture() +def cache(): + return mkstemp()[1] + + +@pytest.fixture() +def gender_protocol(): + def to_gender(file): + annotation = file["annotation"] + mapping = {label: label[0] for label in annotation.labels()} + return annotation.rename_labels(mapping) + + def classes(file): + return ["M", "F"] + + return get_protocol( + "Debug.SpeakerDiarization.Debug", + preprocessors={ + "audio": FileFinder(), + "annotation": to_gender, + "classes": classes, + }, + ) + + def test_train_segmentation(protocol): segmentation = SpeakerDiarization(protocol) model = SimpleSegmentationModel(task=segmentation) @@ -24,6 +77,48 @@ def test_train_segmentation(protocol): trainer.fit(model) +def test_train_segmentation_with_cached_data_mono_device(protocol, cache): + first_task = SpeakerDiarization(protocol, cache=cache) + first_model = SimpleSegmentationModel(task=first_task) + first_trainer = Trainer(fast_dev_run=True, accelerator="cpu", devices=1) + first_trainer.fit(first_model) + + second_task = SpeakerDiarization(protocol, cache=cache) + second_model = SimpleSegmentationModel(task=second_task) + second_trainer = Trainer(fast_dev_run=True, accelerator="cpu", devices=1) + second_trainer.fit(second_model) + + +def test_train_multilabel_segmentation(gender_protocol): + multilabel_segmentation = MultiLabelSegmentation(gender_protocol) + model = SimpleSegmentationModel(task=multilabel_segmentation) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") + trainer.fit(model) + + +def test_train_multilabel_segmentation_with_cached_data_mono_device( + gender_protocol, cache +): + first_task = MultiLabelSegmentation(gender_protocol, cache=cache) + first_model = SimpleSegmentationModel(task=first_task) + first_trainer = Trainer(fast_dev_run=True, accelerator="cpu", devices=1) + first_trainer.fit(first_model) + + second_task = MultiLabelSegmentation(gender_protocol, cache=cache) + second_model = SimpleSegmentationModel(task=second_task) + second_trainer = Trainer(fast_dev_run=True, accelerator="cpu", devices=1) + second_trainer.fit(second_model) + + +def test_train_supervised_representation_with_arcface(protocol): + supervised_representation_with_arface = SupervisedRepresentationLearningWithArcFace( + protocol + ) + model = SimpleEmbeddingModel(task=supervised_representation_with_arface) + 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) @@ -31,6 +126,18 @@ def test_train_voice_activity_detection(protocol): trainer.fit(model) +def test_train_voice_activity_detection_with_cached_data_mono_device(protocol, cache): + first_task = VoiceActivityDetection(protocol, cache=cache) + first_model = SimpleSegmentationModel(task=first_task) + first_trainer = Trainer(fast_dev_run=True, accelerator="cpu", devices=1) + first_trainer.fit(first_model) + + second_task = VoiceActivityDetection(protocol, cache=cache) + second_model = SimpleSegmentationModel(task=second_task) + second_trainer = Trainer(fast_dev_run=True, accelerator="cpu", devices=1) + second_trainer.fit(second_model) + + def test_train_overlapped_speech_detection(protocol): overlapped_speech_detection = OverlappedSpeechDetection(protocol) model = SimpleSegmentationModel(task=overlapped_speech_detection) @@ -38,6 +145,20 @@ def test_train_overlapped_speech_detection(protocol): trainer.fit(model) +def test_train_overlapped_speech_detection_with_cached_data_mono_device( + protocol, cache +): + first_task = OverlappedSpeechDetection(protocol, cache=cache) + first_model = SimpleSegmentationModel(task=first_task) + first_trainer = Trainer(fast_dev_run=True, accelerator="cpu", devices=1) + first_trainer.fit(first_model) + + second_task = OverlappedSpeechDetection(protocol, cache=cache) + second_model = SimpleSegmentationModel(task=second_task) + second_trainer = Trainer(fast_dev_run=True, accelerator="cpu", devices=1) + second_trainer.fit(second_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) @@ -62,6 +183,18 @@ def test_finetune_with_task_that_needs_setup_for_specs(protocol): trainer.fit(model) +def test_finetune_with_task_that_needs_setup_for_specs_and_with_cache(protocol, cache): + segmentation = SpeakerDiarization(protocol, cache=cache) + model = SimpleSegmentationModel(task=segmentation) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") + trainer.fit(model) + + segmentation = SpeakerDiarization(protocol, cache=cache) + model.task = segmentation + 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) @@ -94,7 +227,22 @@ def test_finetune_freeze_with_task_that_needs_setup_for_specs(protocol): segmentation = SpeakerDiarization(protocol) model.task = segmentation - model.freeze_up_to("mfcc") + model.freeze_by_name("mfcc") + trainer = Trainer(fast_dev_run=True, accelerator="cpu") + trainer.fit(model) + + +def test_finetune_freeze_with_task_that_needs_setup_for_specs_and_with_cache( + protocol, cache +): + segmentation = SpeakerDiarization(protocol, cache=cache) + model = SimpleSegmentationModel(task=segmentation) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") + trainer.fit(model) + + segmentation = SpeakerDiarization(protocol, cache=cache) + model.task = segmentation + model.freeze_by_name("mfcc") trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) @@ -107,7 +255,23 @@ def test_finetune_freeze_with_task_that_does_not_need_setup_for_specs(protocol): vad = VoiceActivityDetection(protocol) model.task = vad - model.freeze_up_to("mfcc") + model.freeze_by_name("mfcc") + trainer = Trainer(fast_dev_run=True, accelerator="cpu") + trainer.fit(model) + + +def test_finetune_freeze_with_task_that_does_not_need_setup_for_specs_and_with_cache( + protocol, + cache, +): + vad = VoiceActivityDetection(protocol, cache=cache) + model = SimpleSegmentationModel(task=vad) + trainer = Trainer(fast_dev_run=True, accelerator="cpu") + trainer.fit(model) + + vad = VoiceActivityDetection(protocol, cache=cache) + model.task = vad + model.freeze_by_name("mfcc") trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) @@ -120,7 +284,7 @@ def test_transfer_freeze_with_task_that_does_not_need_setup_for_specs(protocol): voice_activity_detection = VoiceActivityDetection(protocol) model.task = voice_activity_detection - model.freeze_up_to("mfcc") + model.freeze_by_name("mfcc") trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) @@ -133,6 +297,6 @@ def test_transfer_freeze_with_task_that_needs_setup_for_specs(protocol): segmentation = SpeakerDiarization(protocol) model.task = segmentation - model.freeze_up_to("mfcc") + model.freeze_by_name("mfcc") trainer = Trainer(fast_dev_run=True, accelerator="cpu") trainer.fit(model) diff --git a/tutorials/MRE_template.ipynb b/tutorials/MRE_template.ipynb index 7a44c1449..70ffacbc2 100644 --- a/tutorials/MRE_template.ipynb +++ b/tutorials/MRE_template.ipynb @@ -2217,4 +2217,4 @@ "outputs": [] } ] -} \ No newline at end of file +} diff --git a/tutorials/adapting_pretrained_pipeline.ipynb b/tutorials/adapting_pretrained_pipeline.ipynb index 06d318809..d7096fb77 100644 --- a/tutorials/adapting_pretrained_pipeline.ipynb +++ b/tutorials/adapting_pretrained_pipeline.ipynb @@ -344,6 +344,7 @@ " loss=\"bce\", \n", " vad_loss=\"bce\")\n", "model.task = task\n", + "model.prepare_data()\n", "model.setup(stage=\"fit\")" ] }, diff --git a/tutorials/add_your_own_task.ipynb b/tutorials/add_your_own_task.ipynb index 6e1575dc8..38daa73fb 100644 --- a/tutorials/add_your_own_task.ipynb +++ b/tutorials/add_your_own_task.ipynb @@ -147,13 +147,14 @@ "metadata": {}, "outputs": [], "source": [ - "from typing import Optional\n", - "import torch\n", - "import torch.nn as nn\n", + "from math import ceil\n", + "from typing import Dict, Optional,Tuple, Union\n", "import numpy as np\n", - "from pyannote.core import Annotation\n", - "from pyannote.audio import Model\n", + "from pyannote.core import Segment, SlidingWindow\n", + "from pyannote.audio.utils.random import create_rng_for_worker\n", "from pyannote.audio.core.task import Task, Resolution\n", + "from pyannote.database import Protocol\n", + "from torchmetrics.classification import MultilabelAUROC\n", "\n", "# Your custom task must be a subclass of `pyannote.audio.core.task.Task`\n", "class SoundEventDetection(Task):\n", @@ -163,11 +164,13 @@ " self,\n", " protocol: Protocol,\n", " duration: float = 5.0,\n", + " min_duration: float = 5.0,\n", " warm_up: Union[float, Tuple[float, float]] = 0.0,\n", " batch_size: int = 32,\n", " num_workers: int = None,\n", " pin_memory: bool = False,\n", - " augmentation: BaseWaveformTransform = None,\n", + " augmentation = None,\n", + " cache: Optional[Union[str, None]] = None,\n", " **other_params,\n", " ):\n", "\n", @@ -180,28 +183,62 @@ " num_workers=num_workers,\n", " pin_memory=pin_memory,\n", " augmentation=augmentation,\n", + " cache=cache,\n", " )\n", + " \n", + " def prepare_data(self):\n", + " # this method is called to prepare data from the specified protocol. \n", + " # For most tasks, calling Task.prepare_data() is sufficient. If you \n", + " # need to prepare task-specific data, define a post_prepare_data method for your task.\n", + " super().prepare_data()\n", "\n", - " def setup(self):\n", + " def post_prepare_data(self, prepared_data: Dict):\n", + " # this method is called at the end of Task.prepare_data() \n", + " # to complete data preparation with task-specific data, here \n", + " # the list of classes and some training metadata\n", "\n", " # load metadata for training subset\n", - " self.train_metadata_ = list()\n", + " prepared_data[\"train_metadata\"] = list()\n", " for training_file in self.protocol.train():\n", - " self.training_metadata_.append({\n", + " prepared_data[\"train_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", + " \"duration\": training_file[\"torchaudio.info\"].num_frames / training_file[\"torchaudio.info\"].sample_rate,\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", + " for training_file in prepared_data[\"train_metadata\"]:\n", + " classes.update(training_file[\"annotation\"].labels())\n", + " prepared_data[\"classes\"] = sorted(classes)\n", + "\n", + " # `has_validation` is True if protocol defines a development set\n", + " if not self.has_validation:\n", + " return\n", + " \n", + " def prepare_validation(self, prepared_data : Dict):\n", + " # this method is called at the end of Task.prepare_data(), to complete data preparation\n", + " # with task validation elements\n", + " \n", + " # load metadata for validation subset\n", + " prepared_data[\"validation\"] = list()\n", + " for validation_file in self.protocol.development():\n", + " prepared_data[\"validation\"].append({\n", + " \"audio\": validation_file[\"audio\"],\n", + " \"num_samples\": validation_file[\"torchaudio.info\"].num_frames,\n", + " \"annotation\": validation_file[\"annotation\"],\n", + " })\n", + " \n", + " \n", + " def setup(self, stage: Optional[Union[str, None]] = None):\n", + " # this method assigns prepared data from task.prepare_data() to the task\n", + " # and declares the task specifications\n", "\n", + " super().setup(stage)\n", + " \n", " # specify the addressed problem\n", " self.specifications = Specifications(\n", " # it is a multi-label classification problem\n", @@ -212,22 +249,13 @@ " # 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", + " classes=self.prepared_data[\"classes\"])\n", + " \n", + " def default_metric(self):\n", + " # this method defines the default metrics used to evaluate the model during\n", + " # a training\n", + " num_classes = len(self.specifications.classes)\n", + " return MultilabelAUROC(num_classes, average=\"macro\", compute_on_cpu=True)\n", "\n", " def train__iter__(self):\n", " # this method generates training samples, one at a time, \"ad infinitum\". each worker \n", @@ -246,7 +274,7 @@ " while True:\n", "\n", " # select training file at random\n", - " random_training_file, *_ = rng.choices(self.train_metadata_, k=1)\n", + " random_training_file, *_ = rng.choices(self.prepared_data[\"train_metadata\"], k=1)\n", "\n", " # select one chunk at random \n", " random_start_time = rng.uniform(0, random_training_file[\"duration\"] - self.duration)\n", @@ -275,8 +303,8 @@ " # we compute this number as the total duration of the training set divided by \n", " # duration of training chunks. we make sure that an epoch is at least one batch long,\n", " # or pytorch-lightning will complain\n", - " train_duration = sum(training_file[\"duration\"] for training_file in self.train_metadata_)\n", - " return max(self.batch_size, math.ceil(train_duration / self.duration))\n", + " train_duration = sum(training_file[\"duration\"] for training_file in self.prepared_data[\"train_metadata\"])\n", + " return max(self.batch_size, ceil(train_duration / self.duration))\n", "\n", " def val__getitem__(self, sample_idx):\n", "\n", @@ -287,9 +315,9 @@ "\n", " # find which part of the validation set corresponds to sample_idx\n", " num_samples = np.cumsum([\n", - " validation_file[\"num_samples\"] for validation_file in self.validation_metadata_])\n", + " validation_file[\"num_samples\"] for validation_file in self.prepared_data[\"validation\"]])\n", " file_idx = np.where(num_samples < sample_idx)[0][0]\n", - " validation_file = self.validation_metadata_[file_idx]\n", + " validation_file = self.prepared_data[\"validation\"][file_idx]\n", " idx = sample_idx - (num_samples[file_idx] - validation_file[\"num_samples\"]) \n", " chunk = SlidingWindow(start=0., duration=self.duration, step=self.duration)[idx]\n", "\n", @@ -299,7 +327,7 @@ " # load labels corresponding to random chunk as {0|1} numpy array\n", " # y[k] = 1 means that kth class is active\n", " y = np.zeros((num_classes,))\n", - " active_classes = validaiton_file[\"annotation\"].crop(chunk).labels()\n", + " active_classes = validation_file[\"annotation\"].crop(chunk).labels()\n", " for active_class in active_classes:\n", " y[classes.index(active_class)] = 1\n", "\n", @@ -307,7 +335,7 @@ "\n", " def val__len__(self):\n", " return sum(validation_file[\"num_samples\"] \n", - " for validation_file in self.validation_metadata_)\n", + " for validation_file in self.prepared_data[\"validation\"])\n", "\n", " # `pyannote.audio.core.task.Task` base class provides a `LightningModule.training_step` and \n", " # `LightningModule.validation_step` methods that rely on self.specifications to guess which \n", @@ -323,14 +351,16 @@ "\n", " # pyannote.audio.tasks.segmentation.mixin also provides a convenient mixin\n", " # for \"segmentation\" tasks (ie. with Resolution.FRAME) that already defines\n", - " # a bunch of useful methods. \n" + " # a bunch of useful methods. You can use it by inheriting your task from the \n", + " # pyannote.audio.tasks.segmentation.mixinSegmentationTask\n" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.5 64-bit ('pyannote-audio-v2': conda)", - "name": "python385jvsc74a57bd0af55542e943232842f746a64555e4e006c72c98a3a863e85e6cbaf12772fa219" + "display_name": "Python 3", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -342,7 +372,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.10.13" } }, "nbformat": 4, From b41b176e3ff28e4c9daeaf7de6e4f80133e44dc9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Mon, 15 Jan 2024 13:11:21 +0100 Subject: [PATCH 40/57] fix: fix support for non-ASCII characters MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes #1608 #1612 Co-authored-by: Hervé BREDIN --- pyannote/audio/core/task.py | 12 ++++++------ pyannote/audio/tasks/segmentation/mixins.py | 5 ++--- .../audio/tasks/segmentation/multilabel.py | 10 +++++----- tests/data/database.yml | 1 + tests/data/debug.train.lst | 2 +- tests/data/debug.train.rttm | 18 +++++++++--------- .../data/tr\303\26100.wav" | Bin 7 files changed, 24 insertions(+), 24 deletions(-) rename tests/data/trn00.wav => "tests/data/tr\303\26100.wav" (100%) diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index 5c0b16f29..a0686fc88 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -215,11 +215,11 @@ class Task(pl.LightningDataModule): pyannote.database protocol cache : str, optional As (meta-)data preparation might take a very long time for large datasets, - it can be cached to disk for later (and faster!) re-use. + it can be cached to disk for later (and faster!) re-use. When `cache` does not exist, `Task.prepare_data()` generates training and validation metadata from `protocol` and save them to disk. When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data - are loaded from disk. Defaults to a temporary path. + are loaded from disk. Defaults to a temporary path. duration : float, optional Chunks duration in seconds. Defaults to two seconds (2.). min_duration : float, optional @@ -567,7 +567,7 @@ def prepare_data(self): # keep track of protocol name prepared_data["protocol"] = self.protocol.name - prepared_data["audio-path"] = np.array(audios, dtype=np.string_) + prepared_data["audio-path"] = np.array(audios, dtype=np.str_) audios.clear() prepared_data["audio-metadata"] = np.array(metadata, dtype=metadata_dtype) @@ -576,7 +576,7 @@ def prepare_data(self): prepared_data["audio-info"] = np.array(audio_infos, dtype=info_dtype) audio_infos.clear() - prepared_data["audio-encoding"] = np.array(audio_encodings, dtype=np.string_) + prepared_data["audio-encoding"] = np.array(audio_encodings, dtype=np.str_) audio_encodings.clear() prepared_data["audio-annotated"] = np.array(annotated_duration) @@ -596,11 +596,11 @@ def prepare_data(self): for database, labels in database_unique_labels.items(): prepared_data[f"metadata-{database}-labels"] = np.array( - labels, dtype=np.string_ + labels, dtype=np.str_ ) database_unique_labels.clear() - prepared_data["metadata-labels"] = np.array(unique_labels, dtype=np.string_) + prepared_data["metadata-labels"] = np.array(unique_labels, dtype=np.str_) unique_labels.clear() self.prepare_validation(prepared_data) diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 1af863d89..4e97c6e9f 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -48,16 +48,15 @@ class SegmentationTask(Task): def get_file(self, file_id): file = dict() - file["audio"] = str(self.prepared_data["audio-path"][file_id], encoding="utf-8") + file["audio"] = self.prepared_data["audio-path"][file_id] _audio_info = self.prepared_data["audio-info"][file_id] - _encoding = self.prepared_data["audio-encoding"][file_id] + encoding = self.prepared_data["audio-encoding"][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, diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index c641b5c3e..66a28e7ba 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -49,13 +49,13 @@ class MultiLabelSegmentation(SegmentationTask): Parameters ---------- protocol : Protocol - cache : str, optional + cache : str, optional As (meta-)data preparation might take a very long time for large datasets, - it can be cached to disk for later (and faster!) re-use. + it can be cached to disk for later (and faster!) re-use. When `cache` does not exist, `Task.prepare_data()` generates training and validation metadata from `protocol` and save them to disk. When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data - are loaded from disk. Defaults to a temporary path. + are loaded from disk. Defaults to a temporary path. classes : List[str], optional List of classes. Defaults to the list of classes available in the training set. duration : float, optional @@ -179,7 +179,7 @@ def post_prepare_data(self, prepared_data: Dict): [classes.index(klass) for klass in file_classes] ) - prepared_data["classes-list"] = np.array(classes, dtype=np.string_) + prepared_data["classes-list"] = np.array(classes, dtype=np.str_) self.classes = classes else: @@ -216,7 +216,7 @@ def post_prepare_data(self, prepared_data: Dict): ] ) - prepared_data["classes-list"] = np.array(self.classes, dtype=np.string_) + prepared_data["classes-list"] = np.array(self.classes, dtype=np.str_) # 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: diff --git a/tests/data/database.yml b/tests/data/database.yml index 608bf40b4..10d3fb084 100644 --- a/tests/data/database.yml +++ b/tests/data/database.yml @@ -2,6 +2,7 @@ Protocols: Debug: SpeakerDiarization: Debug: + scope: database train: uri: debug.train.lst annotation: debug.train.rttm diff --git a/tests/data/debug.train.lst b/tests/data/debug.train.lst index 16be824f4..471bf03d4 100644 --- a/tests/data/debug.train.lst +++ b/tests/data/debug.train.lst @@ -1,4 +1,4 @@ -trn00 +trñ00 trn01 trn02 trn03 diff --git a/tests/data/debug.train.rttm b/tests/data/debug.train.rttm index 004a3f2eb..be89e2a4c 100644 --- a/tests/data/debug.train.rttm +++ b/tests/data/debug.train.rttm @@ -1,26 +1,26 @@ -SPEAKER trn00 1 3.168 0.800 MEO069 -SPEAKER trn00 1 5.463 0.640 MEO069 +SPEAKER trn00 1 3.168 0.800 MÉO069 +SPEAKER trn00 1 5.463 0.640 MÉO069 SPEAKER trn00 1 5.496 0.574 MEE068 -SPEAKER trn00 1 10.454 0.499 MEO069 +SPEAKER trn00 1 10.454 0.499 MÉO069 SPEAKER trn00 1 11.040 4.592 MEE068 -SPEAKER trn00 1 16.736 1.410 MEO069 +SPEAKER trn00 1 16.736 1.410 MÉO069 SPEAKER trn00 1 16.980 2.778 MEE067 SPEAKER trn00 1 18.883 0.490 MEE068 -SPEAKER trn00 1 18.985 1.831 MEO069 +SPEAKER trn00 1 18.985 1.831 MÉO069 SPEAKER trn00 1 20.944 0.447 MEE067 SPEAKER trn00 1 21.392 4.465 MEE068 -SPEAKER trn00 1 22.928 0.384 MEO069 -SPEAKER trn00 1 25.001 2.471 MEO069 +SPEAKER trn00 1 22.928 0.384 MÉO069 +SPEAKER trn00 1 25.001 2.471 MÉO069 SPEAKER trn00 1 28.033 1.967 MEE068 SPEAKER trn01 1 2.977 0.391 FEO066 SPEAKER trn01 1 18.705 0.964 MEE068 SPEAKER trn01 1 22.269 0.457 FEO065 -SPEAKER trn01 1 28.474 1.526 MEO069 +SPEAKER trn01 1 28.474 1.526 MÉO069 SPEAKER trn01 1 28.593 1.407 FEO066 SPEAKER trn01 1 28.993 1.007 FEO065 SPEAKER trn02 1 20.704 0.688 FEO066 SPEAKER trn03 1 0.000 1.184 MEE067 -SPEAKER trn03 1 1.104 28.896 MEO069 +SPEAKER trn03 1 1.104 28.896 MÉO069 SPEAKER trn04 1 14.032 1.744 MEE076 SPEAKER trn04 1 14.345 2.471 MEO074 SPEAKER trn04 1 16.736 7.216 MEE075 diff --git a/tests/data/trn00.wav "b/tests/data/tr\303\26100.wav" similarity index 100% rename from tests/data/trn00.wav rename to "tests/data/tr\303\26100.wav" From c921f441f6f091d9822ddc03ba982c9ac4c10104 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Mon, 15 Jan 2024 16:33:27 +0100 Subject: [PATCH 41/57] fix: remove use of unsigned type (#1616) --- pyannote/audio/core/task.py | 26 +++++++-------------- pyannote/audio/tasks/segmentation/mixins.py | 2 +- 2 files changed, 9 insertions(+), 19 deletions(-) diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index a0686fc88..82e8939fe 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -160,7 +160,7 @@ def __len__(self): return self.task.val__len__() -def get_dtype(value: int, unsigned: Optional[bool] = False) -> str: +def get_dtype(value: int) -> str: """Return the most suitable type for storing the value passed in parameter in memory. @@ -168,8 +168,6 @@ def get_dtype(value: int, unsigned: Optional[bool] = False) -> str: ---------- value: int value whose type is best suited to storage in memory - unsigned: bool, optional - positive integer mode only. Default to False Returns ------- @@ -177,21 +175,13 @@ def get_dtype(value: int, unsigned: Optional[bool] = False) -> str: numpy formatted type (see https://numpy.org/doc/stable/reference/arrays.dtypes.html) """ - if unsigned: - if value < 0: - raise ValueError( - f"negative value ({value}) is incompatible with unsigned types" - ) - # unsigned byte (8 bits), unsigned short (16 bits), unsigned int (32 bits) - types_list = [(255, "B"), (65_535, "u2"), (4_294_967_296, "u4")] - else: - # signe byte (8 bits), signed short (16 bits), signed int (32 bits): - types_list = [(127, "b"), (32_768, "i2"), (2_147_483_648, "i")] + # signe byte (8 bits), signed short (16 bits), signed int (32 bits): + types_list = [(127, "b"), (32_768, "i2"), (2_147_483_648, "i")] filtered_list = [ (max_val, type) for max_val, type in types_list if max_val > abs(value) ] if not filtered_list: - return "u8" if unsigned else "i8" # unsigned or signed long (64 bits) + return "i8" # signed long (64 bits) return filtered_list[0][1] @@ -528,11 +518,11 @@ def prepare_data(self): info_dtype = [ ( "sample_rate", - get_dtype(max(ai[0] for ai in audio_infos), unsigned=True), + get_dtype(max(ai[0] for ai in audio_infos)), ), ( "num_frames", - get_dtype(max(ai[1] for ai in audio_infos), unsigned=True), + get_dtype(max(ai[1] for ai in audio_infos)), ), ("num_channels", "B"), ("bits_per_sample", "B"), @@ -542,7 +532,7 @@ def prepare_data(self): region_dtype = [ ( "file_id", - get_dtype(max(ar[0] for ar in annotated_regions), unsigned=True), + get_dtype(max(ar[0] for ar in annotated_regions)), ), ("duration", "f"), ("start", "f"), @@ -552,7 +542,7 @@ def prepare_data(self): segment_dtype = [ ( "file_id", - get_dtype(max(a[0] for a in annotations), unsigned=True), + get_dtype(max(a[0] for a in annotations)), ), ("start", "f"), ("end", "f"), diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 4e97c6e9f..9c5bcd792 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -287,7 +287,7 @@ def prepare_validation(self, prepared_data: Dict): dtype = [ ( "file_id", - get_dtype(max(v[0] for v in validation_chunks), unsigned=True), + get_dtype(max(v[0] for v in validation_chunks)), ), ("start", "f"), ("duration", "f"), From 293d8fc33eeb0887c001e1e61c2b60be0570f842 Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Wed, 24 Jan 2024 11:26:28 +0100 Subject: [PATCH 42/57] improve: add missing Optional typing --- pyannote/audio/augmentation/mix.py | 10 +++---- pyannote/audio/cli/evaluate.py | 2 +- .../CosineAnnealingWarmRestarts.py | 3 +- pyannote/audio/cli/lr_schedulers/CyclicLR.py | 3 +- pyannote/audio/core/callback.py | 4 +-- pyannote/audio/core/inference.py | 10 +++---- pyannote/audio/core/io.py | 4 ++- pyannote/audio/core/model.py | 6 ++-- pyannote/audio/core/task.py | 6 ++-- .../models/embedding/wespeaker/__init__.py | 2 +- .../models/embedding/wespeaker/resnet.py | 6 ++-- pyannote/audio/models/embedding/xvector.py | 8 +++--- pyannote/audio/models/segmentation/PyanNet.py | 6 ++-- .../audio/models/segmentation/SSeRiouSS.py | 4 +-- pyannote/audio/pipelines/clustering.py | 28 +++++++++---------- pyannote/audio/pipelines/multilabel.py | 2 +- .../pipelines/overlapped_speech_detection.py | 2 +- pyannote/audio/pipelines/resegmentation.py | 4 +-- .../audio/pipelines/speaker_diarization.py | 25 +++++++++++------ .../audio/pipelines/speaker_verification.py | 24 ++++++++-------- pyannote/audio/pipelines/utils/diarization.py | 12 ++++---- pyannote/audio/pipelines/utils/getter.py | 4 +-- pyannote/audio/pipelines/utils/oracle.py | 4 +-- .../pipelines/voice_activity_detection.py | 2 +- pyannote/audio/tasks/embedding/arcface.py | 8 +++--- .../audio/tasks/segmentation/multilabel.py | 8 +++--- .../overlapped_speech_detection.py | 23 +++++++-------- .../tasks/segmentation/speaker_diarization.py | 28 ++++++++++--------- .../segmentation/voice_activity_detection.py | 14 +++++----- pyannote/audio/utils/loss.py | 16 +++++++---- pyannote/audio/utils/params.py | 4 ++- pyannote/audio/utils/preview.py | 6 ++-- tutorials/add_your_own_task.ipynb | 4 +-- 33 files changed, 159 insertions(+), 133 deletions(-) diff --git a/pyannote/audio/augmentation/mix.py b/pyannote/audio/augmentation/mix.py index a6fff49c0..c6e811280 100644 --- a/pyannote/audio/augmentation/mix.py +++ b/pyannote/audio/augmentation/mix.py @@ -60,10 +60,10 @@ def __init__( max_snr_in_db: float = 5.0, mode: str = "per_example", p: float = 0.5, - p_mode: str = None, - sample_rate: int = None, - target_rate: int = None, - max_num_speakers: int = None, + p_mode: Optional[str] = None, + sample_rate: Optional[int] = None, + target_rate: Optional[int] = None, + max_num_speakers: Optional[int] = None, output_type: str = "tensor", ): super().__init__( @@ -80,7 +80,7 @@ def __init__( def randomize_parameters( self, - samples: Tensor = None, + samples: Optional[Tensor] = None, sample_rate: Optional[int] = None, targets: Optional[Tensor] = None, target_rate: Optional[int] = None, diff --git a/pyannote/audio/cli/evaluate.py b/pyannote/audio/cli/evaluate.py index a5ab682c5..d88c88635 100644 --- a/pyannote/audio/cli/evaluate.py +++ b/pyannote/audio/cli/evaluate.py @@ -53,7 +53,7 @@ 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 = None, total: int = None): + def progress_hook(completed: Optional[int] = None, total: Optional[int] = None): progress.update(file_task, completed=completed / total) inference = Inference(model, device=device) diff --git a/pyannote/audio/cli/lr_schedulers/CosineAnnealingWarmRestarts.py b/pyannote/audio/cli/lr_schedulers/CosineAnnealingWarmRestarts.py index d8e5f4b3c..3c270eba1 100644 --- a/pyannote/audio/cli/lr_schedulers/CosineAnnealingWarmRestarts.py +++ b/pyannote/audio/cli/lr_schedulers/CosineAnnealingWarmRestarts.py @@ -20,6 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from typing import Optional from torch.optim import Optimizer from torch.optim.lr_scheduler import ( @@ -32,7 +33,7 @@ def CosineAnnealingWarmRestarts( min_lr: float = 1e-8, max_lr: float = 1e-3, patience: int = 1, - num_batches_per_epoch: int = None, + num_batches_per_epoch: Optional[int] = None, **kwargs, ): """Wrapper around CosineAnnealingWarmRestarts diff --git a/pyannote/audio/cli/lr_schedulers/CyclicLR.py b/pyannote/audio/cli/lr_schedulers/CyclicLR.py index cd7a7b730..cca4420b0 100644 --- a/pyannote/audio/cli/lr_schedulers/CyclicLR.py +++ b/pyannote/audio/cli/lr_schedulers/CyclicLR.py @@ -20,6 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from typing import Optional from torch.optim import Optimizer from torch.optim.lr_scheduler import CyclicLR as _CyclicLR @@ -31,7 +32,7 @@ def CyclicLR( max_lr: float = 1e-3, mode: str = "triangular2", patience: int = 50, - num_batches_per_epoch: int = None, + num_batches_per_epoch: Optional[int] = None, **kwargs, ): """Wrapper around CyclicLR learning rate scheduler diff --git a/pyannote/audio/core/callback.py b/pyannote/audio/core/callback.py index 5ce522d57..0cc46845b 100644 --- a/pyannote/audio/core/callback.py +++ b/pyannote/audio/core/callback.py @@ -20,7 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -from typing import List, Mapping, Text, Union +from typing import List, Mapping, Optional, Text, Union from pytorch_lightning import Callback, Trainer from pytorch_lightning.utilities.model_summary import ModelSummary @@ -67,7 +67,7 @@ class GraduallyUnfreeze(Callback): def __init__( self, schedule: Union[Mapping[Text, int], List[Union[List[Text], Text]]] = None, - epochs_per_stage: int = None, + epochs_per_stage: Optional[int] = None, ): super().__init__() diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index dcf21868d..2d6976f32 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -86,12 +86,12 @@ def __init__( self, model: Union[Model, Text, Path], window: Text = "sliding", - duration: float = None, - step: float = None, + duration: Optional[float] = None, + step: Optional[float] = None, pre_aggregation_hook: Callable[[np.ndarray], np.ndarray] = None, skip_aggregation: bool = False, skip_conversion: bool = False, - device: torch.device = None, + device: Optional[torch.device] = None, batch_size: int = 32, use_auth_token: Union[Text, None] = None, ): @@ -526,7 +526,7 @@ def __first_sample(outputs: np.ndarray, **kwargs) -> np.ndarray: @staticmethod def aggregate( scores: SlidingWindowFeature, - frames: SlidingWindow = None, + frames: Optional[SlidingWindow] = None, warm_up: Tuple[float, float] = (0.0, 0.0), epsilon: float = 1e-12, hamming: bool = False, @@ -702,7 +702,7 @@ def trim( @staticmethod def stitch( activations: SlidingWindowFeature, - frames: SlidingWindow = None, + frames: Optional[SlidingWindow] = None, lookahead: Optional[Tuple[int, int]] = None, cost_func: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] = None, match_func: Callable[[np.ndarray, np.ndarray, float], bool] = None, diff --git a/pyannote/audio/core/io.py b/pyannote/audio/core/io.py index 0a44e75ea..cbb7ee828 100644 --- a/pyannote/audio/core/io.py +++ b/pyannote/audio/core/io.py @@ -253,7 +253,9 @@ def get_duration(self, file: AudioFile) -> float: return frames / sample_rate - def get_num_samples(self, duration: float, sample_rate: int = None) -> int: + def get_num_samples( + self, duration: float, sample_rate: Optional[int] = None + ) -> int: """Deterministic number of samples from duration and sample rate""" sample_rate = sample_rate or self.sample_rate diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 098c15c02..2acc1248b 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -196,7 +196,7 @@ def example_output(self) -> Union[Output, Tuple[Output]]: def __example_output( example_output: torch.Tensor, - specifications: Specifications = None, + specifications: Optional[Specifications] = None, ) -> Output: if specifications.resolution == Resolution.FRAME: _, num_frames, dimension = example_output.shape @@ -341,7 +341,9 @@ def default_activation(self) -> Union[nn.Module, Tuple[nn.Module]]: Activation. """ - def __default_activation(specifications: Specifications = None) -> nn.Module: + def __default_activation( + specifications: Optional[Specifications] = None, + ) -> nn.Module: if specifications.problem == Problem.BINARY_CLASSIFICATION: return nn.Sigmoid() diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index 82e8939fe..afad62717 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -250,12 +250,12 @@ def __init__( protocol: Protocol, cache: Optional[Union[str, None]] = None, duration: float = 2.0, - min_duration: float = None, + min_duration: Optional[float] = None, warm_up: Union[float, Tuple[float, float]] = 0.0, batch_size: int = 32, - num_workers: int = None, + num_workers: Optional[int] = None, pin_memory: bool = False, - augmentation: BaseWaveformTransform = None, + augmentation: Optional[BaseWaveformTransform] = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): super().__init__() diff --git a/pyannote/audio/models/embedding/wespeaker/__init__.py b/pyannote/audio/models/embedding/wespeaker/__init__.py index 603a88c64..c504435c3 100644 --- a/pyannote/audio/models/embedding/wespeaker/__init__.py +++ b/pyannote/audio/models/embedding/wespeaker/__init__.py @@ -96,7 +96,7 @@ def compute_fbank(self, waveforms: torch.Tensor) -> torch.Tensor: return features - torch.mean(features, dim=1, keepdim=True) def forward( - self, waveforms: torch.Tensor, weights: torch.Tensor = None + self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: """ diff --git a/pyannote/audio/models/embedding/wespeaker/resnet.py b/pyannote/audio/models/embedding/wespeaker/resnet.py index 54f95fa8b..21fc98fc5 100644 --- a/pyannote/audio/models/embedding/wespeaker/resnet.py +++ b/pyannote/audio/models/embedding/wespeaker/resnet.py @@ -15,6 +15,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +from typing import Optional + import torch import torch.nn as nn import torch.nn.functional as F @@ -35,7 +37,7 @@ def __init__(self, in_dim=0, **kwargs): self.in_dim = in_dim self.stats_pool = StatsPool() - def forward(self, features, weights: torch.Tensor = None): + def forward(self, features, weights: Optional[torch.Tensor] = None): """ Parameters @@ -190,7 +192,7 @@ def _make_layer(self, block, planes, num_blocks, stride): self.in_planes = planes * block.expansion return nn.Sequential(*layers) - def forward(self, x: torch.Tensor, weights: torch.Tensor = None): + def forward(self, x: torch.Tensor, weights: Optional[torch.Tensor] = None): """ Parameters diff --git a/pyannote/audio/models/embedding/xvector.py b/pyannote/audio/models/embedding/xvector.py index 975f0a991..b5a5463ce 100644 --- a/pyannote/audio/models/embedding/xvector.py +++ b/pyannote/audio/models/embedding/xvector.py @@ -41,7 +41,7 @@ def __init__( self, sample_rate: int = 16000, num_channels: int = 1, - mfcc: dict = None, + mfcc: Optional[dict] = None, dimension: int = 512, task: Optional[Task] = None, ): @@ -82,7 +82,7 @@ def __init__( self.embedding = nn.Linear(in_channel * 2, self.hparams.dimension) def forward( - self, waveforms: torch.Tensor, weights: torch.Tensor = None + self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: """ @@ -109,7 +109,7 @@ def __init__( self, sample_rate: int = 16000, num_channels: int = 1, - sincnet: dict = None, + sincnet: Optional[dict] = None, dimension: int = 512, task: Optional[Task] = None, ): @@ -150,7 +150,7 @@ def __init__( self.embedding = nn.Linear(in_channel * 2, self.hparams.dimension) def forward( - self, waveforms: torch.Tensor, weights: torch.Tensor = None + self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: """ diff --git a/pyannote/audio/models/segmentation/PyanNet.py b/pyannote/audio/models/segmentation/PyanNet.py index 2c4443e06..b6cdc604b 100644 --- a/pyannote/audio/models/segmentation/PyanNet.py +++ b/pyannote/audio/models/segmentation/PyanNet.py @@ -74,9 +74,9 @@ class PyanNet(Model): def __init__( self, - sincnet: dict = None, - lstm: dict = None, - linear: dict = None, + sincnet: Optional[dict] = None, + lstm: Optional[dict] = None, + linear: Optional[dict] = None, sample_rate: int = 16000, num_channels: int = 1, task: Optional[Task] = None, diff --git a/pyannote/audio/models/segmentation/SSeRiouSS.py b/pyannote/audio/models/segmentation/SSeRiouSS.py index 9ba656182..45e9ddb7d 100644 --- a/pyannote/audio/models/segmentation/SSeRiouSS.py +++ b/pyannote/audio/models/segmentation/SSeRiouSS.py @@ -79,8 +79,8 @@ def __init__( self, wav2vec: Union[dict, str] = None, wav2vec_layer: int = -1, - lstm: dict = None, - linear: dict = None, + lstm: Optional[dict] = None, + linear: Optional[dict] = None, sample_rate: int = 16000, num_channels: int = 1, task: Optional[Task] = None, diff --git a/pyannote/audio/pipelines/clustering.py b/pyannote/audio/pipelines/clustering.py index 80098ea24..cd4b38935 100644 --- a/pyannote/audio/pipelines/clustering.py +++ b/pyannote/audio/pipelines/clustering.py @@ -25,7 +25,7 @@ import random from enum import Enum -from typing import Tuple +from typing import Optional, Tuple import numpy as np from einops import rearrange @@ -56,9 +56,9 @@ def __init__( def set_num_clusters( self, num_embeddings: int, - num_clusters: int = None, - min_clusters: int = None, - max_clusters: int = None, + num_clusters: Optional[int] = None, + min_clusters: Optional[int] = None, + max_clusters: Optional[int] = None, ): min_clusters = num_clusters or min_clusters or 1 min_clusters = max(1, min(num_embeddings, min_clusters)) @@ -79,7 +79,7 @@ def set_num_clusters( def filter_embeddings( self, embeddings: np.ndarray, - segmentations: SlidingWindowFeature = None, + segmentations: Optional[SlidingWindowFeature] = None, ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """Filter NaN embeddings and downsample embeddings @@ -205,10 +205,10 @@ def assign_embeddings( def __call__( self, embeddings: np.ndarray, - segmentations: SlidingWindowFeature = None, - num_clusters: int = None, - min_clusters: int = None, - max_clusters: int = None, + segmentations: Optional[SlidingWindowFeature] = None, + num_clusters: Optional[int] = None, + min_clusters: Optional[int] = None, + max_clusters: Optional[int] = None, **kwargs, ) -> np.ndarray: """Apply clustering @@ -323,7 +323,7 @@ def cluster( embeddings: np.ndarray, min_clusters: int, max_clusters: int, - num_clusters: int = None, + num_clusters: Optional[int] = None, ): """ @@ -476,10 +476,10 @@ class OracleClustering(BaseClustering): def __call__( self, - embeddings: np.ndarray = None, - segmentations: SlidingWindowFeature = None, - file: AudioFile = None, - frames: SlidingWindow = None, + embeddings: Optional[np.ndarray] = None, + segmentations: Optional[SlidingWindowFeature] = None, + file: Optional[AudioFile] = None, + frames: Optional[SlidingWindow] = None, **kwargs, ) -> np.ndarray: """Apply oracle clustering diff --git a/pyannote/audio/pipelines/multilabel.py b/pyannote/audio/pipelines/multilabel.py index 18693f14c..b35ebee7c 100644 --- a/pyannote/audio/pipelines/multilabel.py +++ b/pyannote/audio/pipelines/multilabel.py @@ -75,7 +75,7 @@ class MultiLabelSegmentation(Pipeline): def __init__( self, - segmentation: PipelineModel = None, + segmentation: Optional[PipelineModel] = None, fscore: bool = False, share_min_duration: bool = False, use_auth_token: Union[Text, None] = None, diff --git a/pyannote/audio/pipelines/overlapped_speech_detection.py b/pyannote/audio/pipelines/overlapped_speech_detection.py index 1c9790feb..66e61c949 100644 --- a/pyannote/audio/pipelines/overlapped_speech_detection.py +++ b/pyannote/audio/pipelines/overlapped_speech_detection.py @@ -255,7 +255,7 @@ def compute_components( _self, reference: Annotation, hypothesis: Annotation, - uem: Timeline = None, + uem: Optional[Timeline] = None, **kwargs, ) -> dict: return super().compute_components( diff --git a/pyannote/audio/pipelines/resegmentation.py b/pyannote/audio/pipelines/resegmentation.py index d01e5d65f..1eeade4b1 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -86,7 +86,7 @@ def __init__( self, segmentation: PipelineModel = "pyannote/segmentation", diarization: Text = "diarization", - der_variant: dict = None, + der_variant: Optional[dict] = None, use_auth_token: Union[Text, None] = None, ): super().__init__() @@ -137,7 +137,7 @@ def classes(self): def apply( self, file: AudioFile, - diarization: Annotation = None, + diarization: Optional[Annotation] = None, hook: Optional[Callable] = None, ) -> Annotation: """Apply speaker diarization diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 354f6be7e..46a7188d1 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -121,7 +121,7 @@ def __init__( clustering: str = "AgglomerativeClustering", embedding_batch_size: int = 1, segmentation_batch_size: int = 1, - der_variant: dict = None, + der_variant: Optional[dict] = None, use_auth_token: Union[Text, None] = None, ): super().__init__() @@ -428,9 +428,9 @@ def reconstruct( def apply( self, file: AudioFile, - num_speakers: int = None, - min_speakers: int = None, - max_speakers: int = None, + num_speakers: Optional[int] = None, + min_speakers: Optional[int] = None, + max_speakers: Optional[int] = None, return_embeddings: bool = False, hook: Optional[Callable] = None, ) -> Annotation: @@ -538,15 +538,20 @@ def apply( # detected number of speakers can still be out of bounds # (specifically, lower than `min_speakers`), since there could be too few embeddings # to make enough clusters with a given minimum cluster size. - if num_different_speakers < min_speakers or num_different_speakers > max_speakers: - warnings.warn(textwrap.dedent( - f""" + if ( + num_different_speakers < min_speakers + or num_different_speakers > max_speakers + ): + warnings.warn( + textwrap.dedent( + f""" The detected number of speakers ({num_different_speakers}) is outside the given bounds [{min_speakers}, {max_speakers}]. This can happen if the given audio file is too short to contain {min_speakers} or more speakers. Try to lower the desired minimal number of speakers. """ - )) + ) + ) # during counting, we could possibly overcount the number of instantaneous # speakers due to segmentation errors, so we cap the maximum instantaneous number @@ -618,7 +623,9 @@ def apply( # of clusters obtained from `clustering`. In this case, we append zero embeddings # for extra speakers if len(diarization.labels()) > centroids.shape[0]: - centroids = np.pad(centroids, ((0, len(diarization.labels()) - centroids.shape[0]), (0, 0))) + centroids = np.pad( + centroids, ((0, len(diarization.labels()) - centroids.shape[0]), (0, 0)) + ) # re-order centroids so that they match # the order given by diarization.labels() diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index c870ea622..fe762bd65 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -23,7 +23,7 @@ import warnings from functools import cached_property from pathlib import Path -from typing import Text, Union +from typing import Optional, Text, Union import numpy as np import torch @@ -73,7 +73,7 @@ class NeMoPretrainedSpeakerEmbedding(BaseInference): def __init__( self, embedding: Text = "nvidia/speakerverification_en_titanet_large", - device: torch.device = None, + device: Optional[torch.device] = None, ): if not NEMO_IS_AVAILABLE: raise ImportError( @@ -139,7 +139,7 @@ def min_num_samples(self) -> int: return upper def __call__( - self, waveforms: torch.Tensor, masks: torch.Tensor = None + self, waveforms: torch.Tensor, masks: Optional[torch.Tensor] = None ) -> np.ndarray: """ @@ -238,7 +238,7 @@ class SpeechBrainPretrainedSpeakerEmbedding(BaseInference): def __init__( self, embedding: Text = "speechbrain/spkrec-ecapa-voxceleb", - device: torch.device = None, + device: Optional[torch.device] = None, use_auth_token: Union[Text, None] = None, ): if not SPEECHBRAIN_IS_AVAILABLE: @@ -314,7 +314,7 @@ def min_num_samples(self) -> int: return upper def __call__( - self, waveforms: torch.Tensor, masks: torch.Tensor = None + self, waveforms: torch.Tensor, masks: Optional[torch.Tensor] = None ) -> np.ndarray: """ @@ -414,7 +414,7 @@ class ONNXWeSpeakerPretrainedSpeakerEmbedding(BaseInference): def __init__( self, embedding: Text = "hbredin/wespeaker-voxceleb-resnet34-LM", - device: torch.device = None, + device: Optional[torch.device] = None, ): if not ONNX_IS_AVAILABLE: raise ImportError( @@ -560,7 +560,7 @@ def compute_fbank( return features - torch.mean(features, dim=1, keepdim=True) def __call__( - self, waveforms: torch.Tensor, masks: torch.Tensor = None + self, waveforms: torch.Tensor, masks: Optional[torch.Tensor] = None ) -> np.ndarray: """ @@ -645,7 +645,7 @@ class PyannoteAudioPretrainedSpeakerEmbedding(BaseInference): def __init__( self, embedding: PipelineModel = "pyannote/embedding", - device: torch.device = None, + device: Optional[torch.device] = None, use_auth_token: Union[Text, None] = None, ): super().__init__() @@ -695,7 +695,7 @@ def min_num_samples(self) -> int: return upper def __call__( - self, waveforms: torch.Tensor, masks: torch.Tensor = None + self, waveforms: torch.Tensor, masks: Optional[torch.Tensor] = None ) -> np.ndarray: with torch.inference_mode(): if masks is None: @@ -711,7 +711,7 @@ def __call__( def PretrainedSpeakerEmbedding( embedding: PipelineModel, - device: torch.device = None, + device: Optional[torch.device] = None, use_auth_token: Union[Text, None] = None, ): """Pretrained speaker embedding @@ -801,7 +801,7 @@ class SpeakerEmbedding(Pipeline): def __init__( self, embedding: PipelineModel = "pyannote/embedding", - segmentation: PipelineModel = None, + segmentation: Optional[PipelineModel] = None, use_auth_token: Union[Text, None] = None, ): super().__init__() @@ -848,7 +848,7 @@ def main( protocol: str = "VoxCeleb.SpeakerVerification.VoxCeleb1", subset: str = "test", embedding: str = "pyannote/embedding", - segmentation: str = None, + segmentation: Optional[str] = None, ): import typer from pyannote.database import FileFinder, get_protocol diff --git a/pyannote/audio/pipelines/utils/diarization.py b/pyannote/audio/pipelines/utils/diarization.py index 4a35f7049..f6797194c 100644 --- a/pyannote/audio/pipelines/utils/diarization.py +++ b/pyannote/audio/pipelines/utils/diarization.py @@ -20,7 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -from typing import Dict, Mapping, Tuple, Union +from typing import Dict, Mapping, Optional, Tuple, Union import numpy as np from pyannote.core import Annotation, SlidingWindow, SlidingWindowFeature @@ -28,7 +28,7 @@ from pyannote.metrics.diarization import DiarizationErrorRate from pyannote.audio.core.inference import Inference -from pyannote.audio.utils.signal import Binarize, binarize +from pyannote.audio.utils.signal import Binarize # TODO: move to dedicated module @@ -37,9 +37,9 @@ class SpeakerDiarizationMixin: @staticmethod def set_num_speakers( - num_speakers: int = None, - min_speakers: int = None, - max_speakers: int = None, + num_speakers: Optional[int] = None, + min_speakers: Optional[int] = None, + max_speakers: Optional[int] = None, ): """Validate number of speakers @@ -122,7 +122,7 @@ def optimal_mapping( def speaker_count( binarized_segmentations: SlidingWindowFeature, warm_up: Tuple[float, float] = (0.1, 0.1), - frames: SlidingWindow = None, + frames: Optional[SlidingWindow] = None, ) -> SlidingWindowFeature: """Estimate frame-level number of instantaneous speakers diff --git a/pyannote/audio/pipelines/utils/getter.py b/pyannote/audio/pipelines/utils/getter.py index 4c589ad05..51040d1c4 100644 --- a/pyannote/audio/pipelines/utils/getter.py +++ b/pyannote/audio/pipelines/utils/getter.py @@ -21,7 +21,7 @@ # SOFTWARE. import itertools -from typing import Mapping, Text, Union +from typing import Mapping, Optional, Text, Union import torch from torch_audiomentations.core.transforms_interface import BaseWaveformTransform @@ -171,7 +171,7 @@ def get_augmentation(augmentation: PipelineAugmentation) -> BaseWaveformTransfor ) -def get_devices(needs: int = None): +def get_devices(needs: Optional[int] = None): """Get devices that can be used by the pipeline Parameters diff --git a/pyannote/audio/pipelines/utils/oracle.py b/pyannote/audio/pipelines/utils/oracle.py index 44b4ded61..3bf9ebc9f 100644 --- a/pyannote/audio/pipelines/utils/oracle.py +++ b/pyannote/audio/pipelines/utils/oracle.py @@ -20,7 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -from typing import Union +from typing import Optional, Union import numpy as np from pyannote.core import Annotation, Segment, SlidingWindow, SlidingWindowFeature @@ -32,7 +32,7 @@ def oracle_segmentation( file: AudioFile, window: SlidingWindow, frames: Union[SlidingWindow, float], - num_speakers: int = None, + num_speakers: Optional[int] = None, ) -> SlidingWindowFeature: """Oracle speaker segmentation diff --git a/pyannote/audio/pipelines/voice_activity_detection.py b/pyannote/audio/pipelines/voice_activity_detection.py index f67489b64..39e529d89 100644 --- a/pyannote/audio/pipelines/voice_activity_detection.py +++ b/pyannote/audio/pipelines/voice_activity_detection.py @@ -284,7 +284,7 @@ class AdaptiveVoiceActivityDetection(Pipeline): def __init__( self, segmentation: PipelineInference = "hbredin/VoiceActivityDetection-PyanNet-DIHARD", - augmentation: PipelineAugmentation = None, + augmentation: Optional[PipelineAugmentation] = None, fscore: bool = False, ): super().__init__() diff --git a/pyannote/audio/tasks/embedding/arcface.py b/pyannote/audio/tasks/embedding/arcface.py index bb2cb1f6c..cb6401e2b 100644 --- a/pyannote/audio/tasks/embedding/arcface.py +++ b/pyannote/audio/tasks/embedding/arcface.py @@ -23,7 +23,7 @@ from __future__ import annotations -from typing import Dict, Sequence, Union +from typing import Dict, Optional, Sequence, Union import pytorch_metric_learning.losses from pyannote.database import Protocol @@ -82,15 +82,15 @@ class SupervisedRepresentationLearningWithArcFace( def __init__( self, protocol: Protocol, - min_duration: float = None, + min_duration: Optional[float] = None, duration: float = 2.0, num_classes_per_batch: int = 32, num_chunks_per_class: int = 1, margin: float = 28.6, scale: float = 64.0, - num_workers: int = None, + num_workers: Optional[int] = None, pin_memory: bool = False, - augmentation: BaseWaveformTransform = None, + augmentation: Optional[BaseWaveformTransform] = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 66a28e7ba..0e4a4aadc 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -96,12 +96,12 @@ def __init__( classes: Optional[List[str]] = None, duration: float = 2.0, warm_up: Union[float, Tuple[float, float]] = 0.0, - balance: Sequence[Text] = None, - weight: Text = None, + balance: Optional[Sequence[Text]] = None, + weight: Optional[Text] = None, batch_size: int = 32, - num_workers: int = None, + num_workers: Optional[int] = None, pin_memory: bool = False, - augmentation: BaseWaveformTransform = None, + augmentation: Optional[BaseWaveformTransform] = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): if not isinstance(protocol, SegmentationProtocol): diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index 7249ed0f4..97db20032 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -51,13 +51,13 @@ class OverlappedSpeechDetection(SegmentationTask): ---------- protocol : Protocol pyannote.database protocol - cache : str, optional + cache : str, optional As (meta-)data preparation might take a very long time for large datasets, - it can be cached to disk for later (and faster!) re-use. + it can be cached to disk for later (and faster!) re-use. When `cache` does not exist, `Task.prepare_data()` generates training and validation metadata from `protocol` and save them to disk. When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data - are loaded from disk. Defaults to a temporary path. + are loaded from disk. Defaults to a temporary path. duration : float, optional Chunks duration. Defaults to 2s. warm_up : float or (float, float), optional @@ -73,11 +73,12 @@ class OverlappedSpeechDetection(SegmentationTask): overlap: dict, optional Controls how artificial chunks with overlapping speech are generated: - "probability" key is the probability of artificial overlapping chunks. Setting - "probability" to 0.6 means that, on average, 40% of training chunks are "real" - chunks, while 60% are artifical chunks made out of the (weighted) sum of two - chunks. Defaults to 0.5. + "probability" to 0.6 means that, on average, 40% of training chunks are "real" + chunks, while 60% are artifical chunks made out of the (weighted) sum of two + chunks. Defaults to 0.5. - "snr_min" and "snr_max" keys control the minimum and maximum signal-to-noise - ratio between summed chunks, in dB. Default to 0.0 and 10. + ratio between summed chunks, in dB. Default to 0.0 and 10. + weight: str, optional When provided, use this key to as frame-wise weight in loss function. batch_size : int, optional @@ -105,12 +106,12 @@ def __init__( duration: float = 2.0, warm_up: Union[float, Tuple[float, float]] = 0.0, overlap: dict = OVERLAP_DEFAULTS, - balance: Sequence[Text] = None, - weight: Text = None, + balance: Optional[Sequence[Text]] = None, + weight: Optional[Text] = None, batch_size: int = 32, - num_workers: int = None, + num_workers: Optional[int] = None, pin_memory: bool = False, - augmentation: BaseWaveformTransform = None, + augmentation: Optional[BaseWaveformTransform] = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, cache: Optional[Union[str, None]] = None, ): diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index 47c5adc63..fb635dc9c 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -65,13 +65,13 @@ class SpeakerDiarization(SegmentationTask): ---------- protocol : SpeakerDiarizationProtocol pyannote.database protocol - cache : str, optional + cache : str, optional As (meta-)data preparation might take a very long time for large datasets, - it can be cached to disk for later (and faster!) re-use. + it can be cached to disk for later (and faster!) re-use. When `cache` does not exist, `Task.prepare_data()` generates training and validation metadata from `protocol` and save them to disk. When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data - are loaded from disk. Defaults to a temporary path. + are loaded from disk. Defaults to a temporary path. duration : float, optional Chunks duration. Defaults to 2s. max_speakers_per_chunk : int, optional @@ -136,19 +136,21 @@ def __init__( protocol: SpeakerDiarizationProtocol, cache: Optional[Union[str, None]] = None, duration: float = 2.0, - max_speakers_per_chunk: int = None, - max_speakers_per_frame: int = None, + max_speakers_per_chunk: Optional[int] = None, + max_speakers_per_frame: Optional[int] = None, weigh_by_cardinality: bool = False, warm_up: Union[float, Tuple[float, float]] = 0.0, - balance: Sequence[Text] = None, - weight: Text = None, + balance: Optional[Sequence[Text]] = None, + weight: Optional[Text] = None, batch_size: int = 32, - num_workers: int = None, + num_workers: Optional[int] = None, pin_memory: bool = False, - augmentation: BaseWaveformTransform = None, + augmentation: Optional[BaseWaveformTransform] = None, 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`` + max_num_speakers: Optional[ + int + ] = None, # deprecated in favor of `max_speakers_per_chunk`` loss: Literal["bce", "mse"] = None, # deprecated ): super().__init__( @@ -437,7 +439,7 @@ def segmentation_loss( self, permutated_prediction: torch.Tensor, target: torch.Tensor, - weight: torch.Tensor = None, + weight: Optional[torch.Tensor] = None, ) -> torch.Tensor: """Permutation-invariant segmentation loss @@ -480,7 +482,7 @@ def voice_activity_detection_loss( self, permutated_prediction: torch.Tensor, target: torch.Tensor, - weight: torch.Tensor = None, + weight: Optional[torch.Tensor] = None, ) -> torch.Tensor: """Voice activity detection loss @@ -878,7 +880,7 @@ 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 = None, total: int = None): + def progress_hook(completed: Optional[int] = None, total: Optional[int] = None): progress.update(file_task, completed=completed / total) inference = Inference(model, device=device) diff --git a/pyannote/audio/tasks/segmentation/voice_activity_detection.py b/pyannote/audio/tasks/segmentation/voice_activity_detection.py index 183fa2ffc..6d0bdb98d 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -45,13 +45,13 @@ class VoiceActivityDetection(SegmentationTask): ---------- protocol : Protocol pyannote.database protocol - cache : str, optional + cache : str, optional As (meta-)data preparation might take a very long time for large datasets, - it can be cached to disk for later (and faster!) re-use. + it can be cached to disk for later (and faster!) re-use. When `cache` does not exist, `Task.prepare_data()` generates training and validation metadata from `protocol` and save them to disk. When `cache` exists, `Task.prepare_data()` is skipped and (meta)-data - are loaded from disk. Defaults to a temporary path. + are loaded from disk. Defaults to a temporary path. duration : float, optional Chunks duration. Defaults to 2s. warm_up : float or (float, float), optional @@ -89,12 +89,12 @@ def __init__( cache: Optional[Union[str, None]] = None, duration: float = 2.0, warm_up: Union[float, Tuple[float, float]] = 0.0, - balance: Sequence[Text] = None, - weight: Text = None, + balance: Optional[Sequence[Text]] = None, + weight: Optional[Text] = None, batch_size: int = 32, - num_workers: int = None, + num_workers: Optional[int] = None, pin_memory: bool = False, - augmentation: BaseWaveformTransform = None, + augmentation: Optional[BaseWaveformTransform] = None, metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None, ): super().__init__( diff --git a/pyannote/audio/utils/loss.py b/pyannote/audio/utils/loss.py index 2c55b26f3..55121a678 100644 --- a/pyannote/audio/utils/loss.py +++ b/pyannote/audio/utils/loss.py @@ -23,11 +23,13 @@ """Frame-weighted versions of common loss functions""" +from typing import Optional + import torch import torch.nn.functional as F -def interpolate(target: torch.Tensor, weight: torch.Tensor = None): +def interpolate(target: torch.Tensor, weight: Optional[torch.Tensor] = None): """Interpolate weight to match target frame resolution Parameters @@ -55,7 +57,9 @@ def interpolate(target: torch.Tensor, weight: torch.Tensor = None): def binary_cross_entropy( - prediction: torch.Tensor, target: torch.Tensor, weight: torch.Tensor = None + prediction: torch.Tensor, + target: torch.Tensor, + weight: Optional[torch.Tensor] = None, ) -> torch.Tensor: """Frame-weighted binary cross entropy @@ -91,7 +95,9 @@ def binary_cross_entropy( def mse_loss( - prediction: torch.Tensor, target: torch.Tensor, weight: torch.Tensor = None + prediction: torch.Tensor, + target: torch.Tensor, + weight: Optional[torch.Tensor] = None, ) -> torch.Tensor: """Frame-weighted mean-squared error loss @@ -131,8 +137,8 @@ def mse_loss( def nll_loss( prediction: torch.Tensor, target: torch.Tensor, - class_weight: torch.Tensor = None, - weight: torch.Tensor = None, + class_weight: Optional[torch.Tensor] = None, + weight: Optional[torch.Tensor] = None, ) -> torch.Tensor: """Frame-weighted negative log-likelihood loss diff --git a/pyannote/audio/utils/params.py b/pyannote/audio/utils/params.py index 685e01653..f4ed42bcc 100644 --- a/pyannote/audio/utils/params.py +++ b/pyannote/audio/utils/params.py @@ -1,8 +1,10 @@ # TODO - make it depth-recursive # TODO - switch to Omegaconf maybe? +from typing import Optional -def merge_dict(defaults: dict, custom: dict = None): + +def merge_dict(defaults: dict, custom: Optional[dict] = None): params = dict(defaults) if custom is not None: params.update(custom) diff --git a/pyannote/audio/utils/preview.py b/pyannote/audio/utils/preview.py index fcdf4d124..1a5ace08c 100644 --- a/pyannote/audio/utils/preview.py +++ b/pyannote/audio/utils/preview.py @@ -47,7 +47,7 @@ MOVIEPY_INSTALLED = False -from typing import Mapping +from typing import Mapping, Optional import torch from pyannote.core import ( @@ -64,7 +64,7 @@ from pyannote.audio.utils.signal import Binarize -def listen(audio_file: AudioFile, segment: Segment = None) -> None: +def listen(audio_file: AudioFile, segment: Optional[Segment] = None) -> None: """listen to audio Allows playing of audio files. It will play the whole thing unless @@ -91,7 +91,7 @@ def listen(audio_file: AudioFile, segment: Segment = None) -> None: def preview( audio_file: AudioFile, - segment: Segment = None, + segment: Optional[Segment] = None, zoom: float = 10.0, video_fps: int = 5, video_ext: str = "webm", diff --git a/tutorials/add_your_own_task.ipynb b/tutorials/add_your_own_task.ipynb index 38daa73fb..7fe7858cb 100644 --- a/tutorials/add_your_own_task.ipynb +++ b/tutorials/add_your_own_task.ipynb @@ -148,7 +148,7 @@ "outputs": [], "source": [ "from math import ceil\n", - "from typing import Dict, Optional,Tuple, Union\n", + "from typing import Dict, Optional, Tuple, Union\n", "import numpy as np\n", "from pyannote.core import Segment, SlidingWindow\n", "from pyannote.audio.utils.random import create_rng_for_worker\n", @@ -167,7 +167,7 @@ " min_duration: float = 5.0,\n", " warm_up: Union[float, Tuple[float, float]] = 0.0,\n", " batch_size: int = 32,\n", - " num_workers: int = None,\n", + " num_workers: Optional[int] = None,\n", " pin_memory: bool = False,\n", " augmentation = None,\n", " cache: Optional[Union[str, None]] = None,\n", From c0b9e79aa8063c7ddc78e7213799d0aeae9d3d10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 24 Jan 2024 21:47:01 +0100 Subject: [PATCH 43/57] BREAKING(model): get rid of `Model.example_output` in favor of `num_frames`, `receptive_field`, and `dimension` properties (#1617) --- CHANGELOG.md | 3 +- pyannote/audio/core/inference.py | 169 ++---------------- pyannote/audio/core/model.py | 39 ---- pyannote/audio/models/blocks/sincnet.py | 4 + pyannote/audio/models/embedding/debug.py | 6 +- .../models/embedding/wespeaker/__init__.py | 5 + pyannote/audio/models/embedding/xvector.py | 12 +- pyannote/audio/models/segmentation/PyanNet.py | 27 +-- .../audio/models/segmentation/SSeRiouSS.py | 25 +-- pyannote/audio/models/segmentation/debug.py | 20 ++- .../pipelines/overlapped_speech_detection.py | 2 +- pyannote/audio/pipelines/resegmentation.py | 5 +- .../audio/pipelines/speaker_diarization.py | 7 +- .../audio/pipelines/speaker_verification.py | 2 +- pyannote/audio/pipelines/utils/diarization.py | 8 +- pyannote/audio/pipelines/utils/oracle.py | 2 +- .../audio/tasks/segmentation/multilabel.py | 21 ++- .../overlapped_speech_detection.py | 21 ++- .../tasks/segmentation/speaker_diarization.py | 23 ++- .../segmentation/voice_activity_detection.py | 21 ++- pyannote/audio/utils/frame.py | 4 +- 21 files changed, 156 insertions(+), 270 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1cff92eb4..29e5dc311 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,7 +6,7 @@ - feat(task): add option to cache task training metadata to speed up training - feat(pipeline): add `Waveform` and `SampleRate` preprocessors -- feat(model): add `num_frames` and `receptive_field` to segmentation models +- feat(model): add `num_frames`, `receptive_field`, and `dimension` properties to segmentation models ### Fixes @@ -14,6 +14,7 @@ ## Breaking changes +- BREAKING(model): get rid of `Model.example_output` in favor of `num_frames`, `receptive_field`, and `dimension` properties - BREAKING(task): custom tasks need to be updated (see "Add your own task" tutorial) ## Version 3.1.1 (2023-12-01) diff --git a/pyannote/audio/core/inference.py b/pyannote/audio/core/inference.py index 2d6976f32..0c3e9b212 100644 --- a/pyannote/audio/core/inference.py +++ b/pyannote/audio/core/inference.py @@ -20,7 +20,6 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -import math import warnings from pathlib import Path from typing import Callable, List, Optional, Text, Tuple, Union @@ -37,7 +36,6 @@ 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 from pyannote.audio.utils.reproducibility import fix_reproducibility @@ -263,16 +261,14 @@ def slide( _, num_samples = waveform.shape def __frames( - example_output, specifications: Optional[Specifications] = None + receptive_field, specifications: Optional[Specifications] = None ) -> SlidingWindow: if specifications.resolution == Resolution.CHUNK: return SlidingWindow(start=0.0, duration=self.duration, step=self.step) - return example_output.frames + return receptive_field frames: Union[SlidingWindow, Tuple[SlidingWindow]] = map_with_specifications( - self.model.specifications, - __frames, - self.model.example_output, + self.model.specifications, __frames, self.model.receptive_field ) # prepare complete chunks @@ -373,7 +369,7 @@ def __aggregate( outputs, SlidingWindow(start=0.0, duration=self.duration, step=self.step), ), - frames=frames, + frames, warm_up=self.warm_up, hamming=True, missing=0.0, @@ -526,7 +522,7 @@ def __first_sample(outputs: np.ndarray, **kwargs) -> np.ndarray: @staticmethod def aggregate( scores: SlidingWindowFeature, - frames: Optional[SlidingWindow] = None, + frames: SlidingWindow, warm_up: Tuple[float, float] = (0.0, 0.0), epsilon: float = 1e-12, hamming: bool = False, @@ -539,10 +535,8 @@ def aggregate( ---------- scores : SlidingWindowFeature Raw (unaggregated) scores. Shape is (num_chunks, num_frames_per_chunk, num_classes). - frames : SlidingWindow, optional - Frames resolution. Defaults to estimate it automatically based on `scores` shape - and chunk size. Providing the exact frame resolution (when known) leads to better - temporal precision. + frames : SlidingWindow + Frames resolution. warm_up : (float, float) tuple, optional Left/right warm up duration (in seconds). missing : float, optional @@ -559,15 +553,11 @@ def aggregate( num_chunks, num_frames_per_chunk, num_classes = scores.data.shape chunks = scores.sliding_window - if frames is None: - duration = step = chunks.duration / num_frames_per_chunk - frames = SlidingWindow(start=chunks.start, duration=duration, step=step) - else: - frames = SlidingWindow( - start=chunks.start, - duration=frames.duration, - step=frames.step, - ) + frames = SlidingWindow( + start=chunks.start, + duration=frames.duration, + step=frames.step, + ) masks = 1 - np.isnan(scores) scores.data = np.nan_to_num(scores.data, copy=True, nan=0.0) @@ -602,6 +592,7 @@ def aggregate( scores.sliding_window.start + scores.sliding_window.duration + (num_chunks - 1) * scores.sliding_window.step + + 0.5 * frames.duration ) + 1 ) @@ -627,7 +618,8 @@ def aggregate( # score ~ (num_frames_per_chunk, num_classes)-shaped np.ndarray # mask ~ (num_frames_per_chunk, num_classes)-shaped np.ndarray - start_frame = frames.closest_frame(chunk.start) + start_frame = frames.closest_frame(chunk.start + 0.5 * frames.duration) + aggregated_output[start_frame : start_frame + num_frames_per_chunk] += ( score * mask * hamming_window * warm_up_window ) @@ -698,134 +690,3 @@ def trim( ) return SlidingWindowFeature(new_data, new_chunks) - - @staticmethod - def stitch( - activations: SlidingWindowFeature, - frames: Optional[SlidingWindow] = None, - lookahead: Optional[Tuple[int, int]] = None, - cost_func: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] = None, - match_func: Callable[[np.ndarray, np.ndarray, float], bool] = None, - ) -> SlidingWindowFeature: - """ - - Parameters - ---------- - activations : SlidingWindowFeature - (num_chunks, num_frames, num_classes)-shaped scores. - frames : SlidingWindow, optional - Frames resolution. Defaults to estimate it automatically based on `activations` - shape and chunk size. Providing the exact frame resolution (when known) leads to better - temporal precision. - lookahead : (int, int) tuple - Number of past and future adjacent chunks to use for stitching. - Defaults to (k, k) with k = chunk_duration / chunk_step - 1 - cost_func : callable - Cost function used to find the optimal mapping between two chunks. - Expects two (num_frames, num_classes) torch.tensor as input - and returns cost as a (num_classes, ) torch.tensor - Defaults to mean absolute error (utils.permutations.mae_cost_func) - match_func : callable - Function used to decide whether two speakers mapped by the optimal - mapping actually are a match. - Expects two (num_frames, ) np.ndarray and the cost (from cost_func) - and returns a boolean. Defaults to always returning True. - """ - - num_chunks, num_frames, num_classes = activations.data.shape - - chunks: SlidingWindow = activations.sliding_window - - if frames is None: - duration = step = chunks.duration / num_frames - frames = SlidingWindow(start=chunks.start, duration=duration, step=step) - else: - frames = SlidingWindow( - start=chunks.start, - duration=frames.duration, - step=frames.step, - ) - - max_lookahead = math.floor(chunks.duration / chunks.step - 1) - if lookahead is None: - lookahead = 2 * (max_lookahead,) - - assert all(L <= max_lookahead for L in lookahead) - - if cost_func is None: - cost_func = mae_cost_func - - if match_func is None: - - def always_match(this: np.ndarray, that: np.ndarray, cost: float): - return True - - match_func = always_match - - stitches = [] - for C, (chunk, activation) in enumerate(activations): - local_stitch = np.NAN * np.zeros( - (sum(lookahead) + 1, num_frames, num_classes) - ) - - 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) - - if shift < 0: - shift = -shift - this_activations = activation[shift:] - that_activations = activations[c, : num_frames - shift] - else: - this_activations = activation[: num_frames - shift] - that_activations = activations[c, shift:] - - # find the optimal one-to-one mapping - _, (permutation,), (cost,) = permutate( - this_activations[np.newaxis], - that_activations, - cost_func=cost_func, - return_cost=True, - ) - - for this, that in enumerate(permutation): - # only stitch under certain condiditions - matching = (c == C) or ( - match_func( - this_activations[:, this], - that_activations[:, that], - cost[this, that], - ) - ) - - if matching: - local_stitch[c - C + lookahead[0], :, this] = activations[ - c, :, that - ] - - # TODO: do not lookahead further once a mismatch is found - - stitched_chunks = SlidingWindow( - start=chunk.start - lookahead[0] * chunks.step, - duration=chunks.duration, - step=chunks.step, - ) - - local_stitch = Inference.aggregate( - SlidingWindowFeature(local_stitch, stitched_chunks), - frames=frames, - hamming=True, - ) - - stitches.append(local_stitch.data) - - stitches = np.stack(stitches) - stitched_chunks = SlidingWindow( - start=chunks.start - lookahead[0] * chunks.step, - duration=chunks.duration + sum(lookahead) * chunks.step, - step=chunks.step, - ) - - return SlidingWindowFeature(stitches, stitched_chunks) diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 2acc1248b..27f34e7f8 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -25,7 +25,6 @@ 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 @@ -46,7 +45,6 @@ from pyannote.audio.core.io import Audio from pyannote.audio.core.task import ( Problem, - Resolution, Specifications, Task, UnknownSpecificationsError, @@ -112,10 +110,6 @@ def task(self) -> Task: 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): @@ -187,36 +181,6 @@ def __example_input_array(self, duration: Optional[float] = None) -> torch.Tenso def example_input_array(self) -> torch.Tensor: return self.__example_input_array() - @cached_property - def example_output(self) -> Union[Output, Tuple[Output]]: - """Example output""" - example_input_array = self.__example_input_array() - with torch.inference_mode(): - example_output = self(example_input_array) - - def __example_output( - example_output: torch.Tensor, - specifications: Optional[Specifications] = None, - ) -> Output: - 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( - num_frames=num_frames, - dimension=dimension, - frames=frames, - ) - - return map_with_specifications( - self.specifications, __example_output, example_output - ) - def prepare_data(self): self.task.prepare_data() @@ -270,9 +234,6 @@ 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/models/blocks/sincnet.py b/pyannote/audio/models/blocks/sincnet.py index 33e312ba5..a7657c2e9 100644 --- a/pyannote/audio/models/blocks/sincnet.py +++ b/pyannote/audio/models/blocks/sincnet.py @@ -24,6 +24,8 @@ # Hervé Bredin - http://herve.niderb.fr +from functools import cached_property, lru_cache + import torch import torch.nn as nn import torch.nn.functional as F @@ -74,6 +76,7 @@ def __init__(self, sample_rate: int = 16000, stride: int = 1): self.pool1d.append(nn.MaxPool1d(3, stride=3, padding=0, dilation=1)) self.norm1d.append(nn.InstanceNorm1d(60, affine=True)) + @lru_cache def num_frames(self, num_samples: int) -> int: """Compute number of output frames for a given number of input samples @@ -132,6 +135,7 @@ def receptive_field_size(self, num_frames: int = 1) -> int: return receptive_field_size + @cached_property def receptive_field(self) -> SlidingWindow: """Compute receptive field diff --git a/pyannote/audio/models/embedding/debug.py b/pyannote/audio/models/embedding/debug.py index 11b3def30..775b6550f 100644 --- a/pyannote/audio/models/embedding/debug.py +++ b/pyannote/audio/models/embedding/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( @@ -58,6 +57,11 @@ def __init__( bidirectional=True, ) + @property + def dimension(self) -> int: + """Dimension of output""" + return 64 + def forward(self, waveforms: torch.Tensor) -> torch.Tensor: """ diff --git a/pyannote/audio/models/embedding/wespeaker/__init__.py b/pyannote/audio/models/embedding/wespeaker/__init__.py index c504435c3..8f1e62105 100644 --- a/pyannote/audio/models/embedding/wespeaker/__init__.py +++ b/pyannote/audio/models/embedding/wespeaker/__init__.py @@ -95,6 +95,11 @@ def compute_fbank(self, waveforms: torch.Tensor) -> torch.Tensor: return features - torch.mean(features, dim=1, keepdim=True) + @property + def dimension(self) -> int: + """Dimension of output""" + return self.resnet.embed_dim + def forward( self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/pyannote/audio/models/embedding/xvector.py b/pyannote/audio/models/embedding/xvector.py index b5a5463ce..85610509d 100644 --- a/pyannote/audio/models/embedding/xvector.py +++ b/pyannote/audio/models/embedding/xvector.py @@ -34,7 +34,6 @@ class XVectorMFCC(Model): - MFCC_DEFAULTS = {"n_mfcc": 40, "dct_type": 2, "norm": "ortho", "log_mels": False} def __init__( @@ -81,6 +80,11 @@ def __init__( self.embedding = nn.Linear(in_channel * 2, self.hparams.dimension) + @property + def dimension(self) -> int: + """Dimension of output""" + return self.hparams.dimension + def forward( self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -102,7 +106,6 @@ def forward( class XVectorSincNet(Model): - SINCNET_DEFAULTS = {"stride": 10} def __init__( @@ -149,6 +152,11 @@ def __init__( self.embedding = nn.Linear(in_channel * 2, self.hparams.dimension) + @property + def dimension(self) -> int: + """Dimension of output""" + return self.hparams.dimension + def forward( self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/pyannote/audio/models/segmentation/PyanNet.py b/pyannote/audio/models/segmentation/PyanNet.py index b6cdc604b..9d397abcb 100644 --- a/pyannote/audio/models/segmentation/PyanNet.py +++ b/pyannote/audio/models/segmentation/PyanNet.py @@ -20,7 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. - +from functools import cached_property, lru_cache from typing import Optional import torch @@ -139,6 +139,17 @@ def __init__( ] ) + @property + def dimension(self) -> int: + """Dimension of output""" + if isinstance(self.specifications, tuple): + raise ValueError("PyanNet does not support multi-tasking.") + + if self.specifications.powerset: + return self.specifications.num_powerset_classes + else: + return len(self.specifications.classes) + def build(self): if self.hparams.linear["num_layers"] > 0: in_features = self.hparams.linear["hidden_size"] @@ -147,17 +158,10 @@ 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: - out_features = len(self.specifications.classes) - - self.classifier = nn.Linear(in_features, out_features) + self.classifier = nn.Linear(in_features, self.dimension) self.activation = self.default_activation() + @lru_cache def num_frames(self, num_samples: int) -> int: """Compute number of output frames for a given number of input samples @@ -174,6 +178,7 @@ def num_frames(self, num_samples: int) -> int: return self.sincnet.num_frames(num_samples) + @cached_property def receptive_field(self) -> SlidingWindow: """Compute receptive field @@ -186,7 +191,7 @@ def receptive_field(self) -> SlidingWindow: https://distill.pub/2019/computing-receptive-fields/ """ - return self.sincnet.receptive_field() + return self.sincnet.receptive_field def forward(self, waveforms: torch.Tensor) -> torch.Tensor: """Pass forward diff --git a/pyannote/audio/models/segmentation/SSeRiouSS.py b/pyannote/audio/models/segmentation/SSeRiouSS.py index 45e9ddb7d..514ad00de 100644 --- a/pyannote/audio/models/segmentation/SSeRiouSS.py +++ b/pyannote/audio/models/segmentation/SSeRiouSS.py @@ -20,7 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. - +from functools import cached_property, lru_cache from typing import Optional, Union import torch @@ -174,6 +174,17 @@ def __init__( ] ) + @property + def dimension(self) -> int: + """Dimension of output""" + if isinstance(self.specifications, tuple): + raise ValueError("SSeRiouSS does not support multi-tasking.") + + if self.specifications.powerset: + return self.specifications.num_powerset_classes + else: + return len(self.specifications.classes) + def build(self): if self.hparams.linear["num_layers"] > 0: in_features = self.hparams.linear["hidden_size"] @@ -182,17 +193,10 @@ def build(self): 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.classifier = nn.Linear(in_features, self.dimension) self.activation = self.default_activation() + @lru_cache def num_frames(self, num_samples: int) -> int: """Compute number of output frames for a given number of input samples @@ -245,6 +249,7 @@ def receptive_field_size(self, num_frames: int = 1) -> int: return receptive_field_size + @cached_property def receptive_field(self) -> SlidingWindow: """Compute receptive field diff --git a/pyannote/audio/models/segmentation/debug.py b/pyannote/audio/models/segmentation/debug.py index a230bf768..d41dba51a 100644 --- a/pyannote/audio/models/segmentation/debug.py +++ b/pyannote/audio/models/segmentation/debug.py @@ -21,6 +21,7 @@ # SOFTWARE. +from functools import cached_property, lru_cache from typing import Optional import torch @@ -58,6 +59,7 @@ def __init__( bidirectional=True, ) + @lru_cache def num_frames(self, num_samples: int) -> int: """Compute number of output frames for a given number of input samples @@ -80,7 +82,7 @@ def num_frames(self, num_samples: int) -> int: hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft center = self.mfcc.MelSpectrogram.spectrogram.center - return ( + return int( 1 + num_samples // hop_length if center else 1 + (num_samples - n_fft) // hop_length @@ -109,6 +111,7 @@ def receptive_field_size(self, num_frames: int = 1) -> int: else: return (num_frames - 1) * hop_length + n_fft + @cached_property def receptive_field(self) -> SlidingWindow: """Compute receptive field @@ -134,18 +137,21 @@ def receptive_field(self) -> SlidingWindow: return SlidingWindow(start=0.0, duration=duration, step=step) - def build(self): - # define task-dependent layers - + @property + def dimension(self) -> int: + """Dimension of output""" if isinstance(self.specifications, tuple): raise ValueError("SimpleSegmentationModel does not support multi-tasking.") if self.specifications.powerset: - out_features = self.specifications.num_powerset_classes + return self.specifications.num_powerset_classes else: - out_features = len(self.specifications.classes) + return len(self.specifications.classes) + + def build(self): + # define task-dependent layers - self.classifier = nn.Linear(32 * 2, out_features) + self.classifier = nn.Linear(32 * 2, self.dimension) 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 66e61c949..1429e4299 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.example_output.dimension > 1: + if model.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 1eeade4b1..85492f774 100644 --- a/pyannote/audio/pipelines/resegmentation.py +++ b/pyannote/audio/pipelines/resegmentation.py @@ -96,7 +96,6 @@ def __init__( model: Model = get_model(segmentation, use_auth_token=use_auth_token) self._segmentation = Inference(model) - self._frames = self._segmentation.model.example_output.frames self._audio = model.audio @@ -193,8 +192,8 @@ def apply( # estimate frame-level number of instantaneous speakers count = self.speaker_count( binarized_segmentations, + self._segmentation.model.receptive_field, warm_up=(self.warm_up, self.warm_up), - frames=self._frames, ) hook("speaker_counting", count) @@ -205,7 +204,7 @@ def apply( support=Segment( 0.0, self._audio.get_duration(file) + self._segmentation.step ), - resolution=self._frames, + resolution=self._segmentation.model.receptive_field, ) hook("@resegmentation/original", diarization) diff --git a/pyannote/audio/pipelines/speaker_diarization.py b/pyannote/audio/pipelines/speaker_diarization.py index 46a7188d1..737cd1cb2 100644 --- a/pyannote/audio/pipelines/speaker_diarization.py +++ b/pyannote/audio/pipelines/speaker_diarization.py @@ -32,7 +32,7 @@ import numpy as np import torch from einops import rearrange -from pyannote.core import Annotation, SlidingWindow, SlidingWindowFeature +from pyannote.core import Annotation, SlidingWindowFeature from pyannote.metrics.diarization import GreedyDiarizationErrorRate from pyannote.pipeline.parameter import ParamDict, Uniform @@ -147,7 +147,6 @@ def __init__( skip_aggregation=True, batch_size=segmentation_batch_size, ) - self._frames: SlidingWindow = self._segmentation.model.example_output.frames if self._segmentation.model.specifications.powerset: self.segmentation = ParamDict( @@ -493,7 +492,7 @@ def apply( # estimate frame-level number of instantaneous speakers count = self.speaker_count( binarized_segmentations, - frames=self._frames, + self._segmentation.model.receptive_field, warm_up=(0.0, 0.0), ) hook("speaker_counting", count) @@ -527,7 +526,7 @@ def apply( min_clusters=min_speakers, max_clusters=max_speakers, file=file, # <== for oracle clustering - frames=self._frames, # <== for oracle clustering + frames=self._segmentation.model.receptive_field, # <== for oracle clustering ) # hard_clusters: (num_chunks, num_speakers) # centroids: (num_speakers, dimension) diff --git a/pyannote/audio/pipelines/speaker_verification.py b/pyannote/audio/pipelines/speaker_verification.py index fe762bd65..c49468a79 100644 --- a/pyannote/audio/pipelines/speaker_verification.py +++ b/pyannote/audio/pipelines/speaker_verification.py @@ -672,7 +672,7 @@ def sample_rate(self) -> int: @cached_property def dimension(self) -> int: - return self.model_.example_output.dimension + return self.model_.dimension @cached_property def metric(self) -> str: diff --git a/pyannote/audio/pipelines/utils/diarization.py b/pyannote/audio/pipelines/utils/diarization.py index f6797194c..5a0f8f675 100644 --- a/pyannote/audio/pipelines/utils/diarization.py +++ b/pyannote/audio/pipelines/utils/diarization.py @@ -121,8 +121,8 @@ def optimal_mapping( @staticmethod def speaker_count( binarized_segmentations: SlidingWindowFeature, + frames: SlidingWindow, warm_up: Tuple[float, float] = (0.1, 0.1), - frames: Optional[SlidingWindow] = None, ) -> SlidingWindowFeature: """Estimate frame-level number of instantaneous speakers @@ -133,7 +133,7 @@ def speaker_count( warm_up : (float, float) tuple, optional Left/right warm up ratio of chunk duration. Defaults to (0.1, 0.1), i.e. 10% on both sides. - frames : SlidingWindow, optional + frames : SlidingWindow Frames resolution. Defaults to estimate it automatically based on `segmentations` shape and chunk size. Providing the exact frame resolution (when known) leads to better temporal precision. @@ -147,7 +147,7 @@ def speaker_count( trimmed = Inference.trim(binarized_segmentations, warm_up=warm_up) count = Inference.aggregate( np.sum(trimmed, axis=-1, keepdims=True), - frames=frames, + frames, hamming=False, missing=0.0, skip_average=False, @@ -212,7 +212,7 @@ def to_diarization( # TODO: investigate alternative aggregation activations = Inference.aggregate( segmentations, - frames=count.sliding_window, + count.sliding_window, hamming=False, missing=0.0, skip_average=True, diff --git a/pyannote/audio/pipelines/utils/oracle.py b/pyannote/audio/pipelines/utils/oracle.py index 3bf9ebc9f..24401f752 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.example_output.frames + >>> assert frames == oracle.receptive_field >>> inference = Inference(oracle, duration=window.duration, step=window.step, skip_aggregation=True) >>> oracle_segmentation = inference(file) diff --git a/pyannote/audio/tasks/segmentation/multilabel.py b/pyannote/audio/tasks/segmentation/multilabel.py index 0e4a4aadc..9184121c4 100644 --- a/pyannote/audio/tasks/segmentation/multilabel.py +++ b/pyannote/audio/tasks/segmentation/multilabel.py @@ -292,15 +292,22 @@ 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.model.example_output.frames.step).astype(int) - end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / self.model.example_output.frames.step).astype(int) + step = self.model.receptive_field.step + half = 0.5 * self.model.receptive_field.duration + + start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - half + start_idx = np.maximum(0, np.round(start / step)).astype(int) + + end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - half + end_idx = np.round(end / step).astype(int) # frame-level targets (-1 for un-annotated classes) + num_frames = self.model.num_frames( + round(duration * self.model.hparams.sample_rate) + ) y = -np.ones( ( - self.model.example_output.num_frames, + num_frames, len(self.prepared_data["classes-list"]), ), dtype=np.int8, @@ -309,10 +316,10 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): for start, end, label in zip( start_idx, end_idx, chunk_annotations["global_label_idx"] ): - y[start:end, label] = 1 + y[start : end + 1, label] = 1 sample["y"] = SlidingWindowFeature( - y, self.model.example_output.frames, labels=self.classes + y, self.model.receptive_field, labels=self.classes ) metadata = self.prepared_data["audio-metadata"][file_id] diff --git a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py index 97db20032..89d299a8d 100644 --- a/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py +++ b/pyannote/audio/tasks/segmentation/overlapped_speech_detection.py @@ -183,19 +183,26 @@ 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.model.example_output.frames.step).astype(int) - end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / self.model.example_output.frames.step).astype(int) + step = self.model.receptive_field.step + half = 0.5 * self.model.receptive_field.duration + + start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - half + start_idx = np.maximum(0, np.round(start / step)).astype(int) + + end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - half + end_idx = np.round(end / step).astype(int) # frame-level targets - y = np.zeros((self.model.example_output.num_frames, 1), dtype=np.uint8) + num_frames = self.model.num_frames( + round(duration * self.model.hparams.sample_rate) + ) + y = np.zeros((num_frames, 1), dtype=np.uint8) for start, end in zip(start_idx, end_idx): - y[start:end, 0] += 1 + y[start : end + 1, 0] += 1 y = 1 * (y > 1) sample["y"] = SlidingWindowFeature( - y, self.model.example_output.frames, labels=["speech"] + y, self.model.receptive_field, labels=["speech"] ) metadata = self.prepared_data["audio-metadata"][file_id] diff --git a/pyannote/audio/tasks/segmentation/speaker_diarization.py b/pyannote/audio/tasks/segmentation/speaker_diarization.py index fb635dc9c..8a091b1f7 100644 --- a/pyannote/audio/tasks/segmentation/speaker_diarization.py +++ b/pyannote/audio/tasks/segmentation/speaker_diarization.py @@ -355,10 +355,14 @@ 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.model.example_output.frames.step).astype(int) - end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / self.model.example_output.frames.step).astype(int) + step = self.model.receptive_field.step + half = 0.5 * self.model.receptive_field.duration + + start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - half + start_idx = np.maximum(0, np.round(start / step)).astype(int) + + end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - half + end_idx = np.round(end / step).astype(int) # get list and number of labels for current scope labels = list(np.unique(chunk_annotations[label_scope_key])) @@ -368,7 +372,10 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): pass # initial frame-level targets - y = np.zeros((self.model.example_output.num_frames, num_labels), dtype=np.uint8) + num_frames = self.model.num_frames( + round(duration * self.model.hparams.sample_rate) + ) + y = np.zeros((num_frames, num_labels), dtype=np.uint8) # map labels to indices mapping = {label: idx for idx, label in enumerate(labels)} @@ -377,11 +384,9 @@ def prepare_chunk(self, file_id: int, start_time: float, duration: float): start_idx, end_idx, chunk_annotations[label_scope_key] ): mapped_label = mapping[label] - y[start:end, mapped_label] = 1 + y[start : end + 1, mapped_label] = 1 - sample["y"] = SlidingWindowFeature( - y, self.model.example_output.frames, labels=labels - ) + sample["y"] = SlidingWindowFeature(y, self.model.receptive_field, labels=labels) metadata = self.prepared_data["audio-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 6d0bdb98d..e52613aeb 100644 --- a/pyannote/audio/tasks/segmentation/voice_activity_detection.py +++ b/pyannote/audio/tasks/segmentation/voice_activity_detection.py @@ -164,18 +164,25 @@ 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.model.example_output.frames.step).astype(int) - end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - end_idx = np.ceil(end / self.model.example_output.frames.step).astype(int) + step = self.model.receptive_field.step + half = 0.5 * self.model.receptive_field.duration + + start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start - half + start_idx = np.maximum(0, np.round(start / step)).astype(int) + + end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start - half + end_idx = np.round(end / step).astype(int) # frame-level targets - y = np.zeros((self.model.example_output.num_frames, 1), dtype=np.uint8) + num_frames = self.model.num_frames( + round(duration * self.model.hparams.sample_rate) + ) + y = np.zeros((num_frames, 1), dtype=np.uint8) for start, end in zip(start_idx, end_idx): - y[start:end, 0] = 1 + y[start : end + 1, 0] = 1 sample["y"] = SlidingWindowFeature( - y, self.model.example_output.frames, labels=["speech"] + y, self.model.receptive_field, labels=["speech"] ) metadata = self.prepared_data["audio-metadata"][file_id] diff --git a/pyannote/audio/utils/frame.py b/pyannote/audio/utils/frame.py index e3987873d..5ff0189be 100644 --- a/pyannote/audio/utils/frame.py +++ b/pyannote/audio/utils/frame.py @@ -24,7 +24,9 @@ import math -def conv1d_num_frames(num_samples, kernel_size=5, stride=1, padding=0, dilation=1): +def conv1d_num_frames( + num_samples, kernel_size=5, stride=1, padding=0, dilation=1 +) -> int: """Compute expected number of frames after 1D convolution Parameters From e43138278a6990bd8ccc673d8a4dcd5824849d7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 25 Jan 2024 10:42:32 +0100 Subject: [PATCH 44/57] feat: add pyannote.audio.sample.SAMPLE_FILE (#1629) --- CHANGELOG.md | 1 + MANIFEST.in | 2 ++ pyannote/audio/sample/__init__.py | 56 ++++++++++++++++++++++++++++++ pyannote/audio/sample/sample.rttm | 10 ++++++ pyannote/audio/sample/sample.wav | Bin 0 -> 960104 bytes tests/test_sample.py | 28 +++++++++++++++ 6 files changed, 97 insertions(+) create mode 100644 pyannote/audio/sample/__init__.py create mode 100644 pyannote/audio/sample/sample.rttm create mode 100644 pyannote/audio/sample/sample.wav create mode 100644 tests/test_sample.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 29e5dc311..15b5b6aee 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ - feat(task): add option to cache task training metadata to speed up training - feat(pipeline): add `Waveform` and `SampleRate` preprocessors - feat(model): add `num_frames`, `receptive_field`, and `dimension` properties to segmentation models +- feat(sample): add sample file at `pyannote.audio.sample.SAMPLE_FILE` ### Fixes diff --git a/MANIFEST.in b/MANIFEST.in index 16909925f..45ad7d6af 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,4 +1,6 @@ recursive-include pyannote *.py recursive-include pyannote *.yaml +recursive-include pyannote *.wav +recursive-include pyannote *.rttm global-exclude *.pyc global-exclude __pycache__ diff --git a/pyannote/audio/sample/__init__.py b/pyannote/audio/sample/__init__.py new file mode 100644 index 000000000..85399af66 --- /dev/null +++ b/pyannote/audio/sample/__init__.py @@ -0,0 +1,56 @@ +# MIT License +# +# Copyright (c) 2024- 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 pathlib import Path + +from pyannote.core import Annotation, Segment, Timeline +from pyannote.database.util import load_rttm + +from pyannote.audio.core.io import Audio, AudioFile + + +def _sample() -> AudioFile: + sample_wav = Path(__file__).parent / "sample.wav" + uri = "sample" + + audio = Audio() + waveform, sample_rate = audio(sample_wav) + + sample_rttm = Path(__file__).parent / "sample.rttm" + + annotation: Annotation = load_rttm(sample_rttm)[uri] + duration = audio.get_duration(sample_wav) + + annotated: Timeline = Timeline([Segment(0.0, duration)], uri=uri) + + return { + "audio": sample_wav, + "uri": "sample", + "waveform": waveform, + "sample_rate": sample_rate, + "annotation": annotation, + "annotated": annotated, + } + + +SAMPLE_FILE = _sample() diff --git a/pyannote/audio/sample/sample.rttm b/pyannote/audio/sample/sample.rttm new file mode 100644 index 000000000..7c6b378fe --- /dev/null +++ b/pyannote/audio/sample/sample.rttm @@ -0,0 +1,10 @@ +SPEAKER sample 1 6.690 0.430 speaker90 +SPEAKER sample 1 7.550 0.800 speaker91 +SPEAKER sample 1 8.320 1.700 speaker90 +SPEAKER sample 1 9.920 1.110 speaker91 +SPEAKER sample 1 10.570 4.130 speaker90 +SPEAKER sample 1 14.490 3.430 speaker91 +SPEAKER sample 1 18.050 3.440 speaker90 +SPEAKER sample 1 18.150 0.440 speaker91 +SPEAKER sample 1 21.780 6.720 speaker91 +SPEAKER sample 1 27.850 2.150 speaker90 diff --git a/pyannote/audio/sample/sample.wav b/pyannote/audio/sample/sample.wav new file mode 100644 index 0000000000000000000000000000000000000000..150d49a69dc2da2310fbb526759ff26638595bdc GIT binary patch literal 960104 zcmZ79+0SKXcHj3?WN|1~ku1(bv(>bvSays!5+KDk5CjnKCCqRM#xd{;8*nk~h*svw5Cv`X3&3PV*ES{{-{?_VE`#q?7tKRqQy`N{T-}$n|K0!Mum1is^Y8!qfBbuY^KbwCzyG)Y*6V-ce|r7*{@#B-zx}=6 z`TeKnH-F_1{^8&G?Z5OFe(SgY!f*b@Z(RP?AN+$qxXk(cx_|xR`tkLn>j&5OuW!$v zFRrd|<8nQ|KYn@g^31%RzC1Pmx^sDaesll&<@K{)zCOR+yMA@OKd&2?hv#+k^4R6p z{JC-YdVc0C_pe{i-;d1C9zHJl@a56@_v7=&>(Tk?H*=0J=B!`OIh^H@`K@z!|8>rO zZ+_<;pU+kA%{gz*?;Zc}y!$eL-<%^{+co^${~nqnzd6SB^_;=+#_{F#(_^k5&3D%` z!iVRGCoZ>-<2uvj^2J>3{`{s9KRyG<~ZImaV2?mNeyXD`oR zo*mTPp8uIaUwq0o>jhSZIo1hN``#JOobUcIS|c`3S9P6i{l$ETjZeqopUig%F+bLQ zc;*Myo#nH6&)3&SkFoHnv55*6zBTW4UY>hzB51LduOFJR^Z(;BKA85p`C#_0_SInr z))OOl=8R?x!w=010?d@%;oG?K{k@q73^%`U%a3bUHu~n652U$fFLB8RUTl7E-p4by z=Bl?24=w8b^yZuc7H-d|ppO^sKd>3j_-O2w-{8pA#jrROQRZ=TX5b2qp)tXE^D!De za-7JxH)CRH=yR=b*6)k8FXoD$9-}Ve+4a%meUHu<^UITSHC8u%?_#n3l?B(cdv?+5 ztfy7{ON?)Phq*_OS((#gznq;oIA^%5=6f>`WzHtn%F z`|KbL7H$tJurL3_ZR{(OSdDGiQyhLi=X`(8_~D#UG@kQ@okx%OFe>o}mpCa)@sen~ z%vE?gYh5Ppp(Kv)TJRc2VMrrzrSb)w6cM}~U-2RgL7h>0|JwVjgD*mfS!4C}RAc8| z{%x)u`O#s+W@si*(lsCm);15ADc|5wGwR(jFKmb}(Zw4^CT6@djt#>w_3YT6*KylyQh^AfYr&LiewOvd=t{4pkDg+V+Fee&9pL!?BsM zd$==}#}3ZEJAdCjc>DIuCp>shS=YHgoM;RSFwKvPr82)cF8>wN<}8zaHSf=6Wrt_S zZqR#o(DU?se`Llg2Ff{Xy%`hUVh}!C&fDKF@?GbX2gonh%lpPhqdh%W%g&D-HaLBY zk7X!!hMY75U(3n2=h){Cu1V*y%zEtB{Hx5CLS&s-U*0eWXTT!n2EAr!E=2{L$a>HM zFRslS{B<&}?CVuFo72pfm=&i_U0%GrJh}F%1A{j%JQZ%ur7OY9!=u>bUhGOeIUWMp z|EamQT-ummCxnR+Jbq_p%-iV$`LLV@;tp=i<%z??{>@`|<|ocYJK^GTmyw5Qk+)v-oo?aF zID}6j=(8jLu-HfQZxQbu56_j^+rRm7Rh}`*f~=mO(}^1;Y zG4H`CkIo424iXi@Yc=7bj^|7%Jtr%b3 zoOi<~v}gZp`S@{G2%*&8o9oKC;Y_Zj?4BQ`e|N^g_VTTtrSqN`AHRQnbE+f?4+`OL zl`-}bQ8X9N6yf(LK6vx#8Q(K=raQ+B>6O@t2j%TlJUt>WyE5w;9Z#~1(G|ran{IWz zd*l1}uJ6ttyiSinpsVv_`K@fh4rz+@PxXhIWOc&_bF^b+m1bWyyiDBT^v$DkGd;oD z>~wo(cK2YqXXkI@TrI}VAOoxgeHt2xe?AoZJLyf=>dIRkWKGFkD- z`5tG-DY1uH7Y+C=1blwXTwY3l+?=DIA4Yp|(7>Z=Gm(Y^`03vGf)#Lyk$gIT;FSgo zVZ}ZF-kdYMeEF5jD`S0Ux$%G#;u&#a43vdq)XwEaD(%@h^0mvWGm6LN>hkKlgX?$Z zj~)Ph07v4L=8ut#Ry4qmn%!vAv-c+co}F=g=Q!sJbAEG5<&-bk6>p}6e2+7YE=EZ$ zLup>2pkT9^szcIHm}F7V?`RVhDh2TI%;C-J&kt@87az~ud0JhyYPx(RqQaPw7^^S2 z(n#107K^~G*S?wmd#Aaj@yaE)X0{L~gB433&A%`z>s50aT{=s2-JUo}Q{qh;$#*Yx zzT9zV#!Evu$0Ku&53X;`AKj0+*n<&g3Fr#1p(LJG$Hu=Wv#P)0M8xQ;;2n7w(yDgw za3f*|sCr~ZbZ7oRmwf;Ayq9I)pZPdGzt$mnVQ~G@;5#jXCH&!0bJ{GB27%A4TqHj- zSHg67M@E$)KAD%RV2-MGJh9r@Jk-y1RInI!p;5MS!&qg6?PAGH>FUK%nh3VGE^cJB z1BCDermU|Kcgn*e^xnafbtj5%+`pP%mc_+oP5*{hUr>{N<~htq+2QbN!Vl-Y56ydI z{g>xOL5kRy=l^j0-2CR7!*eG;KmpIeYW3NvlV}^Z%>(JCDq5W7U$PDzN-5l)^Z4?c zPX}`!k7e?PyxyJHM{}mMJM5WTk)=MBhs9-M=6CtR95E(; z_2MV_OE&QC@T>}{dNLwEg~M{;Q==VTI-)k+e`l^+4dR$)gjLG$Wpg^HtjL$5sqP%k zhHTe(V$MkizdRiK;{02E-pGn2If9*fKl?#Iy&189#k`sU^zrh|c^^#TG~Qlq=ABrl zx&#NRspzdDz6@1;A{tpx6sG9e5uQY{*PR(JO{K=r(TIh!Kl^?$-uqzAT)vF8j7!(4 zF|)YNAZ)@gw8hur=AGficaGNw$5ERx@YUB7pE9-MDJDvb*RJz7Zxr=BQb!ppKX>q# zPB#w9TTt`DWH-6??%0OP<8{pb@qxKG=gavYRa*adCU=ar%0mRI0*s1H>Bf46XKF2C)Xi?P}#46n>D`q)dg2y0$npUgan=zDI zbQ*oJfn#E2KES)NtKXOV%-y_Ul}4!APG?+42gFY@!87Cgx?n88Yj7{C$(NArTKE9R zEN6!E>1y0M>GvMlKQ_{VIEe?2Ji zq+1q#oec_Tu=jt7B|MYXDDI6D9z~N`RToeWcqUGu@17o%iA~jxp0<9lTJ5ae@jvCz ziw9*)9Y?)5k?`4E1+RSmODtjr%BY@r*NlD2M!X!O@;}}UUvvm1^vL|y*H?3P{he}^ zuE5g6{Yy>GOGT+%yA4ZmW zf5s$Y#bmm1b(}5;JM(M(2ANN!uz>MG|JU<>m1t^P_0Fbho2?pU&c;o5>m;eK^us9E zVzo$2H}C{5E8fnyh(SdRw!pO^)0K)T$GCdjVa#R_F03KRReZv>Sgx8xj#VQ&7EWPI z#9|8ncU^uJH?#>08h7d`^vZqgqLWb{z;9&{c(^g|$H_8>&Ygd;K=W69L;rhIwNOti z>3U-4k$Kni2Mf_1uC1rS53t&5mif!ft%2-XXWa|F^JPwr*GSK`9b?n=5`oU+ov!1( z)!;Z5F6BDEt>TauaipGLoP2-Yk9F?N+25XQ_TCY%^=fc7UVdh>!ON3_9QWAxBF?vB z`|cc#E&X9*o+=09l(@y1w!;QrSc!_KGaL2R9r0F7|LwI$`H%iE0#Q&`qYft}7LQ_N zioCcK`8dH(@v%Jb{}j)=*PmX0GL_mdu0NZ9z4?H>)J!}@ozROo=$kMsZrb)LL}bIhJ^zuk9)n_W3gneqj` zkWu7&d0v*^ey5q`zfZ@4KR;0L))B{IEVZwjC{|vWm;6`%N>);*8R6l+^$Wu>?iZ7-|R2^YXa#HS$;vw3P@`eLyhgiI2G#;z7~QC5 zd~6URpQQ)rJ=~x&P%FS1%gEd9H%L?CYCkU*<4Q*sZTy*rZLG#A4zOPsQzsX<=@cvp zfvrs8W%xAu^2ImDcy^3<3p0Ikc&R!?uStw!P_f9~_=LuVME0RO;mkE@+EAZ;;QNEY z)z9ZooxQ3X@6)%$W?MHeU;DrFg#g{(Rz+OTxOIEa8Mr0ms?}; zUrfFI%J36^>9;&S=fTwSU-c`mz_zb!&Nn>C_AHE>WD(=36RI!1Jzuu*J~3x>uw~q= zY>o5oTvN}}IZ~CBWcW#wLxgLk3)6=wgZglF2lchswDCBG=BS@xl}3jK+wrNI@5Wp= zZiW*+)Aw-%Py1q9R>v@5jR($(+F5X+BeOYv6T@{+WGr*9_Mx4vJIgOrc4zLq`4?yN zPQJt#=`|U=RR+h(MIR4`=$CFkL;ikq*o<|}PiIRFp$?Tnx9i(_zWEwcSb!Va4K7`s z;#J$K5h)M7eeqGQfO$-eW5RLW#MU|CHLVps;}+;xJi-U3th^ zsm~WjQFR^XHI_1#97|hm|AvzJV8$%2tB`2sbSK0+igtoQ_=6>yPL6`2R9Zg4;kb@% zcBPSR(=m-X^`)-WuflKfBD{Qh_~-uQwdyAQV0eFWZ08Db8su4NdUmwNYcoet(kgd7 zvvOwZA1R7fX!y)k;_b4B{47`LnX-|HqJ-Ew{=!-?<$UbG9@KL+X1ph7I?`{=*G$z_ z+o`qkx>bSoDtL8d^;&$*bClF_wzDm6yt5jJ*HtvKKzgcc!iy_l4*nKjcq+b=Npu`s z!};UBdk0p(n6W{in7e)89y*LA&1=1t|NQpxnLiwfgUf{;srK@F=lpbH>b>Ll_YbXg zy~5$`LxI%W#|-hZbKusPhzC0U{W;I`qabe|HQ3Fg(tY?)B=i!M2q&$#$cAF0wKPAy zcYWgMYTvlXA5YHJpFL)5{pI<|wcj1Y=z3dc<^_DEVui&wuRj`PbMN}XT>Zx7``7>P z`r{c3Epr`Agb02so<5q0#~+Vfe)aO_$8Mj@yMH`C`CzjDe|Y&X=Vu>X|M{Hp_Wb^p z!4A|Jr|c*mJ70Jay*dZ&Jy6?NC1Pt{&R&pAU!5x>D(5h|d;oi*P3Me?x;YFjLt}3> z1paF;j@)qTU`SU=vGPsW<|FLZ4goR3_w_*K8Rr*|auOB@!R94{$ZA=3ZDr1MzMSRQ zvW0lWsq{rvXR1a9>Hic=iaI-qsrSZ;_$e*LlKpEL7Vq#-W6M|GVZ2rI#m#j*qr2?< z^pNN-f0@x!gFF3UJ4x|-b~Sfc#}HyWMiZy;$i`o}zX-3!t9w9C>MYnxmcGF*#fq$yIXoE&K#}ta{h^#0Ba-*E1Kq`ovgydz6mAt2~F} zjoQD{=KNX>T{SN5`ugjszl=kzZ-S78Lg z%o<~dGF45xSMsInL+Oo!DcB*d#)z;L9{rF1WHQ$E!j$cxsbaAX@W@ejZ{DM&TJgZq z{2`Yb3qPnW;h-_5!8aB{QizFvRZsPzpirzf@{}d-nz!{_eJUCvo#@JPwR$H_RE^U* z4O^5G$`tst^`7)3Ys#nZ%%3w})O$E3OKhbW*P92Hk>C09_E;aMiuYFcWEq;0)$AKq z$KVKdN#n_mz8;?6=>yTjEH2;U3)xpEwM zv}7}B7d7jg9BeNOOlP;=%SP?TJoB^bQ**^sy1T3B$Kt#Awtj}FN~z-)Sh9xiwQJk> zgF^ED`;(>GuVfZ{RBsSA`DwYP%up>N7IlpBLFbMm@DEOh4V}Ly=Q^7S+G$r05JFvx zwJ1C>gDaiO*uEYwS`TDyJw7d#jmx>M!RjA~#`-bk zB8U;6T}jOGHJtM$#YFAuRcx(6YvMR6MSd_F3Pt1^d825b#;zLarLd*3*Y_|x=fP;L zv#Pf2bQ1rqhO?y%&`xtUps?E+z>ZI_8Zd1)`yZR@MmM@%_eQWbE~$%V z)L+hc-<<2dF2(&gqVMPA0z_3~6`d@n~}pVmCf!s^tmf$La4 zacF)O|LPvGNrTf()$ji11$w770r6=q_B#`my5BT@>ldHRQP!Q?gUD+7+m6=FOc6KQ zGL%tcJf3=b&SO2?N;BI~0j<*QYAesBR$$UDo0I`tu@tLU4~L_eEY_u~VZmx1B^tM} zr&uj3&B4Q8ev{HI_iy8#ogiz*3&U%_?hJ4bM;s; zma52>#a!JQIHX7+L$6^witNOT56yXFF25;?txu-2{cZj~AODv@(q;008LfM4=mj3) z{k!A&#wYI>opl;)O;4#& zvYhL;D^{*Zr?8yd;(k1lWhK?#V^Qb$d{f`nUhnv-jubu$A3?&bIo> z`?Hpu=(;hcSnobESl~-}oE~XkpX<^V>c{SCP%Ajn_CCc#ZL+M5|Q+a~|5{tT(-5cxw)QcY1)(#sNW@&!# zTc3r;;1^%Cz9Ncvr~Q+8j4j!UJ`VNa9zTlPuLeQ(YN?Cs%eL-oZq}4VcfKi7*@ykp z`nVnv(^qNiG;w$;n`d_sm*!ips*YNoms!j)=71Q!gW*_(#mZq=BXr6KJjze?r5xdX z)Uw)KbgL$LfAeqO=k$m5XwowWikgs^ogu{kiyE~D1dFr!fg69$8PAnvMby@#d9J>e z9+zsp-M1lTafK7j0$<1xyA~+!^g*bZ))6-r`78}9lj1}c-k34Y%{8)U$gh{7ZeRY4 z!Dude?c4+7Orm^ss5o>_6fc-1-EiZhq4z?FQAJM~vu>%fxsR;njOf80(#@S+XuA z?h>QCMjNB8E+_TS*%@TNDRZeHKBR{AYH`uK25d?sfYEiB7KeC~hxQ;mc@Z~;$K zQtCJ;!5w-Vy?1evwhs4rHBP5bUYTQ6x6a1qFdL(!5=E7|w-qGUKC3b{0DskW*;-0Y zv8PT|B2MM`&TmYP*7cKlS+_L@*TtD-v{*rX3cpyo__7b$K2Ugx6)`qUnQz=fC&UN1 zAA7YH5bif0`x)$2vDdGR!>HHuwH|0qj{U0YoR^QjIl5HE^K)ZMeOkL+M6Mn+6nr!& zc>9>I*m6ckJF>kXw6+RH4S-3l1y)_PGw`ircgZ`W?d%c={hgrKvn*8C9`*Pl$-|KSoD&=JS?oogcYn>48Yr9lwj`pJ$N9UX#9pA}ctX$2FA21~g z$0l;7RTI5^eP8p#Zz91+)lD#9)m8p$1%U3;)$Tql78HRg7^trwO>fue=qT%T6R z|GlGVNhOCU<7>}^UQf>ov75IpHPuWzh=uOB+g-qV)$h+3AO-#|YNe-$v103m$#{TH69KM{o8T65#R*2hFnE!FL`AWLZ_>}sL=*BB zgv4)U(|C#Bdk=e7$MX9sG@h#ZhBW7qZQH%Ck4C-nknf+*@m1_uvNOVS>U=vOkk2BI z58~^A?Xv-_&$o*fcYQt)M1>eNMWWOA!FYx8!lLHY9pEZ9mS7dvu70a3#>+A-W)ffQ zWw(`1a0&uX)x&02_XE0{MLo<8R(I>4i%^w-?^bxd6GQ65^LM-hjUn6dR8yT|c|5!D zsZ78Qu4e}f|2W@=GfSOAolSN#?k8uQFCQ6Nj_v;2a&Ng>9I}5*tPiP|YflHJszZkr z*;MrN#%8wN!mqnN0V^xEi)SBEWilm!Tt`@s$jV0C&KCU2k6Clqb<_J01(nsjs}L|6TW?-7Hard=*c{Wj zzAR3i$tmh7An`WffWi6a6`}E$ z4Otv>u&D8dQxVpD!h9JQQ_%se;GI>=jluQTH+~Dz<&ZRvpFm4jXpGgdY2E4sd9xk? z6(W}zzc0K|7U(RLU+n3({Mi}@1Z)n3)i6Z4i(fUOtYr1ez4P_F%|Ki=cR1G(*%yS! zCXhxUo4xn*hn+Q$GT$Cxpt!VmUR^IH9AmHS=bs{RYUelap8@P9>4D$7@eJTYwNe@F04LVKHJFDYi-B7 zd!9sKoWR>vpw1UkT#tRc%e62c3)rEL8_YF!PesOYdRgKF2AoyTm)&7htmRX`g%(_C zwD!)pC*jAl+wN!MS$i9(V0%=y8+39~eN<;GA3482sS|b$Q?Rsb!i!baP#gz|-t92> z?l~!ZW)4=Gj5x-Sud4>)i*z78UaZ9z`9~&)BypFP#nD%Vv_w^qr ziLKAf1#%X=v)q3lLXO-r9)vE9D($_GH+l;r)BHxHAHdfiDIjXz#cX_kE9xYqVV}D~af^ghu z6m+tgIyX&tYWQL??b@~S2%e?4I>H={4O3X1#SmG?y2Kk3t?$k|WfD()Xt#RxzGnou zZu|=UUOWlIG*x$(7klM8`sUngR_DPu#2_zXIrC0uRb%K-$qViC!=3d=(zt$}QiZJ5 zC-p=0iq3vLMM=xHHc5xmEb=@a=-C3+z(e20HeA7gx;rhC7UiMtM-z8pw|Mb)KJ|XF z%u8nJJR+@?H^ogo@g~(%Ket%2cD?t%Z-k0ZIOq9dfFCzkxN0?O7K~@o8Lq!O zj%gJKyb2-JnWiTbuzaFx30wigDiYzVvh2#BuBZ89f2Rd_|(W9((d@ z8BT4MZZaG3-5NvJs#{p6$k^x%`{v%8@AKayx8cH+32jm@!C2Ev#hU0n*LB5u%mN4a zX|*0i)Hf3~_Nut+P$u-#I-u>u*jxxJJSXz0L&sPn_U>3j=ME-yF752GM&2DeIE{_N zj$>H~>iB{McTGkHSbvvw_)3ME@^O~3M0fly`t&{E+j+5_UMY{@S$|{l?y0~5-UYKp z72i4Dor&93p+Bk~upPUUvqE`sY`;j|-R?s^h}oO%J$IF z8+(7F{Y9^gC9|pPoO%NOrrekIi?OvF`=nESk}45hp%3**E_&b%G$Fw3US!UNf=N){*d900M( z8ms-QPj!am2WNw1{E0)Hr9O_|wL%ac%SH8ujn(Uwfri|y^AV)Ge(HmgUD-{^w3 z`#~MiPB^$@L+4{rHJSe#m+!9ach%R}3vXd1c~L!(uBlJd+K;>L>Lz(EqW8)Mt&82A ze$KCqhmF^Waj@U$uIMXZ5C2kE>CRCqn1b)w4QI5vj}yxB>c{$fkwMU5Q&h@lJbUkU`0N~{kS0o>kP8l-rtiIV^X?z?>d#K>jiHYxRr{nO8T9#_sD~DzfC*%+gH2XX%ZOms{iM^c+8)0FT1bS#lh(hY(d%E>z!`HT;A(T z99AdEEp(O$DSBjeQMbyacjGJyiar-9S)#QnHf3Y6R=riO5#eGx_KUOB7p()9i_#Uw zpHgHK?~o^WS45RR>b|S~}Vu{C` zl@0idow0HHfYO0~yj3>yT|cDVu&M9%idrwQlK#keQEYl+PdMB=B zwZL!GckOV4;~DbdE&8=x!kCzaS;MU3MOtHhTb3FOF;t z)m}`DQ&s=;jFS&w4%^~IS}#o1ImwE$Z?!4j_cR+%?R;&%S8E%sm1s3aI$fTX8{5?= z9$*B3d>T-3@ME5INf$8}havl`>!W9%9ev)TpTWXH=#0pJa zm!~~as#$lp{&ZeHnXcLoMpgg#P@6x#{_*t>um5`T*AM3R>JH;f^YWOuD-P>fw7(T@ z#ip7VvV4bOwyqlp3-wHOO)y&uuyuqoM)k4?-8xvlai-Q7%5(Lf>n}Qws1-+8N5r;= zBGyXl@TK_M)%S8&_aoYALACH~5r!u*h_l5_DZ$1RN3m%d(ADGVy8i4Va$^#{-Wb89 zc_g37@J8ZZmG?*Wemw7l0E|?hx_u+NugD!8_4vdHC7iBOQ`Q~2H}Mc}w7y)NvR!pz zT{YPt4|UgvqxILsRBI^M0cPxr;@RfI9%|n-UD`Xl*8z%~bwTJpGwNA9)ZjyN7Eg;( zhnPcF4_kDY9EH(nq^E}+JPVf{>giyTs#{3+KbdxQYpbs9$EVI%huTp0Sa(ScQD89^ zp76x5x+A(nEXL7_Nd1?TjF}ZJEJ%+) zZ{st`F{)X>inTLgT>V zt*@^-f+md4rzy9Xs?03HRul3s&69=cKAp6Xa;!Te<I}F~qI^N8^D||&nh=v&wZzmEU)HT(!2WU< z#btfJK8>uc@)jM%TfWEJJ#j2mVx_+BD=(&qiiV~mQi)Jw;|R@ zw`?w`mQMr3F4d}?iQ0yvs=c_H#){wZto15!Krg$#N-IA!9ny&9W-3!*U7I+9>Z5$Yvp5Q(mw)k(42j0X)Td_g~KU?v&w+#xZL40M56udda zK}AX`qTT`QV^8;@!j93pm)*a`tXNdLsvL@X3K$X^GcFT(YzFtvikWr=k@awEyOCJk zaqJ|=v0-}>L_qs7++kMsbKZ?VXXM+~b+!+?&rxiTgFE=;S``*M8JpS1-B@*Z)>QME z1z!1Pt}GVANnEX-znK(TDaO zy5p>B!74w-rJbvh+YjtK-sOqPzH~-KtMhdKD}Pk4u&itMhdn8QjS+F;g@41etRzCh z9QN+Xma!3h?|MG`bZ0ER5+_!dV~t|NPh~{)TR(ATHkEVa4@a=Gv)PltR`ql#a2d7{ zitDZ;KXkovUp&g6Y}!m$r|_1nT>P^Hj>2f)3=-vNKIk6eSBG!+85eRDTiQ$4d8ZI^{IN6a{$xL^FNEEo5whAV$40QQe3Smc zH2YFty)f@)S%^(D@F~R0(O#m|JTO|Aq}@ebJzGC7CO3ET5pGZ6l^1w4{&zlp6dmc) zvv%hXJ)d&0ENiz4{}nYNAYHtQhsrQhFaE=Sc*y9s*I&+KIsKf~`}83mC_<~dM3*{G z+*6&95Pn)0V;jedFu#Qy^+xwYUna(@0#K*K4yI=xWfe>8V8NPi*mT(5vwT~d3 ztb*w2RPDF3_Y`;OL*fae_1#fyM(@juctga%0<1#yYFf2g>MXoNk^I&kl{kR+og3O{ zud-4VfOlJW@0x14Ji!9_^6XN;_3E6e&oW5Q@Kf(#1K81ztDkPqhWmJW7KNE$*v1d@ zRp(ei<@deOQ?#l({B>4vJFMtFd6EFd;+dNEak^i`yR2}CdhCNg(pJ_V^$)Eb_Ub9O z`*aNVgIJsNJI|f%PN#a7#iet#r_}C#>#ppFIXy|?<>}!6sZoI6o6&T)j%vAGExg)& zOfs;}jPvXs5I%5bHB_;R9bl{YDPQm}`@kaJ-zOeAx473u`<1!=ug)l}C0OZ_5B>Xv z0}=F_T3gS@r-azuPU*rznleseG5=D>+S^Q{^4XgY)*oAY{n`Bg>}%Cir}kn(_|_BI zmAvLqtcbFnHP3tcShyDtcmfwM)A9DfsMq6%_KeGeW?;l+xbE}Qr@*Dg+8Ri4b8;SA zdIo?s7@n2!%f&L381r5{CML^w_3^BF(k$Y#?l{iUgDW=|7mla3J!?U}htOpbJYeQ^ zQOq};5TD_Bfe!*_Iu=`u~=k>%`rWXz|HXPHcxqMq^Rm{VH z4z)XDjI|#1qHC*F)zIx3XDib7k*Hk6I(DN|S&E|{ABN~=^5tE?_QzZJGVWjdZ+vyr`K<8KLyX5A6u&*R>QYyqVIy~alL+u zSX)+hR%^_-&UoZ9zxT!VyT7MZuh<>;nlJ2ZkA+RJX=@Fw)y3nzk4@-WdpNvOpK^w* zq)y!DsKskOvx%OyRs}b&9xP|IP@So=raUMreFE?3c_=*zR1Se|Sw0;F|N6T>oc`_~ zA3a`AMZg6c+jcx)h2Hn$dH4Ao8l84s(KIW3ZH|_4*i8-9=K{;W?ea2my>XF^pD7eN z)p^8Ls>$EoXQ`iCM*{xZ|3YJk1j-j{^(6M?FwX;0Ikx_4?X(E3$NllV`%h-B)?cYC z7*?O)Qu+dRiv9NFw4)PV%c`QP74LMoaqF;PAS|XYk7;9iaY9psl=(JaP{#kQ1-x;L z=0{^^pMRBBb)!>@xD_-SE z5vXqQIm#UK09c^6o?H5(`CoVQ zVE#0o5nw(Fkd8KIc&vJBcb}RR26k_pnmvxDLySFyh#GpO+N9oP{b;p^Rk@GGTkz}p z@TLcjJ7r*ehXHvXtKFU7Q`ao#rNe?P)VJ&jw|-L3;Qg7~Pi7_S=i?b_JN;Wl0fDZQ zE{q9e)H4PsE8J$DcK4`9szLCBF~D*oH+olI1@7mLhhSY>*lK3gjdkwR@2aJqjR-yN z!O6enXk%!^Vh5_(6Ozk&w74u&Z-brrKZLq24;I1I2s#YWwg<5gI0q`AKaDkOk@9)`c{XDye0DL7c;}p6J&$KqQJqf-y%X)~dc$-5b zGyZTWW{er%Q)Lg073E!5W?#0qcgl*gxvD)xJ`HQV*lxkHVoI^~*xldTD&^)d_HYL8 z2{9A~4Ij2)#H;&0*hn>1uH9$hm@nM42Da6Rdlux!){I}BEE2cUCO)rGp49)`b+Gn_ z$Ru4Q-39~D?~BItemsfctenZZJ;}f*_HIRr&1$*0Z$->;bZpqlQ=5ArAq=pAKA8yA zLD6-`Ei|~?gVQJ_N?8OwKlO-OK>5GBhas!FdGlTR%dvGStF7y$h!*x)OO~(Av6=98vW;I;r=`ZzNVHSq)tK4gksIJ-9 zbBre-$d@ps4``jYnh6&1ReWGf5L^@$aqI%aenyvzOxRJKsKv!g9U|A)H-aYTST&Fi zFv`}I-2(+%?j@kw)8@FEeKBO6DODaum6hE^f;GCQl_%Mq^SxBD^P7~P7uel~b< z*V7M2x&QI8LxY0<{^avNn%DP7)%(mIdxJln`N`$ZS1yxr>Sbe5nD86#Q7hVK`ug-O zzIS|vp3J2Ze`Ut0lfj-i&OC5FR{7I2{$D%Z|J^y>ikW)aCp{X4b#Jy$tNr3Y1nru_ z3lnxw+86!(*pUg|#QZTYzdEE|J z&-bJqVJW@t?`kH|1AXGSZZ6KLKf(+3ZGGk=wlyb}Z#BW*KPRJ$*Pi90kN@^4xgX4U zRPr=LxkaB#26=Vt@N46zU%&jhc|QGbUH+rXZ_n#5&FeQWe|E6;E;c|9gJ^&kpq2 zBlLs8DVr2`-4nTWt9`kA1Nr~KjOMpy6u)`-%a{N3@}FP+kGFmtw$k8tl`1=a|7yj+#~ni{GkudnU7< zFD^`5q+?_s%#tQNvzlI(xWO0L#`+*++R5U1nQ6uS^z=05?mrZ9DG52&3R!ou;Az?z zyHJ;UlaPi*)$H5n*nTt~uB$`&$b71+?tc;sJ>e2ViU{|Q7+34M)DW(cIb%*ezj%?> zgsrCr3&oCZ>eDkWnV_nhP4#=c*xkBzn!9ym99N!dze37udtY_P?Vw0U$>DOou9z#g zo@o6?M&PA-%c*;@gSX5?eNUTU0Jg*EYb&|bYM8#4p0Lj)!`5|4r<`rT-dB9 zLsE~{w`l(MU9cUt*t|}gh&3pevuM4ZYR;zmH|@=9vlOPvsx~qHT5lVM-RI!#tZ`l(UA~ogYF8m0=Ef zrFx2ASi2Y8cCM7yt{}L!bKIP>`s`!=&~u|;_^EZ?YJ}>3*I++cOl@Wi6pXb!^M@uq zr1}N+pU^u+yg04Smm8|8(s1osqr+$j3W7eXZyf%45LT*Zu_~rZg&BqJHzcZ?+X1d` zrt-%PY-&HdIi%IpnQ0s7Z9f<6RL^*qvDm#Q=ZXn<=zVoNu#>D+ugmCIxxQ`+)qHrb zeOX!F-8hh6h2yCeAyYMkl_)o(r9CN}n1waG&y}GzJ*Up1zhI@_zuW~i;*rKJE{&`6 zwAu~Rt%d8C_+LjCr>*bO##LS_*H-JzK?nWewm zH^EL6nD{f=nfm<869C(%P4C)&fIH)-I{Es~#=l6H{nc?8mgceI;L3Umw5I+MpS70h zDq@$Wft`B&)F1Yv1XO)~@5#xH&{-Od>`>)k)LoCwtgrX9rFgL(KzOTTR6jC=;shn4=}{|eRlz! z`$Juw?d-9T&5C`T!ShgOKF%r5MWh|));#hrD;q1Dq?qz;pNNJ8OL(CfDUO~iS>x`v;IbBZh$b;W97%mP$8%{2({c z8al%2qAC*@kNMb_;_@CI@wYL<&f;24VGg3Lbz-r*_a@aNs9qH3)O_`^ zt6;I$k zv-bC?dHBS8XYjxDvDv4S)oJ*2>s!7SW8$H8<)Z%6nQ5HEUyBD;kKIHU3*jv4t2O@p z9QW>H`EU>u$UeeWhk$imA*4Jp$9e(P#yKyd5!i6C+29b6pgvcKQvPs5!1=X zX$TRFS49}zh?}vpoVe?<;7Hc)n z9KDC{j5S*O*wwxCkm%)y?JK*obH<_SG)lYuYJ6um1)TybFl=;cJgkUw@X@Z%7wz&Y zG>dQ5LAK^+(TDrPKz&ouUA$04BDQ*3Zu8oFE`RsFR(wQ8yjbp$%c@KuX7!R0%SG{s zJ@!>Vx_S0D$P83-`D$0&ioN!2`Sb{47v>vR6pq&-=|GgZYaTg0ucNAZwe zQv1eM6UP`h&U>>B4l*;*%CgzV|J%i7-5QdpKlUo_=_CqqGhOiq3u(yS6;(m3G5|b!mGRL&_EEQsAO@W5Sq3 zlhKJyxWQ1~TfV^}DeP6J&BxsM+;_7Mi|kH4)`g(+^n*XLCi(B=CVigz0Iu#_ zt*_mkqn?|88!K+br;fur@{lN^FnP-#M^*)Pp1IWgjGlGnxIiw*hH1|<5N__>@?uJ? z{8A-Y-mo4WtEPjT(TI#f9cGMG3ujEgm7HcA_06{fYOE<^eC516+3JoC8Qh7~_EhpL zANhTAX!g95Jz518Z&s$%NcFL;q?LEsy%l5mCoL&I^RNAg=4!OvHwOpCL3N4g?*F0B zR?*;wUODa!Jvv&ZeS0(TOFREX#kvx>&?cO$m|I3wpXTmpy>d%aLsrF zKUYJ@!nj5qBNy)4rsKW0dd9eyYhbZHlWW=wkdj+WmBn^$Y9_NQl3F*$?qVnYVJVdq z_M*qb6|Dg2MqC|73x%o8@$O$rMQp!!?N=UMESD#;1tyl^L$kOs3K}yH8U+NJe@NGJ zOkIF~x3As$wT!|#th_nVx~xiJ z@81_GkWK;j?y5KOf}!YHRe>lJIorpj2hGD5&tNgucaGKxtCzZd3KS1gwj2Gf#4pw3 z)xJhiCdN@dN8G+8t4?0slYz77dpc(I7aXt`Tv}hGXwucD!i!kA;?3LOn%ge?XOy$te#Ss3% zV|~w$u@g&+QSn~aU#ASt$^#;TT8eK)sEXH$uytR3jGw)pw!bX{uY?^GEE*FKJud5cPKZT+G??;vq5Y8y%cOs-wi2J#x)G zT&MugehM3@MZMC*?fZlD@Z{L)vG~lW{I(|$wJuzb#GV7a40AV+`i(3V3&{uNO=}M_ zG?i4Y73cLN_08o@IsjH=B`Vwg88(5-lvCrSP#fba#PSgT;YuS3*VQ-qJ#3e^_yz`9 z@8l>ECacINR1+-Xk`$0ix;)%Yi|&gEFPKlHdeypnDyGZ%I!!s&rMPrY_eF=IDbCFWvFb~DmeTZ-?jSSLob;=OW-{M6b`+)tOA zKdusESp$QrvFx1s&arPH&7lHiJM%K$bTNHFZ_^mEQO_=FZ(sdrafy@cXw=bPMlF+D zdy_FB6|(#E2Ka78Fhy?WbcPv+7BiBc%{;w=WxHZ)Ibu|2kRF8*S;cyaJdK^;2@d22 zD7Bj&2g{M_xAxrPE$gJMSv7kWkh_Z6^oo(mVP(@YDsBE!H-LuD{-tRKz^4jJ)8A-SB&ddvv@c<>1 z22R6cKl_dJgsL98XL^xj-YN|7lPcH6DT<9>y^?~jm%>`?n9jpN?03R407Yv3gui_jXPN< z4q>}$SejuYuO}(M1nw=@8KWoF;wbFE^3I~_hdXED_0~{RoNVmc=HFdb?Zar@Q~wEX z$D6Hrr~91G?t-4XCeARB?`cS#TE7b!F}%Fch_aG>=5nc*y<0jwdzY99bT&GbRr&Pn zaX_e5k$pCZ=vsw}IkvW2g>B8LXQ|k6_0zeQy&15?k6#`847&r&y1#xdJ%EdioI>#3 zRrm}SI-35eo=QnUHe9tIOK!AN%$_i3wP(#tj9J|2$K>zw+pe!wq1G+0_c528BdUDl zFC3hgwoliyQr%Ty_nG=^vv--&@ta2>wm2*Xs`JF1_!URH=1U2{SG!2?0WTM|YX@V& z1!r&C6+;8A>~nFfQj2Ake0QQ%sWqm}hjKu1Vb>t7>Rx@Hv}`BSy#pif%<;`2O{Jsj z`IKS~_w+n7XRia5;%rq+R-+g_lc_pJ{*sHoT_a$u_IA=m=2GN8F&^x>TzckuCGjJl ztEYKM-%u8HXEttu-?iH6N37}k)wcCb;6VN__w$Z-*&+JIL`C-vhF^Sd|A;w5s2Ss5 zb8js^Ud5-bZ>M6CeFHZ5L020v>@cNxjbS_GJe&m>!wZd(`r)BI&)8#=)}V~1#8$@_{Oo* z@MjYbp5cliRGS--nC{Fd^@FROXo^-`z8G6tw{_Q4Pd&x{_|m>5>kaH8=IUY97lC&S z(7rBf^*9kXi+#2>19`N)Ea`iz>x<6L*i-mL2DXXOU=8Bb1u-+7U4I=))jL0Xu;VR7 zF8`E^%AM?psp9lR2=Zbf$UE4ib z-B}H#x|Z?Si9fBXU@QMKuQIl%kw@WK)$jb`S?pk;-D9p#qN-r!Ug5WWAocayF;sMy z+gp#6WAq((wmwk%wCY7bZdooQh-tY&{cEkFXUN&Bsm`VH)Vbw!nwC0}^I=@vr@45< z9Pk8hh6g^m;Yo^iZ+2&f$e>YVKAA&=V?*ETbB5*C__psLHd&am zsUOhp0@V>z(rxPO`i(dQ7h*e4!t7Z*?ew%h)CxB~KIUY7XT7XyV=8ku>Gk?jYaR{H#H58*2b^hu%z8m3c6R^=?{6P&udi0iKaO4%!Xp1-FQ|LG0M53;tJTf zeT}dhn`WPwuQ=nis*m;});&^{V-dB!->d7I)z%pCy?ygCsC`j7L>~`g@{PTy)ZcnX zrm;5Iy*}l6Uan8zZe<8y4b1MUu`c#8(^WKTZurKPxFF`MYLS84$wO0#duKBXS}crP zi>_b87I7P^JChN1ACd~L8g8$hHR3=0I{)7|G&=tm&GqEk9mK~tjitRu+~X8}O4~QS zI^j65+1OEJY$}uWB#omo*!rVSGx45OIE~}o@WtC^ytPa$d43-$nBg) zR#r)g#Qw`dMiL@q030LxiFN1JYnS(}fzds%;{9sZY6?H&U+0s*^(W+$o`OM_n@9Z} zd0~7yZ47Ee=@cGQ{PI}`|nvm-*6sv#jQ;vyN%b45A-$p7I*HUo^rEf1SRJ~ggh{N8=6_({Kj@@Vz2+QsgrZ}W3kvsbd{5CP7&{K2ZU7rPi= z9oStb(l^h)j>EIi1(R0W#YE4Pu@{w2NmDi6)S$d>Mi>dU+mo&z$?is76gXL-bk7iV&uq?qh_=^8w&l&Z5JYU++t0v0E zp5uX`HsA1bS+@AY3&o<@RVSne*wTE{)#eA!={D%Y67J2Cz#+@EOL44px#e?wU6J~@i_MK<@&b=QGG5ZMya~e6UmlFp`PSLF#t&{l`<7K>3`M6 zxn8}t$P00h9f!tLZ-uw2+wr9HEJLOjQjE;aqC#ro2`T9y8OjT&R>VoeB~OvST6!U;AtAJ zRXRr%W9m5>*_q@XYjXDC>vpn<7?Ky+fc^;QI{S42&w2xsTaT;%L`%g>{vTG;J^k%> z^iH;b@OY%?E#ke?e5uu+&h>cgIx}_U_ECw&@()xQy_sR#_$Dh?hqXI@tD^GURuSr2 zef)Z%TWdRRyTNj^i1!EE7z>|o-@oo*_3y@#9JkL^wE9wP%>d_2YQ5?l_@heW`r>;v zPkF?s%0{0aF)V+zA0680I|`~kg1F*|Gy%Tf9tRtrxaDgzQOi;Q>?m%^CsqXiZJdh* zu~AIKusyXzUriM94ZP8<@ZRz1EV?>vNLk|XxZXU}0_@oHd~VHI@PawVbTSRSq4t4r z3cDK8_xtvCs36!{r7V(rj=s)+6spl+5SFE z^StNMcYWXMPgddUXz6@azu;DC26u`_D5&P;4|RPyfI(WrJ{A{wa^T%HGGRM`vxWu6^q?Jx?elh4)>l^Yn>MUDFAcl@ieGBxZ{DzaO!(3@66Z^ zdpi<-WZd23oKI+Y&oF9VRZk9Uc9>fp5c_zq$-e>~9VZ(qEgY zjEW~!3MxQ3v)wHALG-*n{X(i1uFre6>UMlIbLh8JSNfo8j1TmgTqy<;HAde0MLJ6C zmp#kG>`><_il_EkSTE9P;&B+l8R9FXsI^-2 z-!;ng3C+Hr{U^pd&Xqf!_w=Z+Xm$zft%tE!^=5T;I@)uc;{aTi-r+UqY3~i*heP-a zA2Irg8&Sk(EY!cw9OT-4?wN`VpJGACkpFd5@DUwe2Ua{(byat`vQDu3;XOZ7*V#@B z_UlOkb~)4=rZ3vpK|NJN#4et9jYII6?^Q=wKg@5h1j;>02bSuJ`((f3Nj~&jv1oo` z#%O8r*6R7P_tFokMcCuLaAKEAdm}{G2ZOcrjr*FbjUC7OY}MzW*-yf%yf3~en0hL* zn;NA(3hc-(p2ya`_wN6z_R*{H%)i#4bt1Y0Lf-U*L2H3n8PY|tFIbZ$*=%3-bMHMh z*pwHnBb4{$+ZpPN*NEjbor$#o{gGA(`#77mQhs|^w5vNq)oPj&M?;%B!g?01bLuu% zg<+@(aAy$lpLD~12g;P}=A#Zvq%{^*D}p!FnA?Gc5v;bRBe(p$8Wy-!A9 zH(>ab$Bi>o6{F6`N-P1#EV0Zl;{37ZY{xis)eoSAokzUNoifA8Eizd5EsNzk8?>cb z$sEk49;_H_^|F3^D^+j~cXFEEtGW2R4ErIge^S!kr;D5l6M=aSAH$2eu(`E1GqCm} zX6bhtxn8Sxi7@Yj74~3}y23cZUaw*is)~l{Lf2Sp`guIu942eVhA;#oKY%C{0G0$(@#Ev~Z$Sl=dSytBU({f@b9eGdA5#!a`vAkX$ z4OtFx1$k`yIGYpLY}XpGCcbr4COD^y%+?VmS6dOu~jsr%C-u%4~+8BGsOF4 zVC$CY2K5}@h96k;{07ynjFUBsL(JqDthN0*{H+UBt!_O|{l_9S?z{89#<}N(L-trL zC%05{reoygcpc_Nn>oQ0P2Jj~&WlW2P7rPUS|wOlw|xS53g?!AMO1x5+FIN~WU*VX z20O&~Y$p1lYAf)r8Rx=6crVY3$8cWHqrD>XKRjbcJ~9rocP$YGTb?qy^0yXmm|fbo?lP9U^FT1`(y!KiB$i%${alfT{o< zEZ?)8d55WTN^4b{`#iJV&OTK-gsHcz`LzG5Itgc`1E?oeQTR7w7;-hXjbHuy)YhAi z<-YPk|68lky;Fy0h`y8%nsH?X=xd+ zUZ{xFo5=t87G81K@>PAe@WP(PRDCYK_}CcO&YEubn6#&Q)l^S{N;|VB{h*2~(l!o6 zuFNOLU^xA29L7IZdFUk^@A|&`c{&dB<)`{9tv~bxSy;K>!wr5e6F(P@2HPb@wV07Qo8^h}I#nxx$e{1a3 z6SSRSYbgvQvaAc~tm=Yd7kaz>e60e(G$w2nyF69iX3z3y`Yb=x52$bMUdr}37%cgZ=4YQO-Z*1xp4Hf_Wkxz6;j*Y;oJCz%3HF@yWP^joZ_wioie7sLwW-LWBV`D)(b zE&}`Oz8$MLl82oi8+HF;&s?N`i%iJCT4GQHw=X^=2@}wk;*52BXVJRZ6AJQ;b)fQ& z%%P*&%4J<96=>K?2g)>ZeHyPP@3a%Zih_CyA}|FDaUFTe1?2K%nu1pUVqj^VODW_Gr)-B_eYBxT|*?PIHsjx+Sm`%)S zbE0~%QFUGD?>r|jgan=`XX>&z$|%x4&gPsHSZKijI6!`d30PL6`uvM}74_%Dhn-3G zMTqbAGT{<>PgdeveE~I#ddIFLxuN`OtRmjd2uHyX-1>RXu@rypEn#Jvt$HF|ZYJOE zmz3XF!CA~17s*Cp%(K+DW~_FnfBb=Cy{jUCU6xa!FKxQr2>KUZx-TDE`K)e8xi0Ug z`C3a!OW2uB6q~4OH)0*`+NgC)qphd}0{y zwTnBDpx-`W`*wKRJmqNEygwfE1PA=Z*XL)57>`k>(DcR1sBqJs4Oi2jb0iBIo9ExG z?Vy8Bu$G`A}zPwvdx*TIDr-%8z z9%rA+;k+=w+SrjjAk)0mIp!|bjlqkqD}Fb&?WYj2@h{KPr*(0SrDqD@ZZBHcstfzM zYC5t#LRH+ZC<>^KBElS8t-8neT{{+MX>*7b?J0pcK~H@5AVNKbXB<@on0@y!iC}nE z(bw~VBIu0M#aT!&B0Lfrv%&TeS=LLP(vGmSP}MW9c0VV*BEGy=_U$)CEM931O7-d` z$GIPiW>&NHiHJTM#{H{BRqK)X@2$xle=_;Vx-K@OSQ%}jbh5n) zFv8*x59Ls?J&EnzR9l@-+w_Fkp2TK7B%i`SOkBR<3uxNDDy)?c@Bl^18^%+9PBF6x z4c+H=(q^e;BcxDi_;htWO7mj|aQrnDY3)coYjUV4wO^{>28~%aUqd@2cw}dT=5CR%u6(^rKrF429uk1RM^YT%#BhJ}UccL9?s-SXRU86qdxiwj;Qf9Tc&GqpSZEcRUdJ?bj_YQW<>__!qMrDnIzF|z)m(eEbZV;1S*4l{FIx9+-34;Z zT+BJ+$?Vu&T=J|)(7g>ma!zPXPstJ(9`3LgZ|vG<*pG{-=!n0yguKnOCc@IUXF&+tuOHu48-+v6ii|XcYXGWvzSDEQhqB-s}k+H(xp=E z!o73CsCf5(edD6dPg{FoD|2e)q&vr94Nk;2tW~+Sj|307u6OuT+^5&Xq)t~W)^b|+ z_&+i%qJt(6Y<;LUh)>#ux>cC?Gg{wag%`yUi{npzqZ`>(PFrs2{>0rk%)cF*!q#8d zTG1LMZ4Xftp1I>xc^dX8^lD9huQL(W;9{9uCNVN=J*`#CtY(!i-rgkqu_7CuwT`Qn z1u(TEA))?Bv09eI3}Usl%Z{;rrGK~U8(Rl?Xa2%ksos3&TxYye9D60qz{{=E;$#1& zm>kpC#SA-BGe+vZmh?)+*>ju5~Cr^Y2!q@LhdGnxRiz!X5Py=wF}k)N?Xk zn(Su`=^A6HE;x0fI4({?df8vxU}8}ud$STA$L7vLDYAfkm%@R_`lX_$N}9@mz--e> zTsvFc`|KLc#GN?qXHUb)r1f^%=d+z-`#SW#>8I39T&+`qd*3?lc0v8C_q9 zH+`Az#F%Lv*Ka4f`v*i_b*R3q7%MiNA^p1hdFokGf%>K_MtYBX9-gb{=ZR0S` zu-2G)2iNl~Pgg%cwD+b%_+C`v;xLSN#ReNXLkdV9pd0!UHQB-0Wrj3+-f1pnF3Qz; zH&>?9G4gret(nkEGJ-GT%f8NGM`XPKV|aAD?6cUn-|W1_u9|}K*1IZ$*6+i))ej*W zH(2{*8RMwObk^-gpq5~l>{i8?%EmqLV}xuiN65y0Dvm|JY}uID5~rmmW8BnJ`!3hY zJ9pL=nZ{L>ckZe+dNaZN`+o0)N_j&(t1DU&Db9*yRi6?1YUSPEa(C;v>K}+*Y{Qd$ zYi(-vYMN3{Bs_dGD6QYq{cVl6c#=hBdGoD`g16=KY{uiVoB!dXcFfT4c);gZ$SC2o zqw!5T0M}Q?u!EVHKX$LXWVe`ZzS^JSJSKj4v=zWIw|S)LokP!9{7|u!(YX$RAB@lU zQy=lN2!It`Tl>;@pmQ5n$}fM>2<4o#fp-<1VFq^8D(T&azQsT0Z_KUFnXUKY zi#t-UcNs^U66QKO`t;S|@^OOt>4eLXYR^)s*P5EhC*VJNQfTp0JEx(g)+ zI`zGyoGUd68F;XMP}N$TIfFjFmSHG5wiBf)O>@Lc`i2yosI?y&BS12)WmP+ke2Uha zNA{F2)a|X4^1-vm>gw}jZGCdFOVf0pw>h@1>NumutLh;ZitRs5da|-X z7S?0JmgZXR1Yet>aj>WmDWY6=t{S9jxBjSiZ_e0y5q`{XaiC7bxG>XBWcA_qX8bSD z*m%hOTso+Fk(=+0@%{10kLEK;Je!^++~2KhqI;J;U6Tg&+wyRV#LS?XC#=Saq3VLg zRY%B*?P+ve^NdURLIxM(v|_8eY4fTOyj|v*Z)4qJ-Z;dK>f+p$rAvcr`Pew&IHkp3 z#+W^;S;dRkHy-1{8gRR8;X8eG=ZK9u|^v;ZzB7gf>Mf~#U z#JoH^HeMWWVo}+qI|J|}pR-q=4%Lc`@zU(wcZQqc8@n2NYn^Jjc#|cn|i-No~bKf5THB>|l_sjg95tM0X38!=L~2t+^S0 z{*FuOdil4Sczd445gUhB@h4}gq+>TTk zW%2?g(D6pQp9Uj?>>ZFj%LEHljk1+)*SB~67rD+%$*b9*zW#)aTYgb5$-#ZiWM}Mp z4(cbLc|b`N8~3k%_Vk>`{8}fGU))hD*ZR~4>qPE3`SR#6+?xn|VxHReujbQ9zdvVj zKfBL%d2N2G+x6xA#B(d|&B(j^qNlaopWk_Y>DO~S->M8g8&tdh#OH~75}e<{kLR|r z7u@({=jZ1qbnrLVmxgO!K92ry_|y}2Zq9Fe?q;9iVW*ZHf`9o1e(kDB?~7?_iOxCW zy#7Vczv3G^(s1VL7^}J}LR#9W!+zYleW4R)5bYUNo)#w)uGWFdQ(tV4nP1YTaV`A# zzc_S#M~QxQZff7TeKxz?2*=i#_{!LzB25pct?Dk*w&tl0tP;ahw0m7l>zA$|f_Hat ztMGen8CZW51BwXac6D*#@6|?)9WH&byZpx+G8oT(J?!HeG-}7Sc7a=bu^=2!CeBc` z++O`~9e>JQA~0p=`e`{wrPC-P<6nL4I`BcexUzmNt?s(<`R1n1%L`>p+8X0j8_{3e zMPn77#S!U+oqKhKe!%*YFYpSl##QFV7VRYz`{Ek!iHEZj(=1!7iSJfZm!D!OqUP!Q3=XL-4}EIOp}Zudm#SYv$J5+<;ZG3}ZMJJ$8A&lE~&LoJ}!XgaK=gGJv{Rj$+h1p_TJ8Umv>OZbJo)LfMr7NWs*&0m`Av1?p#=Y^lxtSHi%X_v?6lZ|}(GfQ|!u~3Z# z2dN60+;eM00Dep(!>bxcZQ%%70`4G=$LyPgerzV+=s&}Rv6y{*2|s~q+Gp3Y9oGnr z->e;}zrx1uJ~CqSqWtN5Bcno$PdqxONcFF{Bl|l`d8PVAzR{QU(vxc?f^NAvR&=j_ z`=EQm>9ccwQ79ttoKevltqQf*0uEaj)Kjv{1&2fN2sX)+`C1%2@guJIM z;2)z@$HqcXv(Xsyv2VGr47c$wmib(*bJohehv%_|xflCI;MtdE^Lh(>P)*uAXoa#i zeJQFa7b}3~Z+6?SGFOb`bJ&cceChYj;8?$Rj4$s|2i2t%Lt@kHy|>!Jb;Gn37p#!g zt36}?I!Snq?bFuKtzR`iI&j2haX`9Y?LiUaFIQzd-=Vyysc!II_IA8Dk{!hi2C^y< zR`YauU+Mp30uK6u4D;Sfah9T zgR6EDuPPa{;v<$%pExG_I|{qeZSjRGxxSfEKE@aac5Ypd?Gcy*-ZBf%f-H((9u~KI zx4h)ZRi0bLcA@|eq(097=l|Bxt+2d0Bj$l!-K2$K#klMX)Qk6WpZF@eM$%|zDi1~$ zr|YxQS#<*;BOe(-83v#4`r+d<|5Q6KH&^(sDl=E8Y|R}y>qEGvuWXeEoSzTjBLuE( zH!l31j)$^THXZEA(YszCP9atwP3H8jM;@q#_WZ}U&?63EpbihN%dc6gr)cFZSg=clQVR zH0|;Ln;7Z0(QKY$%K6H!kkbg{Z+(mQv^$smDry`WV)rzMYbbIjlsotA-+p6WZ_U5# zaJ2HUdmvP*^6U2BLRWf||KdQMmSP=t>&0ce6cwI3Ykz)G6UdOX6)uk(}j3a_aY*=u>icXqBm9){t1EPk%%Zzai zmH+WvQ7kWS!af`Im8R*bSLu-M?=?66PbI>bo+Y03{0~vkzC~Fsl!-9OU-!*%=2D;?|duu>#x|%lkZJ7EcH8>2jkipH`3!;iHVC?&_IV z`mC;f*4M0%a^TG{Qm4mA%8$-#hMObthPfL>*)~;OXKIzg^6;rIWKn$}ImDRtEnvPb zS#`g&s(7ED>}l;C6LklLTAQUES>J|kceMQ>&i(DZZZRZQ!Jlb<-sO{?hSukW#7}aC zx!NPyns$38ums-WV?SxtGkq8FV9dpJa{)N{fs+^jI%F!%n zKJt)xq$A*7zn3CP4~tzf<9cGjSnI|?m)(itQfIR}nD||;#jUB)J-!`mI9>hU?i3v( z%&5+i19biQ!c4`lcc)XRNp)CV>9kFHHp``_R(H5M+v%iKk)#IXQ~1;ws*_qC76%)x zGqf4~uF16*vz2&1*MYU)uZ~4|5)NfRcyYdb7w1t8MJao;9R(Cuq#t5gIR{VSeLmMi ztjcD0Dnjq7T^H&nk!ZaPqtH{bFjUuTFh6r@?NC0T!qYExRAp1KZhzee^Di-?b0q)h zud;vWJ?rhV5%0Q_&Dwb0W;wjBfPul`tE5QU+*OW^3ni5u39|I>7TGx?fi3CB7~~;6sLLWn}j?$O%SQ z4@9h+J=;Mi{kflJSvEP>C{m_jUM%^8eX2Qj-;%kD1XVo_5QlwY4x6T999vF+p}ljV zyB}4CF^xzxr>#L9Q=Z%BV6PT}Sz6Qi)9~s;$M?)=PqY$E&YP}GZRqB~K31XC?evn# z*l{iFnyrPf&}t(qe~VAbg0D}0fik%d-(jFsTD1iBpxS%FZu@Il-q*ML$)ZDDD#nec zS|(jVyBfDw{Rc?V72j$mriK(}Ha~WOnVuDD|5AJ#lWg3U2e1v>vNqkXpJESW+5@KX zweiJ|u~67I(sCH|^Ng$dyXeIo=IIzXlMB>d!B~RX7stvc2@bW4`XaS#{i#ub(dGWHq;z4 z7k&z#;*>@#M;Hg)(`QHMW2TE)eleq(-wqPHxC^PBcFvnMiaKY?O06H!J7tpc1P}5W z&&DP35Ieb^*|23jq;#%G=ZiG1afM-5+O=plU(QMqh%V>BYP2bCaCP~hy_(hR?2u1V zdfR8sAN9VR1yAt0k)?p^#kNZu&gh8tNEo9$&2MFb;(ZKvc+1GF1yWhY)*5p=7iTcT z1FTa$+#K6$#+L1Y>i!j$^v<%JnRdTYbIq2<9*4@$?TwfD^hMG#aDpF}H`q_S6+hKE zBFxC}?tYF5-jZMI1%*6AuIwgM&6d#8Hox$(ZvUB_b~(eF!@5qGtU z%gd=j(JjvxpXI44V^;qExw;Q{>#wTL|K~E60feALAdNH30V#<>?mp|5)f~$wVx3OXhhyFsZa}flE{QGSlI)5Xn6I89J1VZ4 zPRh%t1E{?P?Gu;P`K%h4)l936^^1}OAL6GWPn!85S+iRyn~m*scKsJ0PR)xsYg_AIb?tv+5N&u|0i3Vq)5ecTbE@0 zMEE;~W*;vhKFH13&JY|6Dl4=ZgI;l#Lva7{JWJ7tK8MnjDyVzTPqOJhj$}Ytv zwgUxtovYi2*s1d3E;$wdVLj{87aEU`p~?jOzx5gVfx{%WGpD&9IkGbIlNHe`G_GFa z#Lemx)s?VRdwH&!ada}X9r8K|kDCtqqvi>*I;mA>T06BSX!k8X#v8soWAy3Hy|uf_ zS=XMH^1_B-79y< z>s*Y_jos)Q^@I<-ocJd#`vmE>=3QPVLtXVNQA!_t=RvW@gPllW&R5SBZ#J?Mjc7(r z=#OY5;(uu*?ip#KanTKyu{j)F|0r*Px8i47P|Jad_C~NB`{>xHXJyoJ#Tsrp zcgX_^!nh)0agKH9%%OQ#A=NL zn{L`;W;F7BXS{#i{8R*lUUl*#jj1*?gKC1GSy!CZWf#6_SY4NmQRgsM>WD8&?DG4%F|GpogYY(A|L1P#70vg42T zKBfbBV_gKI^W{&C?pft})?G4H7y9V<{pIu59s%Re2l!4{T8|T4*IjVf@Mjk5xaQOW7bnc_)oyX0;H=S$IA;0{m8N+4s#FvX^PsV$v>-(~K z@{4D`T)Mqry1>udzH`32YQ`1o#_8lKo6RQ%H7?q|WBZ2f%eKF_{q^lHY=3V11jEzhtSL|Q5f64wu`xnmZz57@1Z?-qtp18f+_B*#v9gV$fu6g6R z^S5vQ$L2RTf4cd*&AT^Oj`Y7`&+BXUZnk&K-m!bf?VYrDr;+@<_U<|V-edl~``(@R zPMx3LeD7=bzH;yLn~!eJ-@J13hnr{2b-rVB#^%m5_phH?_ItN~xBa8-FV8q1u)XVy z>4@zOwwvwe_OG0=ykq|j`+vLt%KcaE|JD8H}-#bboY||KOIfIbbk7_{j2u( zwqL)!)%Nt6>C?7y?4~!UH2Zo_n5sW?EU!OPw)NA z{QZgf?g@L38e2JSXF(_JU4QT6n~OJZ-@Iz`tj$kuzHjs3k@JlbbF`mvD=$&Z?yfY?U(mIzyGEEFYN#G{-^gpx&Kc)soi#a&ynpTM&eK1{^9o3 z;}sv6@qFFP^Yh+vp45%-nn_p=C8-1|7i2V&2Noee8<@7oyP{~@Uz2W z-nKn^yx`^A7jK`t{hjS^Y=3Pe^px#0w$B^Q{?+#N^ZWOWUN$qvqc^u3`*`SB)nms` z9yj;-&KdnTjwKyB*aD-jn)hC?d!0XC_^$b%XZY&ds?Ss{CoHm(p1*ru%1s9W?z(x% zT=OZLm&}+yJbt$sZ5}&*cjA2g)aD;%{7>FIe6Zv4?VpZ+-Di8q_Cx#U?EmrpukAm6 z|B?F--hbf!L-)U9{|EPrI#m1FOx&-j0QY~%lI zUNf?}V)LcVjmEA{8JoJ>-WlW9517Aa&foiuU7a)nx3g3cS6yk_&F&94qBu<|<$#vVCZ{ml0L+kYHOf7$5o z#oHGR$~|}cobB(9MxVO<`9Z^9*lG8f+y6a3f9{O@g(J_uoOi!`=JAH@xnoH*ckx`s z6J2m8XOim7moKUc!Rr$?w;tTM?I6UhNB^OM*dJ?-{Zv~MSH%=PMXu*8ojQc%Ol9HX zr}&PYST)f>Eso3BWL)Bs3{u@v9}i9~o>|?}e_}mDAK}esY$r_AIb}w6`?1#B&gf1W zx!h`pcPGtgZ#zHr^IPsBlcjRv`$*mA;dcBhX2o;HYn_su;9mCu;hz31ya=O=fW z$Z^N9gxd__oiuYlWxk#`pF4geqf67O?@uAB% zAK6?rKK|kH-79xrKeGAQe7$He=I_Us|9BT8zI!6%se>$EHG96!8{NEUqVdmdzyF#s zoHF-6dHx=|J$!rgjN{bpH_X@`w*B7i4~^G9Wqj*TM>gjU4qP!({OYm8W5?cD+O21X zw;65Rd8BghiNRv)y+=OZJn{7O(c1k-QV-ev_3wiRSsymC`OcBhx6jYNd0r2iuirB7 zz5D3R#`~W>zkl(}@HHdvcg=YJZMS-DkM_xfzxSRIJz|jUhlV>mVRZE?Bb{eV z%=o>*YX#f5X-zZn~O&S1??4b%Fe zx&QZ!#=dWK_Ne*$gENkwnsNNhlF0yZq3e!S z-D>1_uaU(==3d`7HuVd0@BcL;c+QODx%2fm$G)C6w)LcmZQnmO@Q8WmgXaDBoN=8z zetyD8%yS{XVz}9dX4d~OV|@L1;r|``@%q2>{cA^luOHuh=h%GDv63mua5{HReRgkr z8B<h-cb@Ui@nqg%|8@CD7<$m1Bg1gI2GqF4jss(6>Jog_ zKJ_vPRUH*A6&rU~gO!t(_o=U~`nEjL|JtRi8sjWD>qpiw>%)*g%E@4FUC{V?`BW=Q z>zoNO+B4HI^ke4Vqh>sq{xRdX?O!VMA*D{tQeSg@r-&3gE+5~H!(TdIFWlkV#k;fl z>{FKG%b8?%=3s?u)uS zrv&Ve6s{axy=3(Cy5UiEb5#~TkH`M!N@=y_xBKQx$dkHLwXY_C7O@@uwVvEASQ%E64=3~rr1 znDzr>`A?m9{>|9n$7iNTjD4OtzW#(k$)}Bv{l#4WwS!4-8031(eE+iXxj&ou{;bXK zj-5Ym?EJ~&aX&en7KT1zu;RgkC8rI>A2~7T^AndY9|@m3*Z;%uzh{nrJ$d^-#s`0F z{{HYFg4g5b?~e_(J#Bvff*JSgXTBGX^?q@C!@0^WXGC`!Upsw#`k{kCXYH^@T)Fkg zdpkIN(fH1*=W`J9>BA_VvHg`@cJ*^Jv!{-qleRM|sp_#GF@S?G*^Co6`y?O5arioXt-^J9kw|_h1`IBM&e>6Pjh1>r#TK@C- z3AXc>^UC+no;khh8ce)wSJ%5_Jonuf%}ed9>*mq!<8O+>rP z*v!#mCr8ZR8;|YWaK1ZX;><~tqkQWiCad|qk?DEkNgo@#Icg#bX%_9==lAA5FP+z4 zZ2oHO=aoCGe&Oc%V>iD(G9}d?n~{CjjPZNt--pcjv4?xi-&2Pj95>QEc6`N}k9`xL z8V|U1B>JYg=bwzdK5a(u=o!hGGuHb~M{ds&IMgEM|4v(anQ*+4f^+d@J^m-Or6ZK6d=!UL&bb*v zC-$B*miD(}Pk%bh=q01qXOAcR>iESkji3GE#JJ~<-Tl%0_OIrBZyFh0FrWL(j@9X+ zVpB)&ba3M60(KoXc%_EvrH}OEGh(%n_YBfx-{;Id-#k~kcxIwI6GOboj7uCjd8ByS z==O}w19lSsp0UwKOy2a!kv{vxz8*Z$@r=paPTSc5ZgJO{*=^?Y)?wA#Rl}^I>SVie zr1qXc%eT&5|9)oh*7^P&GnVt`{+?H0T~Qsznqq4ZhmH0>eMo-%eV zM|#7sxGU!Mf%*E*$%Wpy!^{^Bs{G3M-xJ2V9x{ySq#471-f@$Qhb_K-(2=HIFn9m; zx$iGdCi%EwDBnKzegCm;_Wg~+@4j)qo<3jiJhuMbgP-v2w`Np-Iy$^~V%7Bq4{tsa zyU$4Tdk2sI=b+dB84rBLAow|h-tUv-2l_?*F|mrssxkjFi5kl=Z{*Y8dKMoMysKbcpY{B09k zE*=~I*zf=~`cIGCKRWtR!?zBmb}Q=VTWd8?oV6Z&lbO?TyKLe3`Fi5m(y8OUw;Q~< z)A;8-$4k$czvUUXzlMogfmRQaK~;;Cx$Te7R-?pG_?fHA&%zm8=5u2^myb`rXKWc~ ze8J4^Iir`~9H05E`TD=dm;QWybN2lH{PFQm&Q%W?|2TQZblQvqkM_FXL{Z%EJI2nx zZTI!8@m5^=5%a>QziY>*??3N5b7pYIvGY!H`O?@ft9a93*UPqlJktDwk?FJN-oHI| z`0JzdUz!-|^*_f>o;Y^k^~CxA|C;yy+34nP#-7g^Z@6^iY#$z9w1#-t*v8_l{O*T` zNBr_|hu_WO$Y`}@Nteq}8B7v}d*9Gg|S`|q0{oLKV6v5|X^?2jEwtJ_db z{xc)956s=(J9wZH`uBr8cUKA3n0a|LEZX z^S!L)Ui0(2&F}9xXl_lsI{IdO&{~AkX`Q1HZbM}&Js+I^t2FqzijkfLcyGNxb@#@D zZYPXIid4@2IBveKXZcz;YRB%8V`H7i8{Wh>&z%{bv-^AY&insz^!AF0ZLb;Kz44m7 z?V}@C^<>XnI&AFYlo|j1W?oQJT>rsc+@hVInn?cS;V_S%nDChKeH`iDyIl6D8HGM5 z&$E#`%k^Ki^WQ(*RbQSl822kXTYB=~$xn|(#lvJkFPpKvW$fsJot@Xk&m&tm6d~~M zV`kR)?XAZy?lg#fhxvN@`S%XqCI@_W^NIYg&j*Bha} zQvRQQoSjndlN!cX&sdJ0E35U`w*uL%mC1-cI~enUoke0zBCH(B3Wn9;L&geDnX%!N z-#M}*x5te9$ns|=w*J^~f&Vt1s-AYtNbp}~d>@|cyme&qn$go=3=TYZ_$IFTizC0E z8QDE)WcQ@``b%TeFQ50Qr<^_Vd(R++tn1Plh1gh!gzAa4*P}-+cNqITb8PjYJ9J>V z@ZhgJBTOdfW{Mr&q1~?(_bKjAg)mbNH$8+s95^{V#LH2h2Qg zHS+nYiFoguXm|FE>;*IOpBbL?eG^Ik%djRq>S4QF_|e<{Hb4K_v5V)=_|F*$UNy1h zE5~P!8+28>Ica=O_29IfzVEh++5AqX{-BBDaPEQQb7#)qZ<)X93SKaJMfbkD%UtQW z8JS%nR#5dWTH~?~cIdng8`+;Y_d9v+d)wW;PZ)Xer!S5!FB+_Q^H}qXW-d>f4C1j9 zFYh)C^|;}wciP@>s@2~*bNa7SV~|<=?#%hG2UFfZHn5%QjPr7CG4uGQowV;W|2}kw z)Q{X@^M4sxKJpsb#TV7DP8@mjbgbz38Ht+X@$;{BqwLzqkDBYMa@~4f5bDISdhFxq z-KUS3JL?~?>hzz-Qd>h*VZ;b^^H`nz;8+W$c=^~co^|nPPG)-9d}saXvav>4fF2<0 z{ymeVYGrGiYMx?fJ^Xc{sh?dw5|H&?Fm;8hsu#|+?R~N$>5NuACDu3bC+oa=FK#e8 zv6^<$c=g?{(dT`x(XR*wXTNp+(l^{aV|2|XP8+@5eCDbzzg>hlob#ZqiJd=VIDgo| zI|gT9{+s6Od4o}SvpMq^v-1opY}r|8=T3Zi-PrK!CRV(1uv50^I;wuH&O0?v2Z~W+ zplL~+5_f=4r|j&BUT-r$x!wGG!n_Y_s9!-9SMR{$!mQAmQ*$%d2aF70+r8(j3RsAz zf_v25lNEHrlp68JXC5r|?`E_w9bA3Z@XH^c%>1#FsXTmM-!)aJN6mV`k4|iV_Wb^( zy9oZ~!Hp|NR`!RMw?Na@!eHv1ck&h0=!3W2YkqdhjP%&CN4RqAE=t~M{PXnD$yvia zAHRD&VbI}8^Vgc(6X)+^=XYn$bxs{?zS(H$^CR!`XT11_O2o4U3w~khV^&~(eo*6Q z2Ip4I{#S<=J$si+{L$pGe>tCd^XTHz!CsZ1o-=aXNF^V>{cw6VL2hS`t;Bvv_00Ln zH;k>EJg;VetveS`?E3iVzsU89kW7_Yi&{$+O;j&)(bs%UT9+2HGU zahmo1;dZ)xoz2z!B{LZK|`i9EfRz(`xgO+lsx=pD6?MGuntI#x{W+h@UL1W8I+pNy`wu&vT@L}y zWlg`hukT-fM;&MFf2@xNcGO?feg!?n^{v(uxi>b_J`SJP^P*CSFv~Yu- z#Wiwu59^Gb!){D;h#RT^hBwAyC4^nvY<^GgUcO>lxTW5Z&dF+zxE?zFAF2&{5-Qa>|CaGfapDg1PEp-6NAWg2VXC1Q z?;_Mc4i>@p^80f~`gpT=;p9%*gxlJP(%i;9u&o0spC!}^W5M=tN)UF-a7B=dpM zqLsa`8hbrvH|o}?$}C!cc*rmVdD|l=pZl)iSdW>S(c|XtqlY6tYR4SEcYdqBf1g1& zsG{m&PR>F7w~_Z1JCA(*;MPl~uKUb+J#W4~Z*t4l8eTe{`O5KEK701=>pA1W7tSoy zGJ0kN9jQ0R!F3D9ja0MlFw(_Ij+>tzF}h$?)+2Sc*a?LTtWI2gfb}h9?W{mvzWUSk z2#S2PPp`gfht;wV9oKqrRKBwN^?4b+mwrrt_U5m?%X<9Tn4i{F9pcsp4hM9F%K|z# zgvBjHaKe{0Re4`=7*{@PbRiFV?C9XTc5LmeiOklVPaN4FHhyBI;bRj!F5bmob(TMy zc=j6;XMb+$hff^NsPpED^Zk?OXHOrks1?6rF!QZraTksBv32!{FcJq+i@3$`>D%w( zuh@I$*z$cx_eS)H;lJXI8i0QvI6r;pjLMqX!{_(kw&M=$^{lyO1^$op!?E8ZG{MFY)U~3W> z(24)S7f%`1bC>Z&^|m_lbZ;Oq7 ze2~b~3Ve6vU=oH3+uIjtzjyu0R;{e_z{9n7>|mcr>np2=-RO^<@jKfxgi)`7n{^bk zvUcyV;j*L7?5w90zTtu}%=h}^L?YkgxOPR#|LtjMH|*-9w!U9~S^cGAtMP}EYFB!` zRhaaL%Q@F6E%4Lt#X=pS`Wd~a9=rPDd1D>TbuJgdcxJtYEZ@9z7RTY`eL4Zu%Y1jR z_sa=&UmVYBw@z#6bt~)H{?g2=SjNXz-(~&KN$y~W! z_Sw~+jWwIC+2|8BUOkxg&pV|~_jb96h$+_~WjZFcD%G4zJC3&`lL zFv^$GSv#`hKX5o%*4L2MprVf0_SyKioU6E64<}wmp3N6Sq4O}jm0K&EI)}4nbLRnM z2Ror>{V7&4$ui3}b8N}I>`)*P_R3n@JE#(?Q`TxP22;I8KX&KIw10#Y`i!1W`q59z zugMYTRb%5L=C7KpUPE`Rg4K7nXMOO_BovdZ(u&5e?T=XEX|U$NF3f_yn~(pQhu`^= z?wb)?&L@p&T`MMQoL$S@$t_Rtb?pS|6FOAe+rf^^tEY=BD>ho%ki{F9pR)tp5N%=o)&d!X$CkWsXE%edEj+2|MN z^RUsnfAxR&GxlNw*|#6p{PHt69Y<8FfZu9{Y{tF)b*&`V`B<*y|E(p;V(LKd#A%kv zPF($y6Sq7swzYq#WIWkb)E{JcGizN-`az}LvE{S5V$>w`{y$uh25W~ z21K#7T!77V{R7YO`)gxBJ@@3plgYvNR+P+n`CXFd@BEAW$~XKU=8*}%>r@U`; z_&)z(2XTwMuUxe_(fVKeIm?vA#75A*1M**ZQtv-pbr0Cu8AjnYYhVw{FS1pmSbGTk ze$7P=Ywv7vYwf8x*dLY@5B6=*$=WXo19X)5JPE>9cdf6UK8v(u>No6b$u)a2lKSE8 zS%8m?n$6_7P%(e;`!q=sd|}zX$hYc%?(TlAslk`9qP-9>P~D?7wsykg4`x6n;()b? zwRecj?QMX5`BgSpPF^3s&(LFEX#uXXO*IAgusuT92(1mkr`0`?!an$yS6m{Z)cJpAp?cr{(4E|LNZ7tIH+lRTB8Ftd1 zY3Dn%&Qa}^^gFp{M&Y1H74)CL7$j-_}yuVnO53(#AKaS*oe!F54 zJkGm2`-hFNl5ia(5&w-;9EA_+8eW|i>s)Jf?87E*w>K5vwi@VPcHdc~tjA9vXXxMT z!y7iD4#FPWyPM8>FAG0dXDo)8F9dB&eU_if6xcWZN^{w~*(}?)=e?bhuHGF&Lgc-`Vs>4>kp zVu+w`0NR$v6j!tTos zXKrkB`64TD9qTjB!?ic0H7Wj4+~L1zm?X<(_)S=ztrWF*dGVtC=0?h{L>hH6|B5ZF zqH_%KR!E;;vQ;`=oG;zmyR9QgPg3#sz>nK6j_X0CVng^#AIZSjJJYMZLt#1FTe=t9 z#JF-S{u7czX#2DICf_%{cx?48cERe3S2QS|6y>@ecFuPcj;c#7B|F0v65b6DRf`nK&E8QQo~YrF-D^)Cu67CzZ#wRB<`^nNMBs? z%(*PBGeXF@Q~csic|6Q@zHxmF=0fgqXp+WFoUSGA@<;1kGJ%)~P8lp%-VUhR+<#}RxZ|jhr_4?@@GOv8r zT67%^bfdl*#*k`O>e{$6d+^eehY71u&}rySpG6Wr3TP=(t+-U&fO}4tG5;jJ z@H!u<6D{v@@>i!@$ZvG3;k9Ap;@CW0%u6RMq*WH|wz$!C5Ap@`YX3XFvT(7SgN(_R zJ`Ye&R<`tBF2xdJOSB)Cq?u)#w7fDqs8+p9T<<v@?pN~i3t@wV1#)FkMhVU##f?TMxq7j&=Uj;e+(3!SUQKb?n*bC{zsK@WSXR4n0( zzbtme=+0rz^NTyQ?6a=VzQ~4ezzLDk|H-AVD`toAVzk~0r@32a)@M>SY(=6hjwj(d zY=MWt<<27s<<&~c14Bm70)Ped)d|s9K2I`NJc;h|T|Y1Sx4z^2#c+w#)lrL4EXj@o z{s0%$1x1U_nxb!#b5bLHRfFcEd={pNDeTi2%)q%G>pYxt?R=2!xIUjSS|b&)T~kfF z2uYf1Ts?>IYiFK3oqfOuHmw4hf8iK#qctwt3rWjoSWdjb{qe(|(}d&Dz*@(GHf&lH z%quVpyo_8(dsWS$D$ftMmfp-KF6nMiuCsyIS$liQI}V?ngb~eWMNvMM%*~fXVKN5a z`6Tp?Z;ArE{-0*${6oV@UDw`WXWN*WJUZsFGI`!YiaoE3XgxhTx=j3{T0&}`?w zIISSwWKCfCc(G9&57Y4YG>%&}w&DOQW53-aln`6}KdkG_K6%v|N!+z+W9vo52iI~X zQm6B^_dSo}yL29g@NXDQ25`fEF4BfGi${=0r`3ofyN+u% zC*HDhGc&gqBc8-7>0(J1-a$jyXXfz=`pf>p5Z73BS#v$8l(7BS8Y`=Y{1*=h8`vY+ z^J$;pBR3pAptpsrvI)LJnsA52mRz#pFhKlPzpF}WO{AO`3Z~%|D`KKa9V@1fEZe`a zKljN~%8O{MwJXsz?W`U^TA(?|S^X)VQ??3IR&_?+K(03)P03a1R7A741Iim~ai4AT zkaEnbfmOm5p2k1qJoOT+XYKSfHx|`7Zk^>vW~)Zv=X663(3Wk8vZP(E%?F&vS-!I> z$L3R9U~RA{%Mv~5wR6yVJ~Y2H6LE@0=ve$ALlRKaSUoj+)xAd5I? zs17l$HFkD%e7*I-aJISw8}M0sxjJ{Pt|$4rxDrOtf*8zBTVslC(Fuesy6M4!TV>PE zbHu83dmlcpuN&W?TbPA+v9_?4w8Oxvb5%`U6~m$zv-G!oC+_cA1Vv!@YCnluW6zg_ zT*l8fjMwrxr~%zQ^S zS*`2G-bgCnFOO!g{(q2zi!so!IL%ja2(<}vD^8OI4=hLZGw+~LBa3shD;%mGbXAc4JH_NPIbFQg>(-=u<;mv$-zBhl8Dh7pQFmB;9-7eXR?`Dwq z(~DW)HV1mDO3Z6W()D}(ph~fo!lUP}s*0UAUo$f!*)WwAvg@7(A!=j&`I)PRpPkF> z|9l-*@D6`M3G6He#g5qY>Vv?tMFL!1JX4!siCHWhldtfl_$X||SXzUqUQmQDZ<9Zg z9UFsw;%GKT-s<2*DgHpN^sN%FZ<-B<89nIoKK2K*g!TNr#Vy>+ z-Q33uvW3&t$c=Gfifmpy)kmx50m(ygyvZ!!aoEyXR-IX8uYwaTK0WUysp90SQDu{A zdd_8Zo*ONAkJ=%NF58sEtlT~qBsw(B?8E{tI7P(%e+ zbc2UVfrjYs*+8i9L~Sx-@JUrq7%;PZm34G>C)XqcIh7pMeac1S;`DQE?p-v>*Q=$lj`9xdwvH12KVbHL&wi{T ziaH{aNKp+VA2&0r6Y6{iSkgKwow0|7?IBN@oTy9}F+n5sa?O0-It|ZP2jds<(0FG) zxK=ROrd*Uf;BA;7C+fT;qbO&U2lPI;E{?=5{2sy|RIlNcbs(MNooyuF%(GM~<0En* zcnM<Vja!H zL7vZVbQ{BTXCTY**gxOG^Raev)X!m;g-o-oJysWH#IIOqS+_f^3RZoNMjUR24eYKu zAy9<)lCdLS1odKj?j#S?jU4w6_PK8&a$l%S3O>9bfV;{3pew%-rqX?7|8Aq z-T4eFVK*!_dEhPl<6mZ+5JjBq84z|qI!j4CLr&0IZcL2*$7|#dRyfSS8jDe5;qJgb z7b4?B_)h0w7*yPVP2v8rsVW5|Z2Yj*Sq=D^{RHjlx#^6k6&7>JO5h&5j{Es8U+1ZQ z7gt|7QF$4Ti*t)>tYz6R>!nE+>G?$=oOi6OEo;mFp;I}QIm21GL$Bp|;!ie8!q#fZ z3h#;|t*2C`Gd4+{<(<${p4oGL^+{9*73cT>JXEQ&tKZ(t))C-*>mT@&D6;&+SGo{; z_-$Fxswew7X~j)o6F%gLnXN;!_O*7z3rH?MDXzvQl_9ok5_@Br6A+qY3 zvqkKOwfD5M2zm}&IYB&DzlD9Rt#}nDTH|xRc&it994{-YEUH%LY39XVQH$5f;NS?n z7q|FZKP|6Fk1IPX%E8$B3gkD{J;FZ~nDigZ!gR~&e1d(J4a~>pJL}IZt2+M5N6If( z42$_>e|b=N-P2pFyX1r76i;5cwj8f#^>|Ml7XG*|?h?-`&WZ*4*_WSWHF+(}uMTSb z>+1DF@^zn~y)=0B&W^K#vH_B>7c-t%-D~k`{=%-z9SbndVsP3EofdMCq5K(I$$#ZO ze#bVdU&_&wAFnBf<8&-h4$Z&Sr98a@J|!D=ZM3ix##hnmEM8Sw^I7>mHl)^IKM@Wg zUyHSeK9G!*SGC=<+(R? zz^gVj3mPx8Df08TbX@iQ;7Q9Y#Qe!hJ@AmZ0-05_C~Al}{5RfO20=5i%i>LyAd)4s zI2s$qF0f&T&vjq60cs z&lRV6ps~OOYxbD2f5lapSA7xtY@A7r9K=kLw0;wJEBd->xnWonPxR?>DZ{N=9-!lOJ!%hhn$Rn#`V+rX<4G5(jy6&w|Lo^U1rCRs{t+iw@O{c z&U1|y&dc852u3WqIS>0iFnI#2#=S84et+p3bzn$_*9 z?echWQ69QD%fd&#UH-Zl77Kt&Bx?M$#Zwvs9gAi00yVr zDr^TfTBSU8BroPx8=AilnN6I%^>yjxuOH`~CHL*~=h-xNPCP{!7l%E(`_Qd1Znzf*%3)15m ztw*R488^N8O!8EPkUbVlLrJk%-;%lo3=vbY)`NUeTyib<3ab|H<1JO1#QD`d;BI7; zmW*0WqO8U`aKV6YVj)`Z&uJTMc2=mKGyTh{b z^uk|RZk0HB5e&?plT0~>`|>Q_LVsjO@^x927sd8i3<;7xjrlHiT`h~fm1V}N>ONuX zWLAwco-ez=pmeo4k)-ZEXq}%On9E#uR|8lmjytZ+&IrzVF3o`xMiTiTM zo)?K_(R=j-b8CF*o;Bb+e2FcPw)@5)7rr0hxA8+W+qKbe)ssgtDPj*<#s!)pG z{Ge#HtX#~8lHuE0#jX#Rc36dzV?0!?OqET zR_$HP>6M@A=MoQ!Y_6;N?vCsfs*~{YbK|8Y_pSP1Hq{eIiocW>qzgPD+fC;)$em8& z7V#sIl21Z@62$9$#TYy*knO24LwuhmiI9m0R`KJ1^*D(zI^;zK6*zoSp6>KJeA7-P zRzu2s!I&|MB%0L1MO+^aRflPp3s2DFM*9A?#wwnO(5@_cx*lW`A=GW?x~ywqZ=3`| zlmohlydhjFKa?Y2nyT;41EeR{6&FdLg|G`VkhQW&>k1H~vB_iGn-l*gqqv>V(^SaT zQ&&Bii1ZhVhQo39*duQ)b`;ZR@H>yrhv}qzK#j{D1(JZytjX6nCm;8RCi!}KP5Z@p z0QSAsAYel|476~6womq9Hlz#F^8|OugUb-fh&81Xs0fqtSfht>M#iGyz8Ye_FTz<* zuy3Vj5#vE(qOm~_dN8&F@1u`Ubn!ZKWB)8Rj>)gO*UAsWYGZ7r9iy%`qEg!0rdfyl z#*9B&rLX&=d=mSKi?Sv9fgQYcajR+oW+CcBT8lRdmI4Y z6czo{49H&{49XW(-2WhdpwBSHwYKEYgYW+BI=d_VyabodU9%y{7k?kyeDMG7lt~H3P4FbB~wfCIlL$0H@*wbLGRmK&& zF4>SP>x+3}8T_|%Rmr=0WW9$x%c_o=gWu(iEHds7Mad)1l-;mkxdOag*b0$ZpliqV zVTiNtJ&zg^Th}l$bAStKba9X@hE!ZF`!$Qsxe=}Nnf$_i*`(0%)V}Z*8gx0pJB5s&luC!ulav_99WPkM2`u9?l{Gx(I9#xOC)D;}9EcFor1(e}|} zAFGm49?FibrRf-8|3z7O1Noa-JzC}W-p&7T75J?-M8hi%!0~#Z*n+bIkV=l5;r zXLg%^`MflUlc6+`&eaRVuWYNeV=3-ki zB=yB)Ly~0#d2c;JxOH_;GXoxPZ!pa7j0YL$GTwDVq)-|){T%2s*CZHVota( zHm-avZw>=-P_lzFcxP4Xg@Eos?&Up3&IZUIgQJ^l(m2EcypI31(V)@p}YWPy_V|6401MPmNxivB@XvKU{NoPYns;m_js4l_| zvu|`sgFnL=^(-|&If&o;`Rc3pyzcd66>$PLk=d4yifRYEN`!08#5K!his7yYHQ;d> zt$8lr7tQz_v`mV|-Rf{`zE!t+Pn=T!v6*N0aB`UUs5Dje$NltkSMlo}#ZI>4+!XaJ zCs$uFb_~TmV|`U7@q_pU%V0k;Aa#?@lebe5Hz+ppxpPNr(!Npo@c?h;v{b_e}of8+G;y4 zn%)=A6*F0+&P|9F2V-yS3bHKRA`?F&9nyuUp(uOyJ3OG;iZO|&GW}}(@t1s_F3HFH zy;DqQ1zzhrm~oxmY1eG9`gD=RXTPw+NfJp@*WYn-E7&}aWM-gaYx%otmiLl|GfR25 z>ty3NOck(d;bEbQiKiwwKT{oG#l_?d6;>RV7uXFg9_c9J7vahNTvvC;Kh5Xi2b2z7 zS>lS{aVt`gWArpPu@1}Rzqo;~tNYOWgFof*=Dc3vT z!0d(Y%5AFI!m^lp@1w(d&Q_m7vTh#P1?+$^VvYTOH`-Zhs4ly1G~z8jATSeUi=sW~iu0_|Bpls8JUs_vcN!vAug z^n)>l)V$3+ic{Hdc^&C`;VRIhS2=j~v4dKY_0vNK>Fw^&IoHlCSFU@joY|TK-cW6c ze4&yrbHPZbDaaueilpH*1s&$5~Wa z8SSZVt}|S`zYGdqRDCE1Bm>BXWx%GmMYYUqf(7w9e1@%yl;sw&hZWP*-AIpavKF=? z=3M)^6XBUS%&y8@Xi+qR$et-7X277E%qx_@qrLcpn#jM+on#N57~$-BK2Uvx#jkub zURA7-L9qjQM7bM#_3mUW4#kJnDtS`X7;>QxSM7RhU2yF)WpDi0wP*kjG~VixY(3sj zhN_ns2W#+7U)`4^@D(dcGS%{R9_YTT6tcoDGK!-vpEdsWYO&LJyeo^J<_LeGt^CV% zt8&9Y`-k9%C{;}LDPGn&J9rx2Ze2!v%nxO!p5@f}%h}%kJcSYxyPNeeej)C;hx)ww zl!)Ly>cDa@l82@|i8NpiyQnTICgC$>9e4#fiR`?BEZA&y5ZsG=ip3+2`K;=9`;MWn zs9;=iXZTc2u+BE@)x29jsRqbf;bDl$_QcF^_#g(j7wppW@`jsrFfBf zt-Qw^H76*szSu87CWyxalp_Pj))Q28C&_+k#TZlE39Q@5#?n3{TVtbjTEULvVUw*=k{Iist>9%kBP@)m(R^0YPCPE)4h530q^2#kBH9Qe0~s zERK%E`Gt03N!9yemwT>!hW_#R^%N-DhY3bS=U9TyKAw%QRHt^o1D)m{)kNVFzbEr} zn)#9(&vQL^Q|C`7L4@7?rufT`R|Ijre1m0GU&(*gUP0YnJ=YzRfloXpZy_x#ir>;E z##`6q=Vq2M7Wy$l_=ct6XLug3W0hX?-QKiT3q8LGa?5XwcA+r)^~apcgk$rxNgLU= zS;7aoExvAqdTH@GYf)=GDIRX@<}C+f5lN8_8@K(!tlUbO44s|Fv5nh2j1TIN03U?J zIGk~ir5J}vLf~~GmT18G>Sr-NG2W_aJ^N%_Eagw3Oa4oi#<}=lT)MiLJDMMCytTus-DWONTCt) zjqDEIEsLlQqV~6@R)rVFIl-}r+Tj_=_l!XG0e69 zLT@tPv+udQto?Ivbmg9_=34#6>OI_Fyt!CqUa*@j;uPXMdowGMNGxt89QUcmj>X_7 ze41>Mz43c*{Zw>m{$vPyajYUvbs|<9PE=ov;hQ%!Z{?S5&@r58Edj<>k1qkJZvgc4Y3nCV7RDY>&P| z%(81bl0V`itz7F#>;3SrIGrujOG3Y_J)5DvptM0*~;#Xp%YLS!MdPXSjh8wU5S-h$) zcGfF}nI@JY|E^Mt%Vk~S|O_s)2Z$!KcCY6EatMseh z2_rfW3H}(3cajyKf%Pn3%qyOWu%4!M^?Zd3#>f(3COxZ#@K@DzKJB-Bn*Xz=WwU(8 ze(_a#_Zxh#E*IHWwuO0?S%*TdW;|lKoqJ_rY)0h+#;Yh~lYG%?j(%d&&koa5IiAt5 zZ8imIlbzTqs;^vp%%;RbQH@-)^zx_0eR00(p4m2;Tsz05|4@~_ z+E)hq!<#T#pQUF(;-J-d{gz(w_m%C08{(@ya#$2u$yQ`QqCuPlrmr&ynqAl$+hJAg z3&!{@eoG%l#J?e9d_Y7DJ=GIe9^g*a#oR3>v?^(`{E%PuqOL&k42mx+G6$n;{g$$_m3?xilbEP~yW zqYP#BYRL20w>kS;?cTfKFiy58oUVQKEVB+SE#O!Vm;E7p?mvXt)YlLz^iQ73CQ zP6J}Ys?fr=FV1Z0H6m+cfGn7Cerje*vu2kL8ySoguZ_VU{>KKz4{Il?{l2e;)Lda> zBh4PGV(7l-zml^X{zC%W?1C7NKKN0)G7?@@rjWbRRHS}oXzJA`H@@+Ph zoY@(hb=pgQ+zB=DlAsN(&ptzkM2R7h&v^!SZfbb2dP%Z%7FvI^xW4pdzS&O^x_aPe=h}2fHg+VyO}dadl)JH2y5etQvKQI7 zw#epQtTSdiZ=645W(|=KkeB>ZFRQNAcq%D$9k$eS=C2%Cs49Dfs^)C1Wpx6HI#ulX zn-_htO4(oi3|Nj&sNU3h%I{p$J=qNVE)K@^afN!TjfIR@j8~R~{~CYwD0;u%WmZYN}7E ztMC?cU3Kudv+L4_8clU8euLYGydoZ4v*Mu_FukX*x>lFp6+h&UGz$mt|2P=y5{)5_ zeci?b$vR&n3pCnZR#VEPvWGZlv8frm3%@mb*JX?BO+@MERX0S6dO}zwW?GG!AMMW= z#0OlU%t)`4KBh117zUYSQNGfMS*f1lh5pdFI=P=hrtCO=%(i4sE5i664Yf7_K zN;$cR!MF6b*i&UrY=gB`A*u=#Z!GgD-^3T#m-~`Yxu+;(_d@5?yBZrZZq{hul-a~% z)@MjCTVk7P8mk{JyH6T$SbUU!!D?{?gDG=#2kV-}*qDl#A3HQB<4i{6!vphxJfXFj z>NR1w-|{|ILJP?W4*J6@Asvi>J)&%^FA1tnWG#N9n*230Y7xb#yhL@~xuk;0vNYy00x3d>oV`B069en63 z>zCoXzxo%gu#{|&wSR2-Up!sK-cmMr$jq=OYVKukst-z9i;c zgZ0cW@`Zxl=UJ$AVn7i8=L0e$T|sb5RZ7iAH(nz$0y1EM_-o^+ysq8NwNPj5t!nu3A)H-Lux!60MVn zW;$@{lVLwBnS>jwStn~!lR@(%8Jy@*EGJ{HmDSQJM24nb3*F;At}QEdmWRGx*1BF_ z9*y%w9`ec2JS6fId$}d+Z(SbVra|)xMHXX~v8!a{Z|dp!uay$GSIl9pc>1dMdzz(d zlBM{Exz>*)cCkpK7P-udj`+s4V>tBknX9j{o3;AS>Wl8;3SO2aiAS`VWz{3t?&`Jf z2MxqpQdOo*abV5ED!9hO~8-hc{4h&6o&g?~&wL0nEa=2ozbK}~zP1i*Sb-ebPgjVtt zI>2QhyL0O4L2bVMg!Z30XN}Z9KbGh$Fg-cyrlN=5!7B!xd%kwPAL@+ktd*U5Sm8&f zqKlU|-Q0XmuXBFg(es_Bf%1Lty#8n(&cpIAkG!tjd8@vQ5A1rI-?#nX{7i3&y!eB90`E32^Ak}QU!l`-96t|-csq%*2GXSyziU-f4F@XOhuhxYw5yY; zn8|$PvNVoUun|1X+~_7;g*D}u7}JUYI2wE>3w8Y?M(!uh>xB7w{57v*NAFe<>}iH) zd=O{zx^g7`{%c~FC**x#d+GcieyW<+6;U@88xxIZK=TKiG3Ne{1<+1)UiNRc?3%2h zftVs%tKl6!vSbnU7MG*22OK6_=4*AH(KJ->dvT#G7_x_h2a!gEX{Cd8iZUtzWZv2+ zE2szCx)Uw|F?b^E3R8<(Yi%ZrgTU_U1(if|x{9ZWQ(hk*iP_6g9f#KKu~p;52|hD( z!^&}mVrljGgR7R;yFS~jKY(YuOJkHHu^C-vM~+|7=aKXD41RX}PUk1i_s8via^mJz z^Aq~N)#kRFThGsqoELvQbUxo7^0Y#5)pW04GFrcEd*Rsbxnslsuzlma-n>0$d-nFV z+qZ1rJr@0rd0jfza@7tYbZTEQwi0iXS;#E$DxPxmSl=mg-`maW_Vc>k{O{JAQ#W_q z+-3frJfndNaHt&tht9lMZ?!;m(9W}DpLq|vsD8yRqzzvGp>{8b^Lgj2&sa{`_@^|n26qyDm|jPoK-e+ z#k{T@30^#-zhJQI;?ej!XMC5;_i*jq^YioPC;vEed-rY!if(U~8vEyIEZIIyeZScm zoKc|^5qN!30CSHMwk}it+#0{Skg9vTX;hHB(V~-DWh|0C(vEw^In{Ek@UsLbJBStPaU|Ghst#IfRxx#k z%X&VW{2!*#bNo>(anIIg!mhoVz?7t^&_&CVv9Y_*a9oS+u|rhXmysU%&Gqc~t9M?&Y`f z0QyfK@m7(`%8y);Zy1Mp$nwJadavSc;8&4Sm#_ z_zi69tZRN%y^goYJy|E2{L9SuBlB|Vt;qG^?fVDY-nm1(iw4`?Jh=Q1gWK;K+>^`W zq3v(=8BY$b(kRcq&RiF+CG+eyeVj0H=T`_Uu()nJLyLiU=uKD*pGt$>j zBzeQU{%#`6tGBP3*Vz-XjUQTzF4kA8gR(Ai2{qV~yRjve5EkVtrc1`K65qY)NZPn) zz|KAA0>GYXYZVusyLY5 z%6olR+)*WQg}qI=P$>A>xi==!*x0A_FZl)=#+KEi%>1y4@+Xb=95Pp^&R9Qp)uBV? z3g*D~VIn@E*0^f>yvK7ejP*nFuRVb8pYNQpYG1eaW7q5kjD$TCc`FN2 z1HeMnaIDVMI|LDEQN)0<{9nY8bK^tUDqIy;*+8>0XEPT`^tQmW`ro}9W2aMb8xptf zWEI`Gt1<4+oy<0l?fq)`t!>Ke)OqMl1TiPIfb6(l5UiwXi#kYsFx81@iJXo1keTbz zGjEx%T7s-ztVm{b)F_-sl{bWqJ{^vibI^TE$%uT$xOm{T<>K1)hEio-FF>Vh#I zNaI`@NCRtNVC%%zL5#a|X=6lWSzVbQr8DDBpLA7+#I@_yxPzI9QpUC764{B8`D7eV zoHHBsax>sj)q1d!GE{xTDy1wouI9Qd)hAcZo>gR7<*V!=`yp>~!c<}=(5%%h+UGGm zhvyp+U0u5dg~u(dg-hk!<;wUjzg@KtoX%Wgd|eA8@AqFGc{xLr{M3A8b(c@vyI|ts zxf2QBIvLD)6HVSY-Kf?BpTyk~w*uKEJ)w;2hMGS)Du>D3XgfU$^rYR@6DG;fozPm(AY~&ENOV2;^38 zo4*(Auomtb_xmRvUO3}EXY#FA&4}MVqy5ME|GVes>M$Q1l=}3H*;8h(nD6VgwU#HN zc9N;rQ4-)iP}`-$DB%^YvD`>pf1I|H@nePLPbUOX(b zDZgsfrur2xtj14g^?Y2ti+AsvaeiPYTbL?td}#jvf%%>P%V*#lM#wWl>+Dw+M$@bI z*V=Mf9{Y#pkiyE3Oc(mze8(CO-;LkN3^7alD2^C8c7u!v`^MJ#cv~k?EZvotqfX)DL=A$pi|6>y-~^6@Fe^n=ENeqay+w~3Vy)b zc=T0cSt@5vXV6`s9`ND0o?4y?Zrz@82%cZA!B^SLI&Y9495uQ*X6APCzt1a;9s2Kh zT@+chYFwIE!z}rUI@A?2iVMaA&KpmD*LZ;Hs?n4oI_;e0w?7ECCn@tRH;L_wU+Q%@ zzxu7ZTI&rr9u0_T$IM9AIr}itr^`3t(#l+5U-d~|k!{LySr=TzP^=`C>%>W}nz4R( z^d9&A)XWQBw%?0A72E1|R1;!{?FYvN*rBXETapdbOPuZC*>(D=fwLv&1RXQ4!$#+1 zX|(c4HYgXw3d&K+!Q!x_S2a(4Dy_1J=4}kCdWye>2{ ze6Kcm{7%2^lbTD-^+d`8u4GP~146Rq<)zw*L8=(zz)mK)c!$InjP)72s^Z1-FBH3a zuE^F^!aY+)rXlOV0YnczOba~^kbNCLBbL|7M(WGfEd#08WM}&Kyn^ySx|27`$zoZw z5Qo##a`hl8mR^-khG*m=Uat!$W0E<&cj5$2tfI-P>5eSb{^dfrt*HMoS?Ng-p9_&z;)xiRf_nBooCfSV}sScTYu1dw=(^(jabQXS}ijde$Pi&|6yymYG&1~ow6uisK3&6l{hse^&OE%>~V&#jG(i(eC2D^i*RkR zBYeI7Xzu9IqsS_1o-mkk)b4fDk!ckTYg9eA=O!~&|7(mQSPWlpi8bA{b6&38$Hb$MBt;sdvz@!V?0Rm}JG7GqcG*t!KC?yGDG7C5f~ z#a3LwLkJ| zH6eOh>qGpU)vePZ;B5S|`bzu#dtQ)S$=db8i&hy_!mQ7*y*O#l(biin8e$w+upBDP zZLc2OwkKA+vf={MWN&NVxs|pxhZxV|2cZ>fFJm;`@_Lz-oZXHKHOZJQtFoH9Sgp8R z2f>nxcVIcKniL1ib$A{9S2N~sbQ%v6OU%q#LTeY$LsY5`N*-Q5UoF9W+zE#9GSSN) z8f~B87iYx_HkbuZmL)=bs|s>Ov9uL%vT8=+fBB5~$If_ixvl${c@dhNS||M1(F`p3 z+*ku%{JvqkZ<)%~dBc0povP5=#y{|4{WMsU>i?l*_qQ7c{*cXCn@4UQG5h+d9YF=Uq@9 z)AlT>j|?)XL&W~9d8(7eIPtaH%=*u1Q~gp2`-b`63elbCfA^lhr_E39IzPMhAckk% zRDUV+b$)AShViybW@P8j-QPHMuUF4_jP3O^PPMO#X6$x>u!!|6wG(&TUES^UdEISS zX*qF5bL`Cbx}yzD6Le2Hv@k$(yvx>SW&d+d4-n00CD5V$V!#j+*Z0^MeA@O4We(z^&#Y>%o zO|l^#8s=1Yf`}`JjT7K+#U{ummWsdD6(EU17oi46+U>q`tDSCKP@L?n6 z`L1a=3A~lr*Qqp72-&D`qF<9-Q{&&(^wH_TMUmkhD zVrWx69p}c5XoXK!dybD3;l=o{uFRX{AcPv1nqDgwuHu;<*4!bJ%t&{l`it|$J~+Qo z*L3c)nwnKC>XlR&(?$N&d)k?WBX1yny)eFG+ksh$2znk=6EnL+g$BV!4= z_pmWhv!2a3w_YNQRQAOV)#T{9ImKM$8F*dnz4e)T7RVN_Q_ol1=b3UqzKv7XH=*Ba z{e<7fV0?$Sk!QY0gL-9>rS+St;4F&Y@Cf~4@&*=Qbn?VSBDSiltRSj8$E#4#n1n(vx?!T9t>fyy}*9i#a3B zs9_FHB{rIUIjhc=Dmr?PZ?;3+qX%cLX6QVFVTaCK?P)k-UiNW83YnE`GJdB*)H#dd zS=?@A_U2cP<`ejFy=$#yrjIoujNb`J?#W)OTbw)<3zengXH>dB>-U8Rya5J=2(mgH zp(+&&QF~>Voe94>+*pYkLlsw50SqRja()~P)xY(T87)L-b5MD4BhvF~^-a89^;UJ^ zkifc(Ot0M3y1&&MoJQ_ybp(FUcXju;lUxScn3-x!t2Sm;P1sqBNyZxH@uLr&wXMU@ zBn~O>@DuaSPT8-WPDz=pyvm%b;;03OUdCfajk3rRxAK|%4Zh)AW(otV0FydNurxUB z*(0*gy3N+pI9o;XJQB~83a<^PN!rz6Sx3rahD8F>3zu zR`#Ml#OO&4-)wgKgTiK~DcrZUqwGP!~`(ZsT@p7E-dJ|8bABvm9LkLC= zWC^#{Dc3Q~#!;_zYXfwd--rRcG>fa(vbeyqs(_F~D=66zeWxw6GA}WOwH@r$r;qJc z-Yvi4!Fh3OfA9eI!V-K1k7Wg_leDD+V`t(j3@E8Y# z8qLi3TBE9ipBG^UqANX$PF1kz(VSejJf8m)wTi&SPd;G`)lAZ3?58}8UEuXBL?%cc zd5!DF4XihIH9pwdR(T6~)Dgg^vY9vm%%b5&XQmKV?Vyad{nlbhIEKruYtb*66ahmX zC?IBK6Rie_pPeBgX7N0+3`>J-^=q{sUF|^)Law66f?x0!pOU}(IUB^|!xfexGSmrX zl4-B_0o{;QydyZ`^31GnpJHF4;=yQqBAxifq31slaYd+n@-t=`?nyE1QxB&{b0(ekm52;jNim$S9z4S| zAErm_U!1WT&gXp!Zb7XqaM_LC2)(4uGHznLESXKzXN1#`8e7j>{2n^Q%8O#v`KvIL zUv&-q-fPUeEYqu_&-{fzd`#8TIn{7Rpt(&_{0l&jA ztg)-ti6+e~L*{znx6c370v)KB@DUKC&CJL(DG%s0$PW z>A-n_K7SBjy-x-UJKQ7emxJJo{2Nx2gIFAE^iJQc8k`x!oxavj!p7-R4XZU8xR`EN zjlSoywg#|pB;W9KS*z%<8}_!pHanLo;D7GVVsA7!anvw?dMVqJ6>ouIR_oMgU=U<$ zzZ;udJb<)mo=tY%zt{ui%o?`Qmi4{rCdIvjK3Nf(Jyk!-4&lQ3*;)fJ2GVs^_KJsj z7aoH*yT=XY=W7LDZcYbca@j7shQE9h5{Oo7MPbxGF^#lW)gRvH5k++4DApE_MEh#0 zVkd8NWpP6oPI4s4s2W%Mg?>lYNjz8?i z6^jS3n4H|dimk2=>i|~F$jfS7C&;oX^&5Og#jpMA{lw4smvc?67^>XW!t4>-x#D%hDI>6hZZGBzh0&R*VEJ(bdJ2=Uft$$mi_8yfvpJRFM zh5s*X69;IArL-0%|7}mASa031y%K6z@m|(tc4=qXO?^k<11vT^{8xV>o!Rl-9-!5? ztvc5VnD-?E7VLYT)pIsgMdd?uBdb*@v`%->^P=LU=EP3Siww*uO*^~R2*`~llVi1z zIiC zTsTg3qjV={ufAJ8TpmnUFq*vO&>}j$taaw{q51XP%UW1xuJj%@$y2XC`c?midVJPv z@g&zJDOU5b(H`!pcUc8Xz5!QB9Xc0lpf0cS)Ifb6exDV&Ryn_X5AGDX)OFVi8u=Ox z4IG>)N)F{kF&6d-rOL_8LqGGOV;}k)+dpe>LVUDpL{Wxz;2j>D)ssc5%5iRYh9RDe zvpAusNS9>5cCF!gqKrM5`Z7N;pAolvQet~2t$yHQMgI6BJ1Yiv3cx?lys%83hig~o zlM~Qbf1t#*bE5cD{nthabF;!`K`J6onJPTNH`rqlNF)g>L@Jtt+xq^+L)S9q&dXZ* z#oI+A{0i1#5~4orz*}IeyeChWD~Lqyv?2iBzib8aWvRu6*a$3fpT&9MM_jr3AN~L< zaL3h02}_%)xV-ZGtS3w?H<6vh=AGz8k2oM^d4QSljIOG`#xU>`=;~T^*Yvq6bL7RZ z%h}3^Ni(Lre44LYQRB~aUrwM3pifKPP7htrcZ@@^=W3(*BD^W9r>`(MjjOpIveSX+ z%eutvJ}chDXGAd`mt9qR!ad?G`blWLnV5Yu<(+nQq!+)XXSxVMHEOLD)6&* z1=3A%LjI7PyKfuBl>99un65AKsB$Oy&h>ygd60wfU+t7<_wIuQ$TGMe+9 zSzCi}svq{5pT{)S@Oc8OkEO<0Se;BoUPH?9$-Yuc}&p zW`9@vFp3vNOZpJ=>A&b(tSi^5moo{uul+>o3t79E%SND47~op6IIN*M+JS6(mwSXF ze8vl+nLoc;Ze_XDpb$aTmOZB>R8$*fO=cB+{>%LbVp}7lB2sgSuLy=7nOI)lsol zjl4{Yjj#^d$Y!xl*DzOqi)!ZfN_*503kTTZkxBNT3led{H8H?ihj985qKu37$PS#amJABmhe#oHUG4ncX=Fbv} zC$WauQg&6IQZGc+DO#%ku=OM?lbx?P?Vc>Hd`@0jcb7g^IiXG>r=a-U!MfGT?%*Gk z>)&{%>Neidt}U|doRu`Mu`_(XcP~yQqS6anHxFMIx~83;XB#JCjeMDO_) zR~0~4hX6ij=4$LJknEuK7yT4jktHrFy%RREe3rQ!)O{lz8P zOUh@=6@nO(+;r^#!9)FqhUwO|RvcNiJT_kqu)SsEXx!Bds|t}``BZX|-{Q?;R1u1H zc7nb}&Rvr<;tMb>d!l1qI8L{fGlhVQJ%$tc4*6i$;e9rVb%&0!DIGkE$BL#T;0m-> zr*HcX#0R)aUu!>)E4dcW#{l>{%QO#`Bo4OD3C~!q--xi78!3u}>N>56#%{3%c!v+? z@6P-zXXTS-QBE2=hn&Ze#Pq@QZ!R-bJIXzz<@u z@dh$%rIDXlGp+AT-EHObMyv(`h544d8XG&~wQ>-=7MK_?+8%gOg$-^(>)gH=#h z2O23>Z!6kBKpMm=S1iOkT2I2ByN-K_ZAJx8iQ zFQqX*Uu>!vprY!E7%k0`j{PY9U=zN>zOs(&LuIwyb=A9Fzuok*2~v@Z%8bjwR^-Dk z%jeS*6me3%wX;q}EYGBMc0zmZA6G7$Vrgu~JG`fVv+z!n6Q|2(-~=0Eeh^xD6F}OVJAV*M#^gNDEriZIxa=8#*!0vchbysmkpRFrk-&RUOe77^!mwX++X~JdFl*R^~z)T18K_6 zRpr?mo?RVjtxngIrE+CH<{+DJA6I1sq{eruZ1Pdq>Hli=U)r5N8E(XLypN^R7v{w~ zU^EL+vkzAwrZf7)Dn970izQWqD$3w?Jv(;Qv|y4yzPe8%!-nzqSO82b*EQpVT0!%G z<@Cu9FraYBHC6cPGlTEO#UHZcaLw$lGk4N~EP}yI{KWX3>dW)QKaspAcx4ks+vFKn zGk&9X9omLKVqr5_l~TUHVh`NseLRefc5 z|4VOTTWmhftFhE6jdzGJv=k0|2fmbVnN_Hu|AxD)X`XN_wr&ICk>Vk09 zBH+r(7s@}NZ`$_rtg!PtKR4Hhq;-(9g7nX(!uLjptFm=D0&lzC+@q`p7bZm<6leK= zRNc$(rB`;=@nd)FZr|^&va1vu+azha6KFsXBqXkp!URT{=YL?z0Ew%ZKoAqe6ft0k z5JF-Q5Q@ZIARy35ce@?m%5AsZcDcIkcG-vZIbSc{U+So;ewTCJckgw1*0a`Ld%vtM z?BvPSNpa9@hfSEZ(;7vwVo!Ax`YXFoiEF%799s=)Z4su363#E+^Xhy&yjeU|MxU(SHLsqA#A0`@CpCR zKiOET4o*IMj!Q$kxq&8yL*wd!`8d5JRQ48!VqkllAC zipb6X+()$vLxY@pj@X<2tn4ej8m;mAmj%gt>c81l&FTSui>H+5iEGy3MNpMY@h`vN zo9uGyI`Bu0#=b>+`}rq7s}?pwoOzbdnQ^f-?}vFtvR240{9%Q#jr5WW+oUUc!~px+ zU8)`GcC6=0^ng@J{WNxZ?BVd&(Ucv8UE)Ca z%pc%m=RMLp59I$?J1l8kHm{=*dWBo$6~|+LtqT^_>C*eJ-YcEL5I@iMH`}x>hplf1 zbZZ?nzw71XOfPIpEy9W-8DQ&03i2~ z45Ij^Qy{yIL&6!aVrX34-HQb}H0&70s61po2(qA&9$Ho6@qalj989S}R>S{D` zfufEb9qoMVjJ)L!#Vrg4|KR(uKu@3DJ9ZYbAXjc}p(m=5y7}~sV`KLYnuKf+&Xv4a z!^TN={>7zxibTtv%MFZJ9@Gv5ddySE01oY*IxFfth>+}C{E+w?Ur?La`E{{|j6A`RDl2np7;$?HA8+g`UKD?;;g&=YZr+np5v~5SJC>D&nKj(a z9zuZDLfAW*!6S2ntF8q}ty<`3@_g-M&!@4d9k=(b>TC?7wK21*66Ts-axYqdn?~RY z@lO1?m1WjOHf-K_?iudXd7XA6lVCgzyOGz4o}zktSlLbeL0C>UUoDEJecuV#?|6B%M7bIJ!J0w|7)H+yIyjXz|!F4er zB<(3Re2+$C>a8M$e&Jt8A##(2&&NJG(cjsQMk5xfyU|0~FXCVqm^7@m>1)`1jm)KB4{#JMqeDr`F!e|M4*Ub*-Gq%bE+O z!jrN_xwt+c2kv3C>H&>DS%yUR=2(Xk*K-AP zk!<`ZFNg{A{5Wd$sm&+h5>A8#$Ait;wfNrWvtvnwVoyAcOdA_*VYMGmbbIH*imkV$ zdCVqe?M$53@#EcMb$yg^5cQ|0&HZ9( zosTCrR>ukF=wGijAIIyBAJXzE$hBDJx;}y9h|Dwm3x<$(c9=BQMmItm0d1G>mxpex z$30xXyu2$OQm@V^dci%}gFPhGKC3^{KeVp{Z)@6oVCyQI)39BrT5iK?cCPITQs*hY z9&3*qf$6TCUM4Eu`)=i8)Uc};PpCFbdfro{R|S&c+n3Z}( zc!gV;NB6et(OOn#FKjF^mUue*$)8zR65jlW&b-tT7i0M+E$1oXloOG$G7KYID{fiW zH)a}FpD|hy7nboBco@p#a3s<`E_N#ReKxb&Gx_ZW5DV#YdqR6IWb3P97;nZh_2yvf z@>ViP)_L8$<;(H&sj@FQ6fPMjV-a zfXW%$b0tcvLi#M8>HVP_ zS>;Y_VAHNiO0X?d!0h@oPxHB?3)x+lrN%*h4XMZ#BkcR|$9Rp-?|nk#VD;iheWx?% z`6<7Tzqt1Dkr;5i!!CyWfv?~_Wro-tn=j@VTjO@!?7tWf?~2##-ip0lDS8IHTFI#% z>ppm@iU7s|F?u>zXWd{l>({PGF3?g8H-~EY%R7p_@no_QFUwchBy^Om@`;!YR;6m` z9?%F{kO%G5nFMi*G^7fsPYE=1YZw`idniI`)?^uJQoRSyZ8Q78xjm$i_9YC(1AczwH* z%!j?vojgtsPflTXvTEH=mLw6iSDnxyxKSGzvc?rT0p{`C`B$0~a* z_pAm)POaC(Bhp_r-6}YcU0pG|;`dcvwg;gnN|Ym30cL3`1g+6^PLJ`%AK9PC*({B% z%HdWU;evNoTQo{tezCXH+{3rYTRmQnY|mk+n=04Gn2R#UU)5WE~I z&cPD!E;b#q>A5UNg_c>n@5@I0giJ&HWoA-n)BrgBLU6;L)Gwb2Qu9g18 z1392BB)gkCnT!B-uo9M1801HOz+np?}%5SgK}SB~o?ox#_@f zk6UYtt-rPI1!rZ+!l?d?D;JLcv1tQuLIR6H?~y%t;yEnpNJ z$!FvuGG233ks(FW;Tx)FSr)na9DSHqoo7Y`b-NO|iW$}vJ4KWf-FMG?tez8Nb+`8U z`xF~BZoHioVQVrkZnv*iBoVdhgNhee&oHX&gsyy+&%+g8v%Tf1>?=N04QF$oq(?s0 zll`1kWS8b^?zCd`UhrWZVeP6nk59_563w*L&u|hq7kU z>X|}LFm_74bIHk3UQ55#`m#6v+S4%Wt+!{Xy~{k>=vpVwSMuv!U!ez>UCp+NGdn0M zhTwcZTiq^NEH0eE=(04JRIVvzvR0Ux=fKer4YM>_Ki`^LP_w(=5Vq`9?C`fqJybKSThKigVDW5znf89E4O za5p$ut_{87KM=i{C07y0weV-pGkSI;Ag8MCyVuIs;-psJcHISn6-PxZ(q_>Z77R0f zcBf9^XTB#fU6CSN=oe>and>9uwDV|3yA>1j>3j?$Zl94%3MIb|>MOfzL96nt(yM|@{^`+Q_ zSQMc-7F_2J+hQg9!pL!R?L3*4xms2l-j?r>zjdhUCt+mY!-DvQH4&DT_ZzdBlVRA0 zFPl5Q(ORCk%jV38%^Q6$ag}amGWDXfFgR5Qhfm1E_<;%pe^WbNcHpygpC2Aq7Qe!y3;TE84jZzb}X5zcdn?D#ns2 zDV7U1exHS{#h|t4;*(sMEb5!)KlBzRh`m1=i5j7KkN`WHhml#eq zFp;N(J+zoKVlmdlSeNHOlY0Gf`GN03L3f7z{`jAKSFWUBq`nuU7vp>{vK@I@7#%k( z-t*^v9OFmcyzhn!irZjc57Xu1As)t4l%{Q{zh$ECe=-O0D=*o5MEYqd7w@_P-U= zs<04`PRJj>Oh2bto8A2*d9!-2KXe+iNQQhbt@|q9=qLUaD|olsEYB9Va4a=P2-q_^ z)pgZIShqesUdHEOWLf`mNhob^p}x>^7nTWo zTc>5SyMLNbs4C++@(2-zuH1v{s+rWQV81w=>38CV>#^m~zgoH3)itFXExi_ns!8de zs)k+=xI|G(^b(`j3fQB5$U1Q2vp%;R(K#j7QQRfzbSI}vIZsR_ z$Zk=4NpQNDM6m=mKu??nmik}(V)wAJSiSgZURcD|9r;Lo_x8=I^Va33uU1~=$rw1M zS`%y+`(ukRr?Ik(>{xum-|YXf2IN@?zOrtF4;WQ8U|g+ik+o}zz_>#^*$hO1W%k8d zvBBqJ=bg=@o_KpkLe_D(5RYu36rGkoSNo_ARGb$*uCC~Zq-+zXx6?$W2CC2uM%=aY zBwZ@(XBon2=I$g|y{1MZ4=59*HLv(qxrZ5+i^_EtQQ;&cW#j!GZ}3$z&MsYxAGn9} z{qZiC3en;| z1MB;p6RY|x#i%WOuGr{K!XE&U}V!tY%fSh0XBIPvhL3(G^D^ zt9m@(omltK%*shvPN?gT&$%D;W|?FwJ{1qxk66lo^tlvgS-8)5A4_B-V!WTZN?61{ zS!Q(&UTrpH$A|N`G_x5KjDTOft!t65s13E?vPv7)l^(Ggyxran&yewq4QtCiBZ8b7 zrxkWjIqqD55CDQSo_1X3e|Avn`s*pw?#qsinQiG`VbSclbJ@$?S)LJs%?EReh<%E`ZM~KL*))bxpBSqqt?I)XKZ;3T$DZh#$?Kl54RF(X*qs)+Yx4W4Dw>uDio5Pn z^{cE_)Pi^_y<)wY#30zUUA$$TNs82}cNO0@&R2u)N<2yoWua?S4ix-gwz zr^YS_Dg*5t?eYSpu1$xO(<$zW3bRrcGu-~4Sl7EmPp4{pLFK4H_UtByi-_GVO zPZ9Ow`&Y+~uVPJb15$NG-fI2%;rU6pz`MnI6)M#X&n}j|u>B8bjBJ=+%KsjoE75~G z3m^46a`m-ra3#XOtKaf_GU4H?ubpSzEu?H^Lf*YKk5<9O64=kDuyK|Hb!ip*hdEUq z-5(lNWiX3khwCL9&&jYm8=q0DD%PeGSC0?2s?Ec8I%7|AV#&0fUBqkV< zKjmnwOx!SMc*lO>fSS~<$AlxH8XIWraDl97pyw?>d^%`VrKnaW3GcRt1~c=N7Ed(_ z-)WJCKfBZ`vp>;~{@^l8!%StYaxVEf^nstQYz*XT2IL9fFQ#Yri`y8NpBN!~Qt@yqNSGh~`z&AJ zCuAjWb*)fXf30=EtV86tW63$nd^twyezZr5>`PpeABZqrbBW*Cp&}3IeBvTVxr+HTu0B<_PE5yGV?$POJx9Ur zBTaj53YB-z(zgOn_>^V_S3w7Sb$VzYQb`M5EY39cJw#!ux>;(BXIM#`_*AvBFW ziO~6m@f1&JwX<_cAphpkcjxNPPkMd+dPajf7AaK&x29lz&5@<%yQEPD82>GoC9k!g z>aZ|`58J_ohp-)0a`6eCwSR~lC2=<`>qS%6)rU&#n1hq=_Z)G@h@L<(z(5 zsS#B@f^EgPSXp)|=BcT%2v)_GHzpT@%?%p)qvou-j=%5=Re|+VdKP0y+Plfl`|vER zk&ei+b2E4&JEdhg^!3ZraAo>pfj@Lqt;rQ>(rG{OP^&N7RVfRA-F(FC*$Pdoh%C1G zx>bi_X!z@s#eJHm`*v5Uzh&F;O7n)9!xk?FCJr#VI(yFGj@vsB7hj)-_c`vJi zk$BJIJDKP*-5Q66IK(3 z)$5p_K*=&y(l0Myd$LM)W9-Fj`lfeUu7_UiEUyyttYa4AA%~R?QOJs<`YoJRD{~!l!pq~jJ!jEg zDQo(Aa>}!C1({>BCHq*Ck&yexvVUP7*nk82rjZ%x~d;teagyT-IC!A z3wBRYl!c}LYK`(vf9Me7QD;9Ybg?pgc2PXeUkq#|EL*m!ir4dNbr;M461nQ?qq9F@ zvr%Vr>%*~`Vwn4pM6&gNaSpDww!#wCD0WTSJ+U@bqtKXl!07sA4s179T9Chq1Lmcs zmY?`dpJQ*ZX;&V^T(RvZ7cYvFw#vw>>eIVw-7tzD`vl$8>+CzY122qTo?+ZFzDGv~ zVw|-^Hjf*SEnX5QV%^K!nlGy?zZI|4ujD}V;-2E0NK`#PZ(k5jrF?CkF_HWujzM?Fi*Jc%d;rQVPO=6SK8#q7jUly~Q4C|j zuELt)rTD{o4_g+oTgzp2d@a^g4nco$`2OdU;xi3i^}UTZaiQ?Pv6^Mo#_X^=`l&n+ zmv6lA$~$92#=sVNJ6qNPdTfK3V-nq^IZY+rf+LFATS0T{F=61KZa=(^v77 z^jTs#fboR0qA&>?fA~m$I8AIrOm2MwD-y85zjkCZL!F_ zynNof;V2BrX57o?mTwkyLNCZrUr}t*?3xvOip#-6o*1(|`lg@_EjK3|k{rCu>Ao4A zCoHIYm`!nPQRbB1V`NXZ!O5DrmVg=6jGGjK!lhuU3$59j07Q=DJb9+tf~9}vB( z&CwC$rkl+y<`x&os|h z`NPr8u&Uv}aW=OrTqF#0dCgVd!G-WrJXEyozGk}2cVnOa9iJ^Kw051P%5nKoYssBx zSCo;DmgTlq5U1tKI1?SY0>q8gSjBS>S`~xTok==uvnC>u?+btDToI~;eS6TYuP!(F8Ac0uG8G)Qv5CM8z&XP`(*r(rFiKI6IGRX_9TXxYNonPSrE+Rl`(V-Cggl*IPuNF zDLYzlq0rB)s?hPgMk7brdfei0ag(Ha72)|7D<)lWkPMC4y_4(WHfxBRR@2~nq>)|t z48LKa{oYT=l&oB@6){qTM>5~4`qg&mUB%yL)SR7&7@IOOqfv8`=PV0_Q>`=V5bI=A za&p}r0~Epq)DEx!W67Udq58>;MGu@<07dZB@&VrEPT?Gz6q`wy+`a1Au_KeDpnp-i z3YKvgt4@d3aUUKgqF2m5ae1UOM66xAtI<0rPL!`JDNa}43%g2I+ZAG+S*&Eo?m=$y zD-lR%kh*>KyJ81kP9`)Xj}8;)zWQjqO*Rp}v3K}gJ^H8<;577I?-)%Qu}UCa9PBTj zq?M{{ek%j>N#|FI$D~7t#e>%Ms~6%_eV_G+`0~E&gFpH7?O`xFe^@N6gfqqCP>cVt zb{O2faBSnRC(`x2iY>)2acbohZ=>7frEc9BS$GP2AXO2O#>_MZTWz#avA*j0?o&MB z>HMD5{J|<)_i|!r)eEC8&!Bm)qV-y3cz`Xadp$hTa&Oii=J(P@VeQX&*=OrS<*9NhIJ>^o z+J-gUa_#z=oX_?2{56{U2SrretU7qcN}X?NvtrT4Ogbr=XXkzwW|%#{FSCFd;@E1M z#J2v=4lrqRXnaK`*Ji~q!_UJZ9wBcphQJklrXqp)m*vLHG z%&YFfT6jDeiVQrrvH7WUP3%JF1zC>T=QHy)E*U1Ue9~h-c(RTnGKW@ts5&f^kP(PS zcr!#X8u(U?g71@qSWp%!-(Vl|D;};IRCd>u@STHY@l`sZu_`h~#HQ;35z(MteiB1> zH_^29lDKs25gvy1`#BuSOC;2_LWl9{Y9{eicG9BiRYz2N5nYcCaeMa0VzRr9 zdBq|gZT&=@5YJfj+2^#b4Uv;-2|VOK@?Nu1!|Z$mSe+bqjiHsc>H+mT7(W|=K1VLE z5~07!?(=X7dx2l|BN?|-q~u2C;V+!VS@^AY^9^y5r(VsT*nECml|fv>-}o22a=$qL zRo#*mf6VIPSJG5lg|f6p0yF z*T(YeB+kaMFZq_*Pf;#Bk#EsqJwH`F_+#9T)Y*+$ix48%A{*YITGV=n(@5QseYuDE zr-QnfV5nG&gNqZqme2B9j1rgTqpYR|g!HpWm4XgA} zc0N4&ht2*}H@kb8kNt{}AeqI^#AJBK&%`k^FiY`?4HW-&@4Vg{9xGZvCp&!g@5%hw zM!VdMkgpYIMOhvXVYUL5Z}~*^m_-M6$E#SL-FJ9JxLGvV*hg3m~71F7VkPstMvtpfqvM1?7PpkhK;wGW7to2aYy#B z_U-ee4U0swLr%Vf^gN@#Mn_+;PGzK=!Kbqg8Cy{cqiIHsi%h;Uh;F4sH(Pq_84EJD z?$ruvJpy$?u|w8z*q@Q`i6V`-j&sS2L>9IsrtxCP9>=$<-fphyAZ7Dw+j+Qs3F5N< zb->5Oj2)6RFWHCOlWdKv=qN7wgdEAIdDDYqf3XX;qQ|7DQoa#`j(e)pz)t@|d$u9w zh;X758S|T;nfclE$zRKkvF0iq#gjPN<}&<=PKr3>QTH!mB-+6t$Tbldbc}>HpOw4$&bZAn5BybYZY1j zeefbRs9gqL=kVs5Wgrk$t&aV`e#lD}8v}Rlcwh{%{K)&#EDNEBqJiJCS+*NSws)%i zYBF|=fbG(88AZrYZN^m~82g1t`JGRZPJ0Mt?{eMN$XjFXp56z+$*uj`;tfm)NpBDO zi@~0d6MJHp?qZ*}>xn>nzB`NEGgVbB?eFtHW+4th_wvT_3c0_&4Y6M~i1&|rE^)Q5 z#4Fa!Rz-T)C4;PXQx?irJa30L^QUSey9!zylF?<|)po?B)=64r?3pXo>S-zDDDy1` zG-rGnf|2d!7@MPqJfRQS(Q$0fxg_{K?Z8tS+7q{`&Bt}sHtbuh-Y-J1FFNmDu1WJ= zaAr?8AU}A2Wc_TVm4MAg%kz3JHaVzqZEdo;MzgLeDYjZC*AbR}taA0as$tk)y|?C4 zZx0^FwyMi!Me5J3Qx_Y0wtBcPhk;zhS%}acJaH-{ux=<@l9|cM%B#gYFC)%NV){PU zdbZEllO1Z48hMp*`czyM-q0z=A@+MWUg2xVAI~F8_ra*!lK_c|r{P}ltt`Wg;-%;=BB(!D=d)evN#un-ei0QI1e><;3?k$&T&8X)?iJM*< z&BEq*SNdZI*aY0SGt(M^S+GgSAil5)xg+}_OY(zrydadrK*%-k_8#Mc*I8mx(UF6# zV$C=We%nq-elDMZaaDx#nBqPpBPZ8|oU9Q_izrwTPl-Xm33Z+N0AN$6f4~sZwod~> zIdvaH#yv6IAI#6;NPB~=n1o+qxM~zWo&MGKNGtwFwxWJqf$qpGu0(szY-2z{BG8linsW+bYxMe$vvk2%E?lse*2}~rRP%erDPPdV4iof%2 zi^><&D)eVLJLFi;alMUgVosbk%nf5$WE=+nqp|8t=3i|m^oJ`rQ(mXaNP7H>HNXeF zu(b|doT`J5%}-&RyhCiZ@1G}$1pM#4!3K6H9y{#qeY6Z+jlW zymj6mW;P3)CRVgvIk9z7DQtlLGEAuV>{K$Y4SL+1zs}eajk6|RRW%H|YLBFuV#{hT zvR9{*i82sB7G;-i^_gm;EI>a3@3YV9-I?=d@9J&*U?XGf9|E<97z6YbyRjx@n?wVC~ zjD#FvVKr9KCrl4h*%{r1OZf^OQ8!U`xBMT=jANN`di3tUAQOIYm9_)DHgE;N)T04`!&lzF0{Y@RMHnx)F#0bi&5`9$vMthhLGfeX6X} zoLCRN^25i+ZhHReo~Xh{i}}2`D52`m9v{(&PdG>P)*uR|Wpv^O#H$__FBFrSA!(C{ ztFe1>^c%TZ6|p=|%yx~s&)y!}6hFMH8iaNDYZtpQqn@3sc5YvtdGFd;dg0$#rg>yF z?k)z>1DoZA#)W5I&9BNH)MI%rS;bpfAkK()IwP~l1h-o661|dg?3V|Km7(n7mk7X8 z+npi)mz}C887m)$EhK{@;UH#1cWJhD4)u>}37GYsG7_&N z8xo2Wz!f%S4Dk&bOL8F&to95n(bO2=b+J*cAKvnH62L=gm{qrSE>~Q?Dn`Zd-Ocy< zGV-Gtz(~Yw?XRIR^P&Ymzi-~TYjX75Zkqa$WLzRe9GP5LDmHL?5vm_mMvuD!UN+-lKwz!*n^qJ+ZuBgkLH^M79l=v5Bh6}8qey)&H z{Kub;SLceP5!RlZc{G29xZ(<#7db=_oy71q?5d8|x)bTk-inK{4pw9q$tApobl!`9 zh6ZpR538=k3W{f~t+Pn6fzPpzRt#kN#!#1wIaxoz|Je!eXLJ6#OI7#Q{Mr*}4a#ay z=NiS!;`A^*oD?%eGSVl#cq%leKl6l-P>OXrVTUe6uQKSK98)b*4PQ1|Z35|W8w>Rk2lvRB9eJ2iq!t@fK zSjJhLjh|p^WLwRHEL^XQ%vCx=d-E-ks2npp$e*^$p|u=W694GdpT*YlM%YliE6Tb8 z`S(A+Ab;a6XUtEQPqtU9PAK*B>NHpLrkE8ga_9ILy9%@ER7U;du{PYOj#gK}^;C9S zD-o@KJl0>%1$A`?*!3izl;N{pD>rg4mI~Qig|+&5R%l%@|IKHO%HP)C*#fJFdF+av z!6`^WMj<9YZej5|~ zIsN`sJtGNK`%0{@0!gd!6SyKPlK-*AB;bzQQFr9eDc zIPPRT{=i5*WOh)xWAn_qWfP(tABB{0xnf;$E)B$h$}C%5Z>6DHMK-X$=~`8#ss&+} z*=hL<8#P1sHXqzXER#QVjtcCn&R-NL+R(B2kQcjF^{S`Eeas9iv!+u%K!);{rw37W z&+^&rOO(x$6dz0{WoT@_8Wf%BgwS8FkD^NM&e#9-L$+fLe^oD&Dd6;^%7=`S-4uo5 zS@A!}w(HGmN3_caiW}8kt!+YWa>v8W3tG&N=e_L;t$M}IaDjMJHTyEh@<=uXC1Iq0 z!%9^oGGBaQ$@UcR6sTnduq=w5(}MV-u4jEKyb3d_RPX`UhhlLHdKN4Cx%(Iuevire zx3!S!9ys0h6JQC!#!R5sJ+!I+q%AJYi}c4kb_l+2m`|vR#k4v zHd(3t16fp`QG1SII2+!Xq;iJid^s_+z3MWX&9AG*vQgZ_7>!zP1fyAPRp~efB*~N0 zHx3}15Hq*-1?`Jxtr*BFSQ5*|B2?F(AB$HrR5AB%mQ()EX2f?42+A5We8cOiN%03Z ztFFv9%XeT)IfU!cXPE`m<~^8yk&4f-vob{}`}n-SY#1Kl6uM!sTisW@&sgko;X~O8 z>m+UV=^PY4XW!TmABl4*3*(1@cqsnJ z((=Li?{a@v*X2nDVg{K)CikFwa!AT)-F>a`v?{~r%R|av{ZNKEN}u0P_qTR2}G64JKv>{qU_;0bFx?N2(dY zJ^YE}A(XLuS2_G*dirO%s{67E^;Ee~Il<1;`^`YKS$rr)v%!95y#90-v6i1fOza~5 zDPo9;M#diF=dR7OXefSUj^4-bs>HZ59OlREG6?C!KG*bnU*8$eee=uHy;y{w%9z@J zr3)1T&=bxUXQ(r-EVTHfVlS^#$t{w{Mg5ljr3KdSo}{#K*zdz^I#%(m)^2@EwOW+m z9dRFXPABY}eabJbFR~f)@_V{t%epDdLrulC;ts9jwdxcCxBk>AYE_ZSd-Aiqgja~` z^aUr>i{tfdK~;zy)dNJM<pFf|sn*ylTX_IuCm zVWaZ$Y>YSZm1>w|+qlUp=H!~$6#X7?-E6$0bu}xtBAvThK@i*gM(qebszJyka0gXs zwpN}Hry{R?dX=oPUbrmllbQKGSA~2P`&sW=qBjXTk+s=McQK$4BmDhsU%#O1HEi<^aivWLB6?swO#eN3EaS|t^ZofP_Mw@+QEW#dftFebnK>i9V>wjfo$9gOo zxL)V>kaD&z-|AU|@}2j_PhKDPX>F0#VId}39un6GtLTIM>HJFvR;@A6I&k46*^1Ee zyLt-J5q-k}a}@q%;6_stw(mD;hVtdw4-WuDmMyGi*A*JKGbo=b5;6d-G~jdF7cSHh8ps&IALqz%Y+&&%Oj^FN5Vm5 z(fpa*tsPduh;LZk;$!tDs6|!B5#!jn&x=OvqW6X75Shm{US9kB>7}Wny)^$@!N-!= zXK4EI;9=dwFfqJw{qTiuRG#=U{E;oQO8DD-)%R(cUg9h;2o9$OddTasYW5>C8+oy+bDX(yj@ zM?Ql`w*Ff$jVgrvc00MMiNhK`MAMLE$6?-fisb9n0E-RcX|berJzkz=`L}f`R#Rk# zi_V=lU-@b0L=|yFU}F_)#XNk&Sjo3;zQt+vPxFieHxBZwX6mQrurK(v%vugpZNU84 z1dfDL!`ToG15y34Mpuo)zKou0Yc%Rk^1r^K4_4;>ESMixXDrWmm-ZQca;eX`ORE(m zYFwKG(em~^v2t?od#3{59Btiy!D!qHCb4DJe^oO*rtVR#s9fgbk!1Vu^gqaOs(s;O zJSa=t`c!-3NrF9yU;N6utRLgAtXS0oPEJY_}EL$0q*kG;xwLAt&uI2V}!@_!3IQ< zawb+_C1Y*3s73B^ZuNw07kj;LzT?H}0j>o@W0$-x)Hbr^({b!jzPQ(p#_d@ldq`Ra z7KbMh`4IL}Eu|cwnVWsAW|?eqW5=+hk@F{#EY1{D%M}irGvaXl==b5@#Sfp!6PqLc z;S(^DO~yUwgr3=%S&Bz^hk22M`T>h)12QAAkq5_^Xdxa^hM7HB=PJhWFrTkRFTVP^ zE8_U>Z2w=Y#{AoyNz_P<#V+uw0##<+M-4V6&RfMDc2qnp>XQrZD*m=UVO0?mE=plc zatr>`&K|u*PR+pS;Xw>ksCWBT}Y+IB@)t*T_fy3o+lDkrQ#2) z(%kYFaoFcXz3#$(<3g;l_5bV-(;}nvQ>@RL#Xek7R5n`n6=LcGt;d$$tBO^Ph|?B* z*aognn@+5d4;=M5{Rmi-JY3zMRY8;NkE9zj#7Pq{%kTMCb^0*3?29F_^XeZy8%DN% z;$HrgGgX7J9>_N8tSL`!or|p1OVwuG&HKw6jD#(hW014)kPWZGXNLX2iaKbyvhGd*x?9x?QK`;iI%rdH*gek0? z7I26-fN}XrTKBW^5x88BWIYUJ1m3%Aq~*2zgpHI(<51iEa>O0AYNI3N#>MCAb|Ggd z7;2E9oqM}}>3`b7Fxv}+gT-&j%b#Kr+2()l%a3|4b!SD!$!TnUd69A5%-i9|=5W_I zx(Gz3X3M{tqbTcTjp^p_P~L{eg$G8?*6EEcw;#pI&>M4# zP`%P9*h|P&Me0B?%q0}U8X6b0B17@cSYa?NK++HtqsYemOjTW8wp~eKCV#4C0Ouf( zH6AjcPYCL>;l}c6{(AJA@=Na~`H+E!lMPFc(eMf{QZ-)l@g6Vt$akvw>BZ`qJ?0wk zW21d74{J?}EcKm+?l2Rkw4P{A?1>*$m1XB~DROeZ*kExrd}1pyvi6IX8<8KslZ&wd z*4XoW^}sYoc@IB`r}JE~IIQYyD0+n+xR*RTnQzn}z4)~HIAkEN>O#g0i&RfW6*H&e zP;1dguTSrhUu=E+9=Uxt##yb~TkhAOCP{@w}2*kbuE=7x{?7Y~yykW)Qp zu)nzNIbo_|II>L14h~~)-w6-vIbu2`>3-`Hc%$1WCDH&;Kwsb}YY< zSF@k3*^~120!%iraRcx(M9bz-#xQVE{Xh-r;$|{#?5t%$N*@-hN ztSzU{;u)5qAF8|(#`Al%w=(PHRH3u@lGU(t`-mSK9Utf6!Fj%+@+(heWv(;Rzx*j5 zs3M1DlsQx{#7<(g{71DLW~dy>W?&Hg(KN5D3q-GvyFfoOm5+t=_}uo>SKDb{5R2r0 z@*FG40Mi%FQW@3<6 z_!$R>88E8&n*ZUw>PxVJl~pgGk?swf%%w5-DX(oEzwEBApX@@sLcn3wY_`}eE9i3zRW@Cgy!_theL ze;TX*1f!LMy9*y7<*Wu9!oFb{kJT@|7jELoI?!5UZAA)OfJHb6dC3qP zZ<_Zr{0+a|sK|%#R(4x1$9C`x<8%G339FBgG8^>Q6~w->8F*O?4h7eAJ7=u%lsAO#w+j#F=- z`N}I`CBDE`t@xy*(Pybw^X;6k8F!z04#2!0yX8j11nvPacH_eR6phYX~z~Iux%C=$e?g zwPMee{(R2isUJI3>s{oW9a}Y#fy1*nu?XaTtLI`UK4@Hc1pO>q42SFLEt4R$4X$p@5#NGje1`mz>sl^cq>B(4>+qM2lRcS;#8>6MHn+9~ zAN|eWtX;H@0vmAwa>-khdlpe$z_r;dM1jX@vV5cSr|WfwnQ56^;-$-!*EnT>kFozQRFSJp6rNMz5Q&b3gTlix~F~ zTg>AilQ=~0JOKj`jd_B47~Exn`N{FW`KV4+`Q%6Z1a{D1^N(j5qr8ZfnUV3smFn7T znMb*!clx&%%+1C&U-mwA@J_HGPchC&^WG}vtOmBT&DKBo zB(LY!=EAm(-=~c*Y@$hiA0HuL; z8D(X#Cz~i<@+W`75_e?}yBC$du?TZ7>k(6N(sCRA6pw(zi(sPK0~ZgXJ*-l#gcZXA z-XO;CR`nRsT5M@$R!5zB;e(U23m(xfdZ_%lU5Y@P2ki_49MZ zUz~kXU!NY2SLXHdjO^)=q})U|#p~zqoPT@9^y=6-f91O>SnthuVL<1pJvn21;e^|J zw(KkOmF_#|``j4Ghdt2i*39mAM_%8bvFcoYb!Pva3+s1Er{^id#cFiym%TqZ*LitH z`t{4}l^ON!r&k}3v*E0rlKu8v_4{*|w+G{R1{@Uus^s9f@)2<@YYi{0N5_riEcj0= zQR*bFpiZEROt+ibUA4sU?dj31%!ZDgWTfX1N@5#g6Bbky{CLLb3h&L>s#vrp=RN*n z6Idz~Z#BpNcEEZz9w_RsOxdG^5%qn(sMeR^HLzGc%~ahK3S#8oYe&( zR&@}3qsk;+ugV0qM2gQc_eT~w7`XZRs72DAp;3)%}-8@ z`-H~yD&OC;A4H7Jg~SpwgFG@sUG4HxakO<9+EWQC_E&dz#m0l-A%=RF7-gljr_@@n#xL4Ct*+txq4?hNp|TnXC-Q6+wS8qq+KNF{ z`|=gNv*ie$HsN)1eEEsFcQfK)tio7fr)#T*6Cm zBixEc)>FiUWnpnxoKZZ(Y&UWh9amaDzjbZAfCsIwv&zqB?2uItMBG!%re%EDD5^&p z4W914G~HfSa3MCU7FTw7as)vO^U~D09#3`m?&IcGG$@ z>9czkcKB1}4*O5vSq_9S8y@k)i@&~l{=LC!Hhg!or6%w zj#_u9KPwaqsf@g_xSxt_`zG8!S*8QCX}v}jS!NNJPd?$9pM@WBY@=XDt>nuKAf9OF z{pGK#Ib+IhSMG86bU;$9rHraQD|ooNCB6t_yx%oD=c~9%W_s|v*B$hj8JoH8A2~qL zS>>U6qZm*fH#7}e;#ZmY?T#YLc2Z~-)7@1PX`?tSI1zrBi zZrw-Li($q6ml3eTmCwdR`v=%1Pprq{=E$e+aS|o}de~GP+Phm`$YO99&yJ!)@r&K? zFmu$4#=3AAmQHdkOT}5;iKW96Hc)-f^+JX`t!kFj^q!jc84WMNA>>)U_P?>$rCHvt zQpJDBOD1+y!Dxs7@N!j~>PBD8XnH>TeqaJ-6M_0d)g_*&=M;%4ng|6t}~Jo#ZVWA&uXPDMD(1EP{t zk(y5w%j;agRPtqf(iQnHkK1*Qs{XDAf5JocE8fV4>*A1`TL)~_sk#@7sK!%%!(UyU zMtqJXSH+YKh^q%?(g;R~VTDJ&cSnDqABH9_tiGFB_e=l1b9oA8fk8vl)~D$MSEYIO zY)p0hW#MFA6{w1Ia@~3cJ?5wQ3z_n*H~<`VUFb;{{8UwD85Kjdu9Dl@gKDXkiEr!ME9Ank0iTR;*>i>tB$p z44n+!krj}0QO5sJMfSrEt80-1rs^soxv`7MWt{%Ee}vZAk*a|hkUx`7nJcd`%Jkg3 zLrmDiGV+ZonAH(Oo$!xdu?o6j^;vgWv>h6v1e^>%H(t@MT-V-MtZ#dQ$d#q)l!Pmx zW^p8+j!&8s+^kC1NLUYvnXP$e-*F=z07Hz?d&m=)-8$OVOyLnfpsBKiyjV{I*~2rZ zB-3B9&Aen0uoy>U_n{N5%4+#(^Dc|WGMyx*&VvcDe9|*Bc;kP5C1O?OuY)5_?HMaN zf91y_4*tt4T?x{^KlWM=nHr0}E;Yg;)?wGiL(A6PSz2*P^@42ndOXig0F@?|FN#~A zb+(H-K|TP*ij~DSV-YXdj_bKvd2U=!pF#cp+yB5WNqg&7e6e_MY{p(rRM(s9FI&Ri zTgP^V^Nh3FMKuim$riS!u60=bSoI^7r(ox#SM=w>;v?(lTh)cF9l8>fw$gBWuDp?$ zzlCB|pGccN&EJfmgN&Sy^Y8L>^=@2gD8KWsxyO-sG9AJMIVwBzYRtvD#=~P>QA~zC@o*gM zSUav)FZq8s;}Q?b&9P(nnl#vMaWDH8KbNhuNB&mVMshgt7WTni{qTE^be-h%vM8IC zgbL=%Hq;M1E3|U}^91!TwVGbl#I4iU%V!jEDt;WNF>2gK49CfiegJbKoj8s6r}gxj zk3pfsgR@1RK?g-}zb9#T6baZ9Hd(FS8T#)GLfVg8|9~AC>>p3JVyDg#XNGh7m+JZ@ zQ@CgBSqDUKeZ~8WE#VSd@vbadglnJ9@+kj@8u4T^G;Y#hRjsQQAFA|(_4HvJMF^jW zRl9rhCBG0`F75a7$-`^loOhOqZmiio)a*`;N)(bEX212H>QmKSR$K6N zKhw{a0UvRuy^y$GOoKI*tMg;?`RQnE_tzU294^-}XZQr^SQnqzuf$JsuRa6;szt(6 zD=-iU?-ZBR2)1w7PO`L{kCBh-d%33hxQCIzV8}>T+dY&0h+@Wn@NLpxJK)<#+@~KA z%@rX_JBzO3R-BEWs&lA*84Cnscd&$YZ?beTa`$h^ym5oum~ugoO3Y@I}=*wXQ1o)x6Ym+K&*jvn7lMS~r5M zbk81X-ObaJvpE(W8}e0o1)C;CE6vU#v%8l4SK*Nh>JKchiWjLf#RupX&f;&aNwyDh z?HjJ*bkKngSpa!wNBKGI6e;X3*J-CBXID8nh9}`Y1mSu7lU20eoL{@%@|g0d#^p|n zFCi6t$QqloRV*FEhu^MzAT2u}iMVMt2(7Gacmjo|r?d|i2TEVEm)3${6EEn_#!@5_ z?dhEd=MnHaO=GY4RqH_UEWDlPn#o>`zVHvepYHVr#4pV;eeHjq_zaUN#DjUOA z%X}8f`CY6XzWP0z?hgqRE9(o3A(VZk8MYdBZZ?;v@iW&gisA(_CUf%=v&g$zyIHAo z%9-lFgpsNbotcP6~ol4g||3=;$T{>d^cX2Az$}`=de}{s;+$JF{og(Yj_C# zvR*4+cnAJUR{31avUN269CuScmfyQCyOs-J(Cvhh(U5T5qlgQg;u>*g$WGd^^XxaA z@RRruZjlYSulTB8h{e7$5l5yQ589Y$ce>nZpANvUvK6!0*j6rVb})#RU<`e=uZqsi zq%|j!Y^>>%7q&nDsqtQQqCFQ|WhDL^x7KZyG+F)b^CR1`&XA3D$Xu6;THPe$){@xw z_Ssvxd}kt;^#D=M=fX7pqcRHxu?Sc28&*g*%jUAXa?bqUmDr+dv3y*IhsHR{Bl5eA zE&i_##KQcUkBvRG#&-1m#g=)V`a`~EHY)n6n)Q*0SI$r0IK)r##E?Bk4yUb9u=t{O zyuR34-vw60n)n)j)#qC*5QFPCQ0Wx!$Ypz!;v*v0W=mp{&-=;d#l9z5{CaW1oLx)B zvVBtS4GGAz*e~~I!|c!>_jMn&0Ci1%Z`QGzQtu0A%fA=p1b8feo}s(UR-l`NRY0Gruze5ataqdsed5+bce=?vyg0D zDO=)i?3mw{`I$cyz`CFx8!tYI>R7dzxBm=Es#jWHH%^(JE7G%fRQG0q{nq#RwmW32 z5Fwe4kJBbIp&pK9!6iQ)2ImfbfpC>oI-mYCFX*y;##RnMb`YL-kn@%Qc-2BvYMsy(PYVjN& zoXeQlMD>4~D^G=0qL;agNc@UyjfE7t?Pr3RUBv)qH~7s+lY|FMeZL`F1wy6M3Y$iEFTe zb*0y;7-V7Od#<6HlKjhhqzGl@05c$OGZ&BZqvAB1eRNiTJs}?MdKFpVu2~nG@-vZ_ z2glQ@NV|JgUw&w2>_NOd_TA*2B-q@s#GqbsPV)@t7f8hSpBtyiXX_S=mKmEpJP+ax7@LXscR)8GE$}nCqa*z<_R5&oevWMDA)T=iS97oO z`51ihJzSt`=Vh>|x6&=HgQPE{YX0;u8*jqMS zRO9I)Ile=yBx^@j8A~}Sd&5TZFC4O{C(pDN>?b0f|HGcJJA6~M#zf$<{hGUe=KBnXB)5LlHXr6@!h; zxZE+$<*VJ_5}z_Nr*s-4jfWDCO*DLYI`3b+^h9}f7%mQSx;c+j$ztWC|Ie_hYqfi zrIA}Nkt5491~yT51AD$ZnL#JYVT9EKI$O>?^D{ClZaXa%=cjpA$PUfK>^tADHS_eI z*2&5o^Pc!ybs$yMau#bl#_fKj!?Wefa>lwdahtlP>h@)!&0J2ZsvtT;5E>;%6>(QG z`__5$MeifA_-*g?{UVL8RYr=F%{#6h?{ckb0Bm3O&dSP-;hIrc=kCm8UFwfr#$?Xq zVh1Hz>4AgQw5SKs`n;a}@ZM;Qsd@tx-|SaD0{!7uyQ}D-b>d}k;Rf6D!u!Z4&)#*k zY$A-H3EHn8sn|lkn3aAOSstBR4P9%Mk+4rTCBCSh)~VXcnD|#rbZ;Y~FV-iHckTz) z%yP>_;_LG2uZ^6@6ylXTkxJ3gn2do%!;dNkcCErM?>}tJJ)s@k;jhJVme?$kKc>_w z2Ih!Im)Gd}(fO^qP(Gv<1L5(@=7!yrjg#6>$7XvrWMd?EvDBEn*cP88k8FV+MQ+F$ z=W`u)>nyL`2_`-_*7%Qm8?`^|%{Al}Yp3Zwc`u`8PtZ{uE|Vm0R^+T3&t|sLsRLBs z-GM!DmoHimX9HUUtCmr0APwU_&}Z#U#u+M-<;suNo*I@=$Elg91r@!lPgr*sq4l>z zAv)0aFEjO9@x~{NUNuzQjth~=+PT;ln^i+!dn!V(-TF1NE1$0_KojL@?(U zeG9lec;#AMknA`A&{(jh-CB&gMDa&K1ccEZ^0HrBa3G=$6TC~KY3xQlybQ8AQiDWihgUa;7-*} zvuI<$7JBk{ank3#Q;$Q>DBB$#oi*f>pIlI`=hx?dRqV`AwoMOmCfLgE%2V(h=t!o} zhkhWY(H}OKJ$GJ4nR~VvYT`J3f9$``M)@P=QKk{=Gd4X#M#JazLt#R6#@E?n5r6ZP zVv_N;CK|tkacT+f!PmnXmZKsq)5!1etK{R#7@RzyGp*$>otNKV&{a_#x9aLv_sA#?)o1yUpRtL?iGpLrViVNkfbiDp461zscE8mR)hz+flw6bHqA%OgKSAt=E z9SnS}_xp;kx{FV3&xW*xNj zs}vK&JMGbHwd3GEo5_kF@&JryS7I?AtD>-qzQlN#+d8rC5thZi$h3-7QLsu-nVy-1 z>!iTGShg#Pi<<|K0e;+GMI*qI-5E|+(W>VVXIA@`3qY;d0{_ic;9s1ZKKWIC$|lT1 zq}e_ie5Caqe%U!^(B7rVYp-gW?56A?+pfWePjLYKJ^C`=pDVIJ zFMd})Gug4btrvxQv{1j8`}r&uo(HFq(RJVoc@=EBJtz#e?IbEKr}yjafVJYA3wW zuwk){9(Er@>w}>I`}O-!#CXUKj}@0&N2P=GD%#1vKDwYZUlQ;Au6lua(rD~3+?0>U zSE^It!toZ&w6!Hy;CIfA+&yrf#2fAwb>su(GwxCzULP-eCO6gFVrkswK+|@(%csg? z**9M5xlZJeFOnkdi$`(t*zS4eYiGCpZ%&SQVpYV8?%G4Fwe_%&yBbu;=-*gAMjk#UMX?&9%f|3tuU+}Vg5f^F05nA3@=2(8mUh3(P9WDE^3bXex-_``m zc#1r(N00acyTUX09;xA=#X|F7zkGl!Hon(O-@0W;13mZ_uHe;Z`M~C^^s_m%D5SEe z_5#tLp1HFrx)i@!VQNOkQk;Y-hfGOIy;Kj*o`h=D{6&P3r)Poei8ZsWpBXvd7;Bct zZyk``EO(<-7!ODJkI%TO&(nSwF6zLj?A8CS0V|7{^#&V@+6LQjPDc!1rpUfUT~Fr2 z9*njpNa85uA;NV&9R8sSD$h4Fci{)tKj^imb3HxpFFMN~Sbm+QjXQre$^(~1+!sAz zrs^$5M}uqtX2>+m*C(2 zac@_LWo)`g;CjW>t;aSWaYQVTE3jYhkH1wb<-4s{@7{JJslNl}m`V5*R+4Xc#dBD2 z-Rx%jgXt@HYvd)*1af^Zh#dEZI6N+{%F2B*POefQ#)hHB z$ofcLHIt3XI;z28p;yVU8UNaw6)`g0np1rU%X^a`T^fO(x?W6^KX<}VStmYL zEvgls7*nVY*ITDAYgtYf9vLMK(924V9OD_ZK%(r21<@A_)$h0c>zzYlw41Htxh%R` zfLd7iNnXn{%*H6Kp!KY>@DTo%b@s1M8(sdfDCk}g-t|H*HLX22h3`41Cj>HT^RWt6 zwGQ*xxVL!`R8vJD9rr5(FpJQM$B~3_(1VdwyQ_Cu4Apf3GjVZQKr8yKONS)QLMGCx zbtCdAK94=*OVyF+nl$7H?bs?uz_qp;$@tufl;SA)Ir;J`GAAd0H*ZcqbXm_9RJZmS z0=Ups z3@Y=GdzI&^TJmF8f)f}*HCs7ed-BvST*Y-@7fp$g`!Z7c_c`%CS@eKwZP^308|9I`ip<*7vhbrTUpHA5Xz6e!mf3COY9?ePTcYK8Fu zXu>zg=IhH)rcP^g}b=X|%p4X|jgmDq>Z6 zbdK}0x(qs*9rkq28^m>=YHrOL2c_d?qs{?UWXf!7*9%)q*gV8(a^fUr?ObHmNN0Gm zGnmzC#UD9o`AGR;e#GW`zA*m2XSMGhn7Et_IiH3R)#gOE(4zcm20eGJe#$?@>ttHz zg>F@+H^6o?EN0X<7~2rXowx`qyPCWzE+x*eWRVdT;-qxwxsgs^w5nOwRBsv1nH5?` zlMm4l#(`OeP!Nk{#Hr(8F-mJTvKRXGDNocZSAlD5D|~I&aXZn@4Aik$K)4>pK{$D6 zy&19X@*wL&#U>KzY*$rJa<2!&tapWZPhc{x)|DVIyN)Sh^I~LA(zA~NqC-7*XJO^H z;xT)Ia;+=yV~o)%V?C=rB~lolu~bh=b8tAooR?*~-qF2a6!r4^EUT7t zm2anS7!dl?9BudgMpg2Ooi-*v&yrxgtBJU-Y5hmlkF|I&uMC&VnfhF@ya=&4%yxK*!}kG*!S1xJ^7{2 z!i&%-UR#B~HE-jGM(kcJg1(*O+^KB-?Pu>zUCBOuRgvN=o@j@GT1jU*W+UPX*{Nyc z+U%b^$enFiv*ZhG4|+nOYL|3Ls=W^;nWJ;koTY0m0vd{3bYeDD>ZYu>*?tYzQA9QUUABoIEgJI_{io%Es+crXZ9~pcJP7?DY<&yt16OAA zttx~YA`#3q%5W4em($4IRIIknisQ*?pfL+}=9}|*ogSp7ZdIXJ5ZCo}Xv+S!mejS` zXYAE}mF(MDA8(G$e>B(SC$dObLeFrLMbmsM8|){U&|~whLn>B%oOON~3n{0N@OOYkejIY%KoUe{`G_NvcUP<$=O7H%#0sPFm5ZyY<#5t{EOB&Vt z=y~n9FHAY|Zr9qptDMuw+G_@%%aPMFG&g(iw}K+iV2A!^@5P1Y#0uno^ee7a+YmoQ zd$viwaWWRK-(DXb?(Cc#93vK{I_=KbIB%+(u-a?#X4mtPxmW(g{^U;b&#k$`vz;kl z@hZ2;6T`v9UA|sVlo8d(&VqKXRgvHtOL85nzMZAT>*%8U7s*1-Buk&gL=^)uQ)f*~ zTwEqwc(#1VeZvcKC=X>LdtOZ^?YOJ_;8A+G|^eD zR#L1ReRi3d^)BPo%fnmg!z`+!*_Hm*+~vdho=+6pS%9mSU+-6C7d~$+Y{O6D1h@se zhQqDU;b$b1)v4oITNg>Zj3tzdgUR9K$xxF#wgbaB>k^=`KFfwhNQ@Ixi@{X!u=3g2 z72;`Dgp-NC%jwj&T?sGRd?u^K5yVxValGK__6pK4{8_)lBZ`}iXa;jZ#_c`uK9&Y| zcm=G6Bw{3g_9GDtJQJq*OKP!+c(vGzE7|Kh_i;LcnZdYFUU zL#7z^shQwwdf)iF>ukl(XP|3OttcuKcU;F@;Br-=x_!&z+fUQ%ijzmY+;ysCY|IcO z+?#29=_m9n*3k$aYkh(wu?#XQZ*uRgLz7OqSv^bPn?7e_s;57WReh(JC3hhY`%$4k zj*_f*ZOGl|J=yU$wv_$(xwR&|U)+p)#{b>lmGqj4B&zW3gOzz7c_G;SE9QuT^IqFSM|{jWuG$DpmgPL}MphKr=gd z@RPgq^^eBC=n3;b%~kF_y?Oqfd6y_~&oK2rclz@)`hPc12KnB2$A{{ z*Upche(m&E<`lqxJ$m@%dEa@Sd2#=I;*Sqscztm3g}L+h=emy%o_{n~y){?(>U{Ff z*rGb1sKQ#SAF;(`0KeIRwXis0a>Ap+eN`Hs+Ilg>;IY||9UxBT<1KNk>ZJGypM?0H zyQc4fH&zFRz+SFZ42yY*13ZB*v#Vn5Q5RXg=&xs2`XkKn)AOUJUl>Vzb9S%jd|qB6 zqO&A=hBvSaAK5xP{!AX8-wHYC$vbEs&RdZZ5BMK^7nevee_>%{!rH|!wK&%xS65)^ zpUpVmoLKqR#d|)ySk>)|N7%mvckds@?JR3GDPE**!C!DD{>Nq^30yP_^Sv`y7s<G}a?|B*gJA7j|#jm2~+A-nw96x!uoErz~#6f!NObhi|EL+uFgn?Z&$tH|f z?yY)c{Oo39@5eJ^a~9!09(hA=R&Io_>*nmh`-K_59fT|)dxIucu6K2^P7-X;Y&P?a zqt{93E_PJuyz-P7^%b#R?ZPu*9vUg#9F3~$*89_$Emr1OIO~Ox#*OinPx<-XnXOvB z-4_^c(U&gRv;Fs;{o@Q8^|E>e<9Xs&{vq#K9A$wbz4%m3$Gzx;N02u}@W0Pvd`5Qf zykF)cuC>QlUCeV0;52)3lH;9ue>sD^^v1}T5Ascty>C9RPlaEQq&gRC!tfaiV-XYB>_{0??N?=b9*vGUhP+Ql}p5Yy$4o#pSIdbEmlqG-=7AjvoteZrgj z2S;6BMdib}oZnkXEEicuG^jqa%Y|KG`>?Ck=fu{iNpSU7ycY=*TlOZ_h|Pi}mh&{iBgD5BEfy6?Lm?cW;8T^>#|E#U8o(@pI*G+-V1W6MUdO)GZ&qOKbX*R1CU`aVD3^BCSN65c!i_oSpc zviXy0yd4X6blFXdpT0Gte(xeFt8i+7B2p_Gy3xKi@_b|7$#QSc97TcO87zH$-levL ztK7YO?(UfmuU&p33VvlI`mNJnIQ_}NaLmEF)CV)-8}kIOZ;XXFmr315KCXr&^T(5n zTfI-d_~_WaJ+HW!r^Lvs9~^uVYd)H1z5L&Ky*8hJhc_ z`s=5^ar%d+e>DI9`sr8Z_cupMw`Q*2KL7W5Hrziw|Hk=mo&Var{^t1~oc|wHX990i z_5S}ooO5Sf(=}vPQN{);WJ-w&8Ix3|L=jRMBcTX=DO4gV4W!Hz8Ojif%#oDL(>2}c z414eY`*YXtzIy$g7w&M*+G{<-=lML(-s@TK2k!+lf|(l? zffZ!>m;L16f#99s$KWUQ@FpX^6!Z^z2hX#DY0Pt2@G2`>$LcO3-SV7ASKn%AJz_m$ zyiVjD%*l3*4Oqt=Q;N$caB@hecvhJ zyl0oScd&+$*v{<04kq|_`xX7p{wDvnpkFWs2~G$`20eqvg2#iQ%9vR`qAy3IpBh5iUl4V4WoaqGF`od4PHSw96g1#kPQ{`cNT zyuR~Jdk^{R{VL344Vr6Z4Yc}ME%C5(!O~y=tM&Z9{0;srf2jYQ-_L*1f6f023BQa4 zPl6denO~ZHpZ%EqfL+r5)f$HdmBN#CmeX~7H-aB83Ob;z2mQU?G;f&qw)eaDlHV(s zWUaCfI)A&XL-&Ncg&T*x(9Dn>deoibY_xy3HU!K3gWi4KpYgTvKjO8#_q{BygTK{p zg{I3QnPJ%O>sABnPc-~cP$?)Bltq$Vk)0iE#V$7a$NVtTULF*;+GFqUSc|ORtjktm z`&PTMeUb00TDyXYK}T%mIo48^ceMibrm)@t{#kFZm+oDN*Y-|%SN-bN5c?Zvp?hy= zbZA-VdZ=PJCA=zhUuc1Q*g0UYux16*{H0!L??8Ne{FnH#cm;2^SJ|J&460&%-{Z$O zS*`J|FRZ232S}`#^<8j(u-AXvAL36$nm_x0`=Q|Opil4-R#Dj+Wc_3nwI8*++l_43 z{+UnS4^CeMFV5q|CGe-J0 zMA79SL1XOUtbfQq?4R(j`h|jf!IWXayI6R3aKAO)+QRyZ*hTD!wclE3y@54Nwm!3# z@%130_Lv~z&-S0hgG>6h@A`N7AN$ogGqZv9hxL*Dn6uGIaQnFbx(z~2LM1}i-QV07 z-1W{myM*1)dN%mPPxrs@I(k*S61)<;NW8H3h&R`>{kQyE8Ko#5(%X8)8fx{y<{E&u z0r6p1J{EKcnt?gRg5;n|&<+$>0`ixznp)50+wWRyrM28zWBrW04=|S<)_m(}qR*0` zO_1lW_21_Tqp+!A{3!KXoWYl-!U9kXXSNp4?vr&}&mKa>$V?tbjncjr3)+Be%T zSj#}3QGT*N2VcvL{}n$PKNm0U_4R)6^1M6zasEZWHORh=sB#P1tOZ^s6IK4?Cu@Vn z!MtEl91I8F-beN)h%&7~(h1gF>pSavY-yvl(>iLMw{GBlzv8uxtqYtx+71n! z@b~z;@afI|LBA*{{cq6Eid)m{6lbJ!#p&jL>aK9-xi7o5-Cvx?oL}uG_B{B^qrnEh zseizG(`(^{ykGITu-DW3#yjsd^cVRhz}QcjMOh^KAlCa3(Y+L`N&S?M1$&4(-v+aT zH$c0-!HfL=2~qPjIMxE(n~1&7wH9CntF1#;o|RxnvF0V#^TdPYyuV&h1Z(`&--2C5 z(dCQCp|^F)demNSS8>KUtDN0V1mCOWUUWWmo^dKT^X&`7;cxNO9exkLkiXd*lli+jDiv)&6xphWO2nmz|Vs6%Y-Y4rzzds?0Gq561wvUQeOe+*WQ52g^g-ox{E z5FPHd9_7{6>WclpW=*rcwGLW2mSbPDwpstPo+J*PL=wHRC(l0u#;o^$@w5GhvA|nF zp>+FycB(Vl`P-@Kc6NKYJ={m#!tQ*hvh$@~(H>}hO;R@A&+zAZjl2x6f>+b4?{)H~ zgWU-r`F!xIJVK+-b55G4Mu6 z_W`($<|;0JhKTzSR{UJhop}E|zV~^skKExAc+&Uy+GP;qlC?JtnFyS!CN3rc(~RtixaL!R!C_fAW|5GyU#< zP5&X}JOkFy-fn;eKZ(zM_h^ zVT(2FhIUKldzXFPnuT5pp-p9hA(+I{;0dr|9~yj(=re$bcbk775&os%0jr8#*72Qp z-92t{sCVd_(A-e7(0=zxcd4_({tK^d7fkk#dM|sAc}=~#SVS|gA4q)CYXH7y``wUa zDP-FOR-9rTK>q`gXk9qiVShE(o9%z^rv@(&!M&gj@!=R4X4^N}b?rOsYW8jREw+!> zwI%Oa0s?kJu42Puf=7bl!2y4c|E53HpX5K`m-Q<%RzGaGnVs(ZjC_x|%|fq+UJi9) zzBNLBxRu=sPO4qXdN^1}v+O`h&;Ao%2ptu=od}Ue(aOp?}@`v59}| z6uYGLXmG|~L(I7uCUV+4;r;6U>}7gQ@ZRgNwJ9LixS&_?BwBnJHd%_;cAdGd#JA`3 zxl8_iWDl9aBgC>}U_lD}tO>7bb}>ee6QAF+9-~6A9KWm-qy<$OX-@vx)q{iDM9LDd z=3-cL7BV>RKZvG|TZ`<6oYl^CC+6fhrQP1{XGD^x-Sf_a&I|T%>r1q=hDbSrSlQ37 z<6rmAco}|Qe5au%+yUPI4F2Due00nYkJ=L(< z=42?3@qgIf$2$6x`}`h^MPK*9K*xZC>b?IJqh4XfU-|1`hL`-){u#eg@FiAJ!ro%{ zc8)nE+*{lh?i3>RPi{~5SLYUIw0(fAa(+-b_z7Ej$$tQze-Qhv?vDh~9T@Kb(DgO& zsvB{!5%y4p{2>%v^?!r24Dkp0pHWEe%?w=PMIV^j??i}O?G|=_dy+j8JKjU2eg=;# zPyW1_*wQcP%$W1Z{7#Ucj3VDTM3lY?q8&wJ?-KpmgP`ZEmGGdioCDZJ#3|*rcW1hb z-0tpb=cHZS?qq#~o_^u|AA*UU{KEce&jDvPfWbE-g_q#$Lty~5f-=muR8SNN|4!_l z0mGaPkID8Q!Xj@3jmaj~DS0^~hTzBImYyE}!HarJ!Nh9CP1M$0CQ^?p3Sbt;5 zx7d%{FWCL;hwW5*3qS7zi%+rs2v!jjCxVr45@A-rnK}gN%y}LDHVX;7Nrv?{<8hDD z`W_}f+4&7SzR7Loj&MJBr(q!@oYi=8cUaUc(5eb{dY)N#@>6`rZ_V28!t%s$x?l~7 z#L&TT@{n4fN}zJ-mAvRZiKu!0KL2ZM;%)y+czkuR zYI{%#Ha6Y*99DVVs!opdgx%S0W8ZCu$dg7B{8B5C)2sd9puh%m%4}C190W{o$nZN5}DeEWS8ZGD65^| zxA$v-le)u>U+Veg*wjrk*g{pA^iq zUbVx{Fz2k(ggE^PtilbQWX>y`OuM!{5-*rQzH{CG5sRAQKjT-0lRSp*E8;1gVGSL? zq$bSuW_+{^R{$$_DY~nN_ciDL@JisIqm@?ro&y@Bb#>Ube&%p&QKWsI2aDR7haKQ zmj~mT!`teEaVfBuugMS_lFx3&f@d)6@zjs{5wUaOZL9t5c=b}|+>Tiv_16ZQtk2+X z9}q8pOIhZ-?{i+Z@(9wUJA5{2M^+7-&*^ui_Kv^Z?WjRh#POh+1fJBKzPiHNULQ~k;h=Zg&R*KNrTwe1V4J>l?m2i<~WyV_bGp8B7=wE5uamMFEG~^@w_qA5GDn$ zTAj%}S~&j$*(wvEd%CaVZ`Yhg&Qv1)L@K}wK$t$ruSjr%c}9s~HuaoW7 z5L^Z)mLt)b%V6yMy3>C;Xkpd1_u6+m?>eWQ;%)`^-h8{g;xu+XATs|C z6kdY_ry$+Ci8~2F5)7&q^@A6gTd zmz0lZe_LTV&yz&CA@*?l6)YjqUQMl{l=T}CXe9O1(aiH@{3Jd23wxUZ%Dl>qKOrWS z0_B!kZ^DNMkkN(6QQH{N<@m+>at#FVH{y#xn|B4uOFxUW^kA{h_rOvJA2e%R5%7QfSAn^(ovK(!Xu*cd{?f2klP3%j=;u=JViJ;5l;7Y4}+&N4%YtAh1_3vS< z=ltS99jd;avC$Ib6V;h#6*tj6!943ZlVBjFscn`FHlx>UzY`Mt84uZl)%PR%&Lxje z;SN>_>mc9f!OS~R6FTBu^loQ<4PkH=wY%qtYF%JjPr%AbVxR9J$%Xbd`;>jw-fyq7 z-?3}ji--&d$)sL|F}((NDjF;Y_geY4lhqvY{_^etU8|92-s^0~mpZv^kmX|Mb>|i5 z2`8|J!gp`C-ocN4MXSgCn!$(M*D6gWxejd)gG+x%U4Az*{s#HpN5tsoC;5B4?Nn0I z{af*a+lf0PK*-YAOF;ILXLYd0A<4ISO-8Og?FWesIUqn&>MEbH_J(-CC8FhAUW@&Y zz>kLL{chM?BM|C{^RPP*rg(>Y0WNlnvzNNb{q}lnd>B=V)gb?yu)rL@KhpG&jpp?n z)+9zV7W{h_1iXsgtNDL;+q?^22HAE);@1aQR#7}-Iu_awj@yX2&9xWVU)nSArq)ET zWc!HqA@!0v)CtytF6GG{_7P*2<4J3Y+6Vkr!EIJk`#$HS^N>5l9e}U@>%4`wFW4V~ z%o|zZ4*a|V*T3YKA-CN`9&(m@8K2`rU14z@u&1Z6+V;r6hs}0Eer2)98hHBB`{yhw-9|pyCCz zy%rz6KiEVJN%oIrfda?z z%*ocjRxP`iJ%(2wsvVBK21Zhe`+)nf!oD!-GuTmonA!tKe}o_R_Xm5djrIh*xvSfb zs?kC0?`H0WJxtYM1yz=_!6Z0Qm{o0nL#Lz7aj=^&h`v8_=W99mI6wHB8GnRiTft!G zf#P@g<^42f_#oE`V*}se_1&p@{y@f(2v@2DFAdwjQJcF5&921bn!wgi5Mh5nw;Mpz zj^tVYSR0U<>$b*!>$};`ET@w5t=+*+u)pEn)N!=c9uGc@2k-R%1>4eL9__({>5RAw zUa&L&xw75F-qArz-gyv4HwDd%#(F+Q(svV!{-A=}EzQq?5s`AY&P~@G{{6!syFZP zGhyfT;6#J4-KoUGDIoSd;_JK2vkkS7Y^--FUUr0gUCoi~Pu$Ha%jyPGJ5~L1EZpK= zvW=6}r$!S$+ViOvaMj+duCG1ugY~Hx2+h-(fCa;iuE^t7h=@qCuQ`!C@F%7WIc_a?vI~<)&2|uO$B*oQU$t~EUBA)nVRWm&L(H6GuSER{0O?#09htb0d(JuH@n2qZ~p{b??WcjkU7`pGgYZ&4yMYOizVlRRG(05szz3` z9n2kwA8p42cLu|)R(2t;T zo=U~r_|GC(+{egtAi5cZyq;yYPonQe%%CR7)EB$i%?x*dRG%ZYdU)GGyyXY(sEtGm z5o?(}fN1xzyOI0F9pJfdIT_9}yAxJDiTchZ_*@&R^qYx5Q(%W{u!(Y9eG*R*{EAMu z;nOqFMH~2OE40;uHQz$+b_+H=oC?ARc-EUp;YoB?iM1c_|Dm!p5l>x6^{$Sy-YM+f zN2I+McJ+djXU~GQZN+{=)(`Nh24v(XsmHy8v?hR%d;CJkcQ{x4gq1I1ebuWlyC$>Vza@vHSj>=xKvUwGlq_FMVL^(Oale&GJXHm8=e9Nb$6 zBHP5JsaTmbe#rlZNVAYy%PGGwqd$R!ry|AA@yLN(Q5p40B=S47lNssTFkgZWk$G`!L2;cj-nC!4t2E$Z%d9tD@~voBNkss$_gj8!$m>(2XsFxPpo zoGnDg)Sx;z@D@5=50XrSv(&`G_mjDy@p6ofwLF9F@2BqsELFKhza8>6ouc~YVXRq|r! ze=XPVN({KnmBx`9^dc7DPb_(YjQ@n+9Co&XJCDy$37Y6e-8(}!g?>Sw%bd8~%|1&# z9Hb!H&VbN;=oz8h?JoLvHbT8fJO2x@XK zx%Xh9fNrUmVE{L?aitN74q{9E0I|HQ@7qQ4PDFksE^0 zuJbonoI$*J6yA51Jo>}@D;x){2jQ7D$Q@7MB{RsEx{`mkL^ch`N2*cT>&m*;=GT%Y zbC0w-QSZ2QkNv9s1@m>C(!`-MaG8o=(Kh>Y7BJ;1?cGEF27K!4s}pPucVAW%g$Kr0v;RtYi;g&tc?7FwG?7 zvjkStf%}wasaH+IBQCPvJ710T?*s8hGM6Ou_L8;MO17KX zz3u5_*Ej5Qu#N5HJiD0vP@a5Avv-lb4W=6nR**?m%1?cLR8WJ zg3*I2u=uXrV@$RFf;;vHK{6S601UA?^M0Fb;~$t(Bd+=!Y;XoKc?-{>q{D;;T63rb zCBqq;VnHtmrpW%+{N@f?3V^(9n?HRWV|7S4nPR1RHl*{Jx=1;jdcR$`#oT|-l zSmFk}^-rv>IB{wK7&Mg?ZRdGSJ%L!3k-J&1qNNRteTC-?iZIt|)HE#+;0Qjvm>PY5 z)>Re@{0TX?26rxy@vZ}tmx9`V`5~n980=#V9aj`m72>K@|xOzI4c!OkLNk9p)*#X$Xr#M@qs`VrDy0ms=&CR7N1 z){{HT8n*;9t&E41#*Qz-rdH!A1CeZb7~EO(F&_zbCU(|@kJNybRe`&7;yN#Z^E2V6 z>tTh5xT8>r=MQhE=GdQkEkO61c^+dg<89#H=G(~TIi5bKLB14_lm5&4R^CPvQAIM#DsasURemdae^Qd1f$Im`xe(y5kaAeZ}PFR#mo4S$y z14CK{*ZCO6G7U~W7N+LB^-8dmo;vF0;k?E>xsE#muC{Cq#prkSpx6ajedpcqw&HssQM$Ogvp?BiST z)iHei6t>g|_FR^GxPK#~y>P9S%(Pi;i^OVIDP{QCtG{2)J9TfuC<;rnGs z`)~5yocwjy=1H5z%=cMV{1TY^EKmQnMQ_ddsb*Ua=60P-{x2l9jxj%D#-FqP&lr7U zer|OfZKor7J;!=Gb7_dR=xLaTd1;)x_>DTy79*CcKfg}tISfD8!)&)Q+n=$jO}uu& zJWlhD>sY$>zv|=U)2VJmpb=cT@-6>hQNFPrO#) zCuO;-pG!2@Mdj}|Ufa0JZ>-@Q8T1v#*U2x%sitXQQG`o1T4?w%<^b~D*W>^!Stj}6*;X9q; zQHoau?%P)8YxUUCIpW%(pk2A&K7*w6EV}lk=(Hs5{nCydbqguRC-uy*p4c|K zTeL?@J3aJFxONMv2Z1Uu>S(0rjJ4Op?BP;h{YqRvJ%6Rzr)72?sz>9$ykGlm04hdH zM@r>+rzEVIn!S1I9jfQEFZ2FCk*S_=)}8~iA3~qgzBtomO;0)NS${okt!I$cVd;GS zs`Ny?_8aQ?^Pd`LBQY_Y|`-T}E|gLOm@i%RtXCHk z*@rAc&*AHj{?+ai_2D&rZ?r=|`_Hw1SvzXAdqLXK&IdjFZq69id4l?_*}bhbYJY^; zF=lpyXs?*|%bWcz`mE^-qx~2*@7MF++CO6Y`D-u7Io7M^xApA1JV$*$)H~7a(KdUz zt|9v)VAvu2PCJ|A13HoVTE0bTx1r4^%t>3?A)*sf)UVF$f{y2}HZ9*~E21Ht$YAVF zD=>R|%pM^1vQR%5eNJZss*j7=OKv(?=;R6cow`Pq;VX4W)-&_k2c|tAvR>`S(cUn# zYgxNk^jz;{bR;dA6TY<1=`<@j!dlc{%zQ@sWHg@k2WyX$IXz5Xq2BqGuov|{(aW5v zB2UuJ328)opLO1_I)SO1z!^q9j_n-he|eDhrkI`~+ApAf9@>jt1|Pm1#F1aidL{XS z^INsg&h$mndGo>@^@>)fXzd~~eNeR@M=LdZYRxWGqi5}8GW~bd8>J+&D#u^#rW7)o zz2AH^|MS}IQLsl(_AQ$@$(8=bvUM7o_BNUB2xhO6_6+HdY)?CfDkGcHd?id#mjd;L zl}5CeNdB3{rwhhA!|0l)a7cEozAO5y`Vh!&3wjC2chwC_`=7NtN4}~32kO%~R$4X-}ltEoAm#N&f1mr2R3HkFF=1)p%xKlG!z6xbaqvb3#*dZSBX>YGn0VzwEda z|CUCE+RLZzqFSM`Ctch0xYoS2>r4n#;M0<__Gf8_lXh*K;a}mr?Ai1cGf1I6uWcAupW@c@6;b}*q)}Y-$(vv*6{K@RQRA+Q`?8rdc>HJo{S+K`Xb2q!^ByYuf_0N`9D>iHAv-%wv z+bq~SYkCEk{aHdh;hqrUzaBe^S+e*zbJZ?FA+5Bl*k^jam{pmTMe`-7UGVAo2&~>UyC4mfGv9 zE(``QN!QUh zih{Ci)2G5=RMUIa?D^N8Pw7P3Nk=D=zWP@xwkX;tmT86Zw+PqK4m6Ezc8A9JjrKMQ zBZQBdzjm`}FP&^crz`3tD@9&;n)GBWKyh9+rqw00Iz=;GMI*|tbdr_gzW9~899+XD z#4fcKaVX6|JD7D1GnRJMDZBEFHV-OZ<52z4BcBMUn#q-A( zQiriu?Wi@8O^i~^SK3k+b*(!Y`HD|!2dVK&voF@{!c~kFW6F4 zY-@L>V!1(9#g8PUlgBL7XG2|DWcBJoul?Ub6_4CRQZhX>gy8ZL%|e(af6xw2VMjDckY*i=}a3wJ~>D$Ci%}_gUwaZlX=(kt%xlRtFnX^(7n2q)o8fy?gR-8!7pMk8|^z{_BD^_TysdS{Co#y0M z;|a1}S&czJeWi}HvT)&y#+O~m9@O7Ju~+d(eZ90ZTUc*wPWgoPwi*#?so< zSwh_oRAZ5T)Vol*gJQ2ZvUFo&rPeDhBkrWmBqrKQ#*}@l9PIWTnCw;i7y>zOR)V4xw&r z(vYl6t1`U~q(S}FUUBtN7ZN%7*VT%o14SEUzlJOP*QHDTE%}O}>MHV>()s=@lrSD4 zf7QE$1oBwP#?%AM=_@9V==wrXX-6y5I)u=sQ=GA1&7z>sl)R?^dri-ig8t6po647j zE=F$!^OY3zQ_WU8u*GC#mx`Pz*rIYG^{0}bYOac0lB`~`5=l-Tt^OpYLxh;DVHcW< zY`6e56<_r!@fWSvFh_9&tx#vY$ciLsaWvDTPID2`Nm}C7(xbS8htHm53^5a-qKSSc zvYGzHitI+08bLTM`I%0OG2U;ocj1t7BH@g7>#I%@B@(FCXtHF(t4z$3w@3pf_K7Wu zBlz$P)3r#u0LIScb9?*`v@`SYe`}@l}0NF;l99A5bkq2%Jb2WdH7kuM42WSt!d(5%%s@O(C~7cBGcN? za_NLINlhy@JwC(~OrEbuZBB4ggfjcdyvngtX`RjtU#wICh}R?wXj{0%=F8V%*8Qe2}XX3R>E@0O{^-Nf{lh!e+WC8t*IMQ$l>z z29*QIYvi-4b<64t_?CmrB@;z=lYwY8LQ7eKEZCr$!9-b*utME@3=>p5(3u)y_R^cM zM)MWhH(8^}MD;USzUf&hyp$FV-U*rXZjG);A}xu7(Y=Yk+zJzDEC$lW_W;d ze_6X?NrBu7Dz;juG$hYcmu7RSw~@ZG3NaDIcVU7u2H~#WElDc>HPu&BBi76eQ#V<- z5ZbVB;g8NG5I54v;9`iXw5XGxW~9E3rp{H2Rhrl*#$)QPvM%AI;+ABmDvIn-UL>Zk zx`nZF%}Vl@M@b*jf_Vu&j9v=v(+I0%r;>|ee?cXp2rNveB?=`>%omR}5>Yi%c4jO> zt5ftcKQRo_SdP)SSd{EZTwA%Iv{%prR2CsiQvFI-F&&%!i$CIgs&i=NLVmFVdA}lz z{JWqYDf>0|TolQbv1v4AfhJp3p4w~EKArV5M15X_A9xdOJJ zuVh1dhlvCQau8qATum)TJ|RmoeX*2<7^W=SRNN3l)E~{t_@6#2TrKD)WO8$J4@9#T z>r*@w{);24+9;F}vdbFuoqj8hVlrr5U1MtfhFh45jbU2yCX?}-o}KbugYA-o5J23~ zR7kW6)Bj7HQ)3yanfM?X7cg8QpX8&g*W4#FEMC?i6fqTdNx?8BRUDM5m@d-NXF(N7 zwx&oWOOrGeal`|3t%7=v;VI_Kb|IwVvoa*j-PoJfAlb_U#l;QxH3VCc>xcQABjzfU&vqO zEt;RMtN5;5TGlN)Hr->5@5-hXwUoI^X7WtgkJcbYCmtp%)JQ^eGm@}fj7e)TxtGzB zsk0fZ)?GAdLy}Pzp;#%qlw}$Fl!pofOx|udtHDR%uJkJVksf3piY{Vx#)b@c(u@>w zjIOkH#bDhfD$dx(7R?;wXW}c0_2Ma#h4L4TBQKF04a(~Ni@LB%%Ze(B9I7Fyf4D4A zvKJ~S0*ieWoJK5LGIbS25#gm|D1GWKgKSc)K$fM5Y_e2wYspme&}_8of>R_UrT=6l zy$i{t4M|hcRvsb#E*qB4WR3bGKh#T>qG)TlhcvJLazbozTroJ4=@&$B6JuC1V+(go zPAzmb`G*kiGV72}=~{+Q3*AhfF0B^aU(na;F{pDZOx`5FHTbTmU4Zra+GLz&o@OLf z4hoHRVo;6y>K)?k#@Apg;5@=wi7bvb#2snsYp z8Xh5QkVh8ypNYb<3&}-jp*0oMR%D@uQ)pzx19MWdGNyv6igM!rVxjR~MF{z=Ji~BB zeP_CV3l((7KwhmHp1P|VMxcmm)+uR8n}(^GxFKuN?@in)_?k=eM=~;~sVrGmt#yf? zntq3hr{?p9)v4Mk3zf$i<}TJOAJU2okjcnZBMGIXHQAnGs@5g{Fwsx8BF1TSs|cg0 zW|*BSS<Pg)g*nR^8VoJ+qq zHAW$qbS&F7es5y7_+)|A$s;tb!5>+G(B5z$)j1?xaa>bRFyG4tq(99=NMN2F(Ab)n z!6G5Hc!lJw-%GaY&8$`H8m4QdR&3Bp+(I^|Pneh{dlXI!#msfYoivu=VCJrnJlNQr z)+!5>4)j-i&*VSSvm&o#ps&T271xyM6hz_z9xZH<{itSQqK0f;SJ9kJl|&pzo@#7L z`L>?tGG~wIy88Klwl3c^)j-vxWPN5`hLNjYYP?9=GQZLMwHj$(l}d2~gE5LF(w2!0 zvUKU%+?UY`WZjaYzE+$zYu0>JeKL0s6;%ud7%Y>m7=C1MRF*3}8a`#JDtcN$_ri>H zZN@ft!_5Dx0Lmj}kFq{RaT8_rzv6|#2a|0X`;;ZfOHH41#ZtXbvNL(1vTMy=Yfu&@ zWGTQcS(w&r{6y6sX+#n;TvRjBA6bx*zU)j_H=i?^ndEI=n!UNQ@z{42@JHkH>DV5IO;cU4s_G*&0Sm3D;?hSjMOAnu`fY-$vSuj-D!c}CD^ zLpD%=;ARxziSVJ|IT1x1#XHGC^An5GbAZMt4VROgHIlL!&B??${nTK!)}ZSbV6WCD zJTquxYGIOz{>mqWvnJy!;1dSPg+^wTvJAaL99s2Ot=f3KY~T1Qs^bdMzv7U7E?iNL zrZ}l_40kt}WBkOdQKOj^NyCPh7TA4(-|JJx7XHhjC8PgvQe&9tSAavhw`ks9rX$={pL%5svQ@DM@do*o5L^5~F-Ko1UTPi6n1rxG z1g%aC;J=y4ZX_e2f}ST)C8gk5P;nyjZpB@VDjBIJs99>BCX-^8~}+>tCyRM)#z zz1Oov=A1Y)2i={}%*{zJ=IJ@jLGzSFXny)$k=#_E433#-X0k^`29x(H?g~qFN87AZ zcajuQB@eB|V6G5JIiRFf5Yr3pRSGv%Y1ExuJ@seuW?7c-L-?wym^5ZIpt_og>WX!W zrKa9to>wq67Gp1xxo};+C%-lMqKTEdi>T*ZjQ<(yQSDMyz=HF%#1{*m50!?cDPt?L zB4c-2pE68U$V~(mYcX=v6(s?^TN$M^EXl~bbzRlSWQ{^$!))}OVK=6Rq!k!EHg##S z#)A7i=1C;!qTppBkiIkV%VeoWcBUR94z8Mj-eY`0ql-JqlN1#SVuIdbxSpwfs6wy1 z+2-D$Y(o-NeqfMFvo>BKTsE9cxs3A5@;ujBlgg?^hnvgnoNLI=iYoMQoxoH28<3vM zUWmi6@f$qP`3uj4@8|hF(@);TCNj{0o~*3KbLr}!Y)<}=UP>{tDx4WSb$>rk84DY# zaIM1Fc!=*SAWc1&r0S+JD3^DK=)QCc>o-p==`R1Z{Hv)tAa7JxbKU(m_mM)3q@QXB zgt|6Mhnaz%1-**?4EHm!Nwz6ITws6to%pEoP}!Z~`kJ#jC(!t{uuW$tn4A{@@kiN! z7?M0p_F!t=@-K140vr;m>8bI{;HJ*UGd$gJEHO00hgBIDekq0ffzI#a-TB{jJ7$%A638?=VlI%sj-*sm) z6Ukr5_d)r(o;Hy08?GQZD&y2xrnV;>63;ZgT#ySGqYN$>-lRNUII1kf)PseC@=|F;J|sz*YMx<4`kc8ZA{17Zt7xUzq$fXAfiN@D zXXWcAjtFTbUr9#ZZSHdzNeeH{dUS{1a6nzt#1Uyws9aDxG8{o(th@2%i5hcKqQNAC zsk+xD1|d0$wTs)C6HX<6!(xQ7>IE

p2^-1U&;L4A7HMV&SU)$QI1~Fj<>WOZP%l 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

^_G=py-BTR6b|h$b%LwKEV=FQ=BZiL)vu$d>2M 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�bxc~*Tm6En{%*8t%7Wwc;O*!<^IPic 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 z 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%0DP2KK~ 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

eifL3x@f9)m%2-;cCOoV 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 z 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 z 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
CBcFj+imRVw5zQZ%I3F`VS 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%0DqijfLQDGRHIBdubc^KHmhjM*oMYV3J>WT`z#h-T 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 Date: Thu, 25 Jan 2024 17:34:23 +0100 Subject: [PATCH 45/57] ci: update ci model used for tests --- tests/inference_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/inference_test.py b/tests/inference_test.py index bd5040394..da28b79d2 100644 --- a/tests/inference_test.py +++ b/tests/inference_test.py @@ -9,7 +9,7 @@ from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel from pyannote.audio.tasks import VoiceActivityDetection -HF_SAMPLE_MODEL_ID = "pyannote/TestModelForContinuousIntegration" +HF_SAMPLE_MODEL_ID = "pyannote/ci-segmentation" def test_hf_download_inference(): From d115e9ac94c2b05b419799765e8efd05468d4e95 Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Tue, 30 Jan 2024 11:21:08 +0100 Subject: [PATCH 46/57] feat(powerset): add `Powerset.permutation_mapping` to help with permutation in powerset space MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Hervé BREDIN --- CHANGELOG.md | 1 + pyannote/audio/utils/powerset.py | 105 ++++++++++++++++++++++++++++--- tests/utils/test_powerset.py | 27 +++++++- 3 files changed, 123 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 15b5b6aee..6ec76100e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ - feat(pipeline): add `Waveform` and `SampleRate` preprocessors - feat(model): add `num_frames`, `receptive_field`, and `dimension` properties to segmentation models - feat(sample): add sample file at `pyannote.audio.sample.SAMPLE_FILE` +- feat(powerset): add `Powerset.permutation_mapping` to help with permutation in powerset space ### Fixes diff --git a/pyannote/audio/utils/powerset.py b/pyannote/audio/utils/powerset.py index b75221e48..6a0716df9 100644 --- a/pyannote/audio/utils/powerset.py +++ b/pyannote/audio/utils/powerset.py @@ -25,7 +25,8 @@ # Alexis PLAQUET from functools import cached_property -from itertools import combinations +from itertools import combinations, permutations +from typing import Dict, Tuple import scipy.special import torch @@ -65,6 +66,27 @@ def num_powerset_classes(self) -> int: ) def build_mapping(self) -> torch.Tensor: + """Compute powerset to regular mapping + + Returns + ------- + mapping : (num_powerset_classes, num_classes) torch.Tensor + mapping[i, j] == 1 if jth regular class is a member of ith powerset class + mapping[i, j] == 0 otherwise + + Example + ------- + With num_classes == 3 and max_set_size == 2, returns + + [0, 0, 0] # none + [1, 0, 0] # class #1 + [0, 1, 0] # class #2 + [0, 0, 1] # class #3 + [1, 1, 0] # classes #1 and #2 + [1, 0, 1] # classes #1 and #3 + [0, 1, 1] # classes #2 and #3 + + """ mapping = torch.zeros(self.num_powerset_classes, self.num_classes) powerset_k = 0 for set_size in range(0, self.max_set_size + 1): @@ -76,13 +98,7 @@ def build_mapping(self) -> torch.Tensor: 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 + return torch.sum(self.mapping, dim=1) def to_multilabel(self, powerset: torch.Tensor, soft: bool = False) -> torch.Tensor: """Convert predictions from powerset to multi-label @@ -138,3 +154,76 @@ 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, ) + + def _permutation_powerset( + self, multilabel_permutation: Tuple[int, ...] + ) -> Tuple[int, ...]: + """Helper function for `permutation_mapping` property + + Takes a (num_classes,)-shaped permutation in multilabel space and returns + the corresponding (num_powerset_classes,)-shaped permutation in powerset space. + This does not cache anything and only works on one single permutation at a time. + + Parameters + ---------- + multilabel_permutation : tuple of int + Permutation in multilabel space. + + Returns + ------- + powerset_permutation : tuple of int + Permutation in powerset space. + + Example + ------- + >>> powerset = Powerset(3, 2) + >>> powerset._permutation_powerset((1, 0, 2)) + # (0, 2, 1, 3, 4, 6, 5) + + """ + + permutated_mapping: torch.Tensor = self.mapping[:, multilabel_permutation] + + arange = torch.arange( + self.num_classes, device=self.mapping.device, dtype=torch.int + ) + powers_of_two = (2**arange).tile((self.num_powerset_classes, 1)) + + # compute the encoding of the powerset classes in this 2**N space, before and after + # permutation of the columns (mapping cols=labels, mapping rows=powerset classes) + before = torch.sum(self.mapping * powers_of_two, dim=-1) + after = torch.sum(permutated_mapping * powers_of_two, dim=-1) + + # find before-to-after permutation + powerset_permutation = (before[None] == after[:, None]).int().argmax(dim=0) + + # return as tuple of indices + return tuple(powerset_permutation.tolist()) + + @cached_property + def permutation_mapping(self) -> Dict[Tuple[int, ...], Tuple[int, ...]]: + """Mapping between multilabel and powerset permutations + + Example + ------- + With num_classes == 3 and max_set_size == 2, returns + + { + (0, 1, 2): (0, 1, 2, 3, 4, 5, 6), + (0, 2, 1): (0, 1, 3, 2, 5, 4, 6), + (1, 0, 2): (0, 2, 1, 3, 4, 6, 5), + (1, 2, 0): (0, 2, 3, 1, 6, 4, 5), + (2, 0, 1): (0, 3, 1, 2, 5, 6, 4), + (2, 1, 0): (0, 3, 2, 1, 6, 5, 4) + } + """ + permutation_mapping = {} + + for multilabel_permutation in permutations( + range(self.num_classes), self.num_classes + ): + permutation_mapping[ + tuple(multilabel_permutation) + ] = self._permutation_powerset(multilabel_permutation) + + return permutation_mapping diff --git a/tests/utils/test_powerset.py b/tests/utils/test_powerset.py index dd12eed41..e04480753 100644 --- a/tests/utils/test_powerset.py +++ b/tests/utils/test_powerset.py @@ -27,10 +27,8 @@ 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 @@ -51,3 +49,28 @@ def test_roundtrip(): reconstruction = powerset.to_powerset(batch_multilabel) assert torch.equal(batch_powerset, reconstruction) + + +def test_permutate_powerset(): + for num_classes in range(1, 6): + for max_set_size in range(1, num_classes + 1): + powerset = Powerset(num_classes, max_set_size) + + # create (num_powerset_class, num_powerset_class)-shaped tensor, where each frame is assigned to a different powerset class + # and convert it to its multi-label equivalent + t1 = torch.nn.functional.one_hot( + torch.arange(powerset.num_powerset_classes), + powerset.num_powerset_classes, + ) + t1_ml = powerset.to_multilabel(t1) + + # then permutate the powerset class in powerset space AND the multilabel equivalent in its native space + # and check it has the same result. + # perm = torch.randperm(num_classes) + perm = tuple(torch.randperm(num_classes).tolist()) + t1_ml_perm = t1_ml[:, perm] + perm_ps = powerset.permutation_mapping[perm] + t1_ps_perm = t1[..., perm_ps] + t1_ps_perm_ml = powerset.to_multilabel(t1_ps_perm) + + assert t1_ml_perm.equal(t1_ps_perm_ml) From fea5c2951e6070342d43a6f305f0f8d28c457328 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Wed, 31 Jan 2024 21:55:36 +0100 Subject: [PATCH 47/57] feat(metric): add `reduce` option to `diarization_error_rate` metric (#1635) --- CHANGELOG.md | 1 + .../audio/diarization_error_rate.py | 94 +++++++++--- tests/test_metrics.py | 142 ++++++++++++++++++ 3 files changed, 220 insertions(+), 17 deletions(-) create mode 100644 tests/test_metrics.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 6ec76100e..4090c9c4d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ - feat(model): add `num_frames`, `receptive_field`, and `dimension` properties to segmentation models - feat(sample): add sample file at `pyannote.audio.sample.SAMPLE_FILE` - feat(powerset): add `Powerset.permutation_mapping` to help with permutation in powerset space +- feat(metric): add `reduce` option to `diarization_error_rate` metric ### Fixes diff --git a/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py b/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py index 9502a527e..1fef2cc36 100644 --- a/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py +++ b/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py @@ -33,6 +33,7 @@ def _der_update( preds: torch.Tensor, target: torch.Tensor, threshold: Union[torch.Tensor, float] = 0.5, + reduce: str = "batch", ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: """Compute components of diarization error rate @@ -44,14 +45,22 @@ def _der_update( (batch_size, num_speakers, num_frames)-shaped (0 or 1) targets. threshold : float or torch.Tensor, optional Threshold(s) used to binarize predictions. Defaults to 0.5. + reduce : {'batch', 'chunk', 'frame'}, optional + Reduction method. Defaults to 'batch'. Returns ------- - false_alarm : (num_thresholds, )-shaped torch.Tensor - missed_detection : (num_thresholds, )-shaped torch.Tensor - speaker_confusion : (num_thresholds, )-shaped torch.Tensor - speech_total : torch.Tensor - Diarization error rate components accumulated over the whole batch. + false_alarm : torch.Tensor + missed_detection : torch.Tensor + speaker_confusion : torch.Tensor + If `reduce` is 'batch', returns (num_thresholds, )-shaped tensors. + If `reduce` is 'chunk', returns (batch_size, num_thresholds)-shaped tensors. + If `reduce` is 'frame', returns (batch_size, num_frames, num_thresholds)-shaped tensors. + In case `threshold` is a float, the last dimension is removed from the output tensors. + speech_total : (...,)-shaped torch.Tensor torch.Tensor + If `reduce` is 'batch', returns a scalar. + If `reduce` is 'chunk', returns (batch_size,)-shaped tensor. + If `reduce` is 'frame', returns (batch_size, num_frames)-shaped tensor. """ # make threshold a (num_thresholds,) tensor @@ -70,6 +79,9 @@ def _der_update( hypothesis = (permutated_preds.unsqueeze(-1) > threshold).float() # (batch_size, num_speakers, num_frames, num_thresholds) + speech_total = 1.0 * torch.sum(target, 1) + # (batch_size, num_frames) + target = target.unsqueeze(-1) # (batch_size, num_speakers, num_frames, 1) @@ -87,17 +99,47 @@ def _der_update( speaker_confusion = torch.sum((hypothesis != target) * hypothesis, 1) - false_alarm # (batch_size, num_frames, num_thresholds) - false_alarm = torch.sum(torch.sum(false_alarm, 1), 0) - missed_detection = torch.sum(torch.sum(missed_detection, 1), 0) - speaker_confusion = torch.sum(torch.sum(speaker_confusion, 1), 0) + if reduce == "frame": + if scalar_threshold: + return ( + false_alarm[:, :, 0], + missed_detection[:, :, 0], + speaker_confusion[:, :, 0], + speech_total, + ) + return false_alarm, missed_detection, speaker_confusion, torch.sum(target, 1) + + speech_total = torch.sum(speech_total, 1) + # (batch_size, ) + false_alarm = torch.sum(false_alarm, 1) + missed_detection = torch.sum(missed_detection, 1) + speaker_confusion = torch.sum(speaker_confusion, 1) + # (batch_size, num_thresholds) + + if reduce == "chunk": + if scalar_threshold: + return ( + false_alarm[:, 0], + missed_detection[:, 0], + speaker_confusion[:, 0], + speech_total, + ) + return false_alarm, missed_detection, speaker_confusion, speech_total + + speech_total = torch.sum(speech_total, 0) + # scalar + false_alarm = torch.sum(false_alarm, 0) + missed_detection = torch.sum(missed_detection, 0) + speaker_confusion = torch.sum(speaker_confusion, 0) # (num_thresholds, ) - speech_total = 1.0 * torch.sum(target) - if scalar_threshold: - false_alarm = false_alarm[0] - missed_detection = missed_detection[0] - speaker_confusion = speaker_confusion[0] + return ( + false_alarm[0], + missed_detection[0], + speaker_confusion[0], + speech_total, + ) return false_alarm, missed_detection, speaker_confusion, speech_total @@ -131,6 +173,8 @@ def diarization_error_rate( preds: torch.Tensor, target: torch.Tensor, threshold: Union[torch.Tensor, float] = 0.5, + reduce: str = "batch", + return_components: bool = False, ) -> torch.Tensor: """Compute diarization error rate @@ -142,16 +186,32 @@ def diarization_error_rate( (batch_size, num_speakers, num_frames)-shaped (0 or 1) targets. threshold : float or torch.Tensor, optional Threshold(s) used to binarize predictions. Defaults to 0.5. + reduce : {'batch', 'chunk', 'frame'}, optional + Reduction method. Defaults to 'batch'. + return_components : bool, optional + Return diarization error rate components as an additional tuple. + Defaults to False. + Returns ------- - der : (num_thresholds, )-shaped torch.Tensor - Aggregated diarization error rate + der : torch.Tensor + If `reduce` is 'batch', returns (num_thresholds, )-shaped tensors. + If `reduce` is 'chunk', returns (batch_size, num_thresholds)-shaped tensors. + If `reduce` is 'frame', returns (batch_size, num_frames, num_thresholds)-shaped tensors. + In case `threshold` is a float, the last dimension is removed from the output tensors. + components : (false_alarm, missed_detection, speaker_confusion, speech_total) tuple, optional + Same shape as `der`. Only returned when `return_components` is True. + """ false_alarm, missed_detection, speaker_confusion, speech_total = _der_update( - preds, target, threshold=threshold + preds, target, threshold=threshold, reduce=reduce ) - return _der_compute(false_alarm, missed_detection, speaker_confusion, speech_total) + + der = _der_compute(false_alarm, missed_detection, speaker_confusion, speech_total) + if return_components: + return der, (false_alarm, missed_detection, speaker_confusion, speech_total) + return der def optimal_diarization_error_rate( diff --git a/tests/test_metrics.py b/tests/test_metrics.py new file mode 100644 index 000000000..c366dc091 --- /dev/null +++ b/tests/test_metrics.py @@ -0,0 +1,142 @@ +# MIT License +# +# Copyright (c) 2024- 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 pytest +import torch + +from pyannote.audio.torchmetrics.functional.audio.diarization_error_rate import ( + _der_update, + diarization_error_rate, +) + + +@pytest.fixture +def target(): + chunk1 = [[0, 0], [1, 0], [1, 0], [1, 1], [1, 1], [0, 1], [0, 1]] + chunk2 = [[0, 0], [0, 0], [1, 0], [1, 0], [1, 0], [1, 0], [0, 0]] + return torch.tensor([chunk1, chunk2], dtype=torch.float32).transpose(2, 1) + + +@pytest.fixture +def prediction(): + chunk1 = [[0, 0], [1, 0], [0, 0], [1, 1], [0, 1], [1, 1], [1, 0]] + chunk2 = [[0, 0], [0, 0], [0, 1], [0, 1], [0, 1], [1, 1], [1, 0]] + return torch.tensor([chunk1, chunk2], dtype=torch.float32).transpose(2, 1) + + +def test_frame_reduction(target, prediction): + false_alarm, missed_detection, speaker_confusion, speech_total = _der_update( + prediction, target, reduce="frame" + ) + + torch.testing.assert_close( + false_alarm, + torch.Tensor( + [[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0]] + ), + ) + + torch.testing.assert_close( + missed_detection, + torch.Tensor( + [ + [0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + ] + ), + ) + + torch.testing.assert_close( + speaker_confusion, + torch.Tensor( + [[0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]] + ), + ) + + torch.testing.assert_close( + speech_total, + torch.Tensor( + [[0.0, 1.0, 1.0, 2.0, 2.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0]] + ), + ) + + +def test_chunk_reduction(target, prediction): + false_alarm, missed_detection, speaker_confusion, speech_total = _der_update( + prediction, target, reduce="chunk" + ) + + torch.testing.assert_close( + false_alarm, + torch.Tensor([1.0, 2.0]), + ) + + torch.testing.assert_close( + missed_detection, + torch.Tensor([2.0, 0.0]), + ) + + torch.testing.assert_close( + speaker_confusion, + torch.Tensor([1.0, 0.0]), + ) + + torch.testing.assert_close( + speech_total, + torch.Tensor([8.0, 4.0]), + ) + + +def test_batch_reduction(target, prediction): + false_alarm, missed_detection, speaker_confusion, speech_total = _der_update( + prediction, target, reduce="batch" + ) + torch.testing.assert_close(false_alarm.item(), 3.0) + torch.testing.assert_close(missed_detection.item(), 2.0) + torch.testing.assert_close(speaker_confusion.item(), 1.0) + torch.testing.assert_close(speech_total.item(), 12.0) + + +def test_batch_der(target, prediction): + der = diarization_error_rate(prediction, target, reduce="batch") + torch.testing.assert_close(der.item(), (3.0 + 2.0 + 1.0) / 12.0) + + +def test_batch_der_with_components(target, prediction): + der, ( + false_alarm, + missed_detection, + speaker_confusion, + speech_total, + ) = diarization_error_rate( + prediction, target, reduce="batch", return_components=True + ) + torch.testing.assert_close(der.item(), (3.0 + 2.0 + 1.0) / 12.0) + torch.testing.assert_close(false_alarm.item(), 3.0) + torch.testing.assert_close(missed_detection.item(), 2.0) + torch.testing.assert_close(speaker_confusion.item(), 1.0) + torch.testing.assert_close(speech_total.item(), 12.0) + + +def test_chunk_der(target, prediction): + der = diarization_error_rate(prediction, target, reduce="chunk") + torch.testing.assert_close(der, torch.Tensor([4.0 / 8.0, 2.0 / 4.0])) From eba4419c8b46727ffce949bbb833a5a86574f435 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 1 Feb 2024 10:46:37 +0100 Subject: [PATCH 48/57] improve(metric): add support for number of speakers mismatch in `diarization_error_rate` metric --- CHANGELOG.md | 4 ++++ .../functional/audio/diarization_error_rate.py | 18 ++++++++++++++++++ 2 files changed, 22 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4090c9c4d..2944eb72d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,10 @@ - fix(task): fix random generators +### Improvements + +- improve(metric): add support for number of speakers mismatch in `diarization_error_rate` metric + ## Breaking changes - BREAKING(model): get rid of `Model.example_output` in favor of `num_frames`, `receptive_field`, and `dimension` properties diff --git a/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py b/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py index 1fef2cc36..c401b70dd 100644 --- a/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py +++ b/pyannote/audio/torchmetrics/functional/audio/diarization_error_rate.py @@ -25,6 +25,7 @@ from typing import Optional, Tuple, Union import torch +import torch.nn.functional as F from pyannote.audio.utils.permutation import permutate @@ -63,6 +64,23 @@ def _der_update( If `reduce` is 'frame', returns (batch_size, num_frames)-shaped tensor. """ + prd_batch_size, prd_num_speakers, prd_num_frames = preds.shape + tgt_batch_size, tgt_num_speakers, tgt_num_frames = target.shape + + if prd_batch_size != tgt_batch_size: + raise ValueError(f"Batch size mismatch: {prd_batch_size} != {tgt_batch_size}.") + + if prd_num_frames != tgt_num_frames: + raise ValueError( + f"Number of frames mismatch: {prd_num_frames} != {tgt_num_frames}." + ) + + # pad number of speakers if necessary + if prd_num_speakers > tgt_num_speakers: + target = F.pad(target, (0, 0, 0, prd_num_speakers - tgt_num_speakers)) + elif prd_num_speakers < tgt_num_speakers: + preds = F.pad(preds, (0, 0, 0, tgt_num_speakers - prd_num_speakers)) + # make threshold a (num_thresholds,) tensor scalar_threshold = isinstance(threshold, Number) if scalar_threshold: From e4d850c8cffa5af8c61f8931c496f4b29c940f6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 2 Feb 2024 16:52:59 +0100 Subject: [PATCH 49/57] fix: fix computation of conv1d receptive field (#1640) --- pyannote/audio/models/blocks/sincnet.py | 4 +--- pyannote/audio/models/segmentation/SSeRiouSS.py | 1 - pyannote/audio/utils/frame.py | 9 +++------ 3 files changed, 4 insertions(+), 10 deletions(-) diff --git a/pyannote/audio/models/blocks/sincnet.py b/pyannote/audio/models/blocks/sincnet.py index a7657c2e9..89368795b 100644 --- a/pyannote/audio/models/blocks/sincnet.py +++ b/pyannote/audio/models/blocks/sincnet.py @@ -120,16 +120,14 @@ def receptive_field_size(self, num_frames: int = 1) -> int: kernel_size = [251, 3, 5, 3, 5, 3] stride = [self.stride, 3, 1, 3, 1, 3] - padding = [0, 0, 0, 0, 0, 0] dilation = [1, 1, 1, 1, 1, 1] receptive_field_size = num_frames - for k, s, p, d in reversed(list(zip(kernel_size, stride, padding, dilation))): + for k, s, d in reversed(list(zip(kernel_size, stride, dilation))): receptive_field_size = conv1d_receptive_field_size( num_frames=receptive_field_size, kernel_size=k, stride=s, - padding=p, dilation=d, ) diff --git a/pyannote/audio/models/segmentation/SSeRiouSS.py b/pyannote/audio/models/segmentation/SSeRiouSS.py index 514ad00de..e337f439c 100644 --- a/pyannote/audio/models/segmentation/SSeRiouSS.py +++ b/pyannote/audio/models/segmentation/SSeRiouSS.py @@ -243,7 +243,6 @@ def receptive_field_size(self, num_frames: int = 1) -> int: num_frames=receptive_field_size, kernel_size=conv_layer.kernel_size, stride=conv_layer.stride, - padding=conv_layer.conv.padding[0], dilation=conv_layer.conv.dilation[0], ) diff --git a/pyannote/audio/utils/frame.py b/pyannote/audio/utils/frame.py index 5ff0189be..cde7ee19c 100644 --- a/pyannote/audio/utils/frame.py +++ b/pyannote/audio/utils/frame.py @@ -56,9 +56,7 @@ def conv1d_num_frames( ) -def conv1d_receptive_field_size( - num_frames=1, kernel_size=5, stride=1, padding=0, dilation=1 -): +def conv1d_receptive_field_size(num_frames=1, kernel_size=5, stride=1, dilation=1): """Compute receptive field size for `num_frames` frames after 1D convolution Parameters @@ -69,8 +67,6 @@ def conv1d_receptive_field_size( Kernel size stride : int Stride - padding : int - Padding dilation : int Dilation @@ -79,4 +75,5 @@ def conv1d_receptive_field_size( receptive_field : int Receptive field size """ - return (num_frames - 1) * stride - 2 * padding + dilation * (kernel_size - 1) + 1 + + return 1 + (kernel_size - 1) * dilation + (num_frames - 1) * stride From e611d1c7aba7661380aa55999b3d784a63213863 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Sat, 3 Feb 2024 19:22:27 +0100 Subject: [PATCH 50/57] feat(model): add `receptive_field` property and `num_frames` method to every model (#1642) --- CHANGELOG.md | 6 +- pyannote/audio/core/model.py | 18 ++ pyannote/audio/models/blocks/sincnet.py | 88 ++++---- pyannote/audio/models/embedding/debug.py | 87 +++++++- .../models/embedding/wespeaker/__init__.py | 87 +++++++- .../models/embedding/wespeaker/resnet.py | 149 +++++++++++++ pyannote/audio/models/embedding/xvector.py | 199 +++++++++++++++++- pyannote/audio/models/segmentation/PyanNet.py | 35 ++- .../audio/models/segmentation/SSeRiouSS.py | 59 +++--- pyannote/audio/models/segmentation/debug.py | 67 +++--- pyannote/audio/utils/frame.py | 79 ------- pyannote/audio/utils/receptive_field.py | 163 ++++++++++++++ 12 files changed, 834 insertions(+), 203 deletions(-) delete mode 100644 pyannote/audio/utils/frame.py create mode 100644 pyannote/audio/utils/receptive_field.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 2944eb72d..514499b13 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,7 +6,9 @@ - feat(task): add option to cache task training metadata to speed up training - feat(pipeline): add `Waveform` and `SampleRate` preprocessors -- feat(model): add `num_frames`, `receptive_field`, and `dimension` properties to segmentation models +- feat(model): add `num_frames` method to every model +- feat(model): add `receptive_field` property to every model +- feat(model): and `dimension` property to every model - feat(sample): add sample file at `pyannote.audio.sample.SAMPLE_FILE` - feat(powerset): add `Powerset.permutation_mapping` to help with permutation in powerset space - feat(metric): add `reduce` option to `diarization_error_rate` metric @@ -21,7 +23,7 @@ ## Breaking changes -- BREAKING(model): get rid of `Model.example_output` in favor of `num_frames`, `receptive_field`, and `dimension` properties +- BREAKING(model): get rid of `Model.example_output` in favor of `num_frames` method, `receptive_field` property, and `dimension` property - BREAKING(task): custom tasks need to be updated (see "Add your own task" tutorial) ## Version 3.1.1 (2023-12-01) diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index 27f34e7f8..d7a264850 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -25,6 +25,7 @@ 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 @@ -181,6 +182,23 @@ def __example_input_array(self, duration: Optional[float] = None) -> torch.Tenso def example_input_array(self) -> torch.Tensor: return self.__example_input_array() + @cached_property + def receptive_field(self) -> SlidingWindow: + """(Internal) frames""" + + receptive_field_size = self.receptive_field_size(num_frames=1) + receptive_field_step = ( + self.receptive_field_size(num_frames=2) - receptive_field_size + ) + receptive_field_start = ( + self.receptive_field_center(frame=0) - (receptive_field_size - 1) / 2 + ) + return SlidingWindow( + start=receptive_field_start / self.hparams.sample_rate, + duration=receptive_field_size / self.hparams.sample_rate, + step=receptive_field_step / self.hparams.sample_rate, + ) + def prepare_data(self): self.task.prepare_data() diff --git a/pyannote/audio/models/blocks/sincnet.py b/pyannote/audio/models/blocks/sincnet.py index 89368795b..b46549bb3 100644 --- a/pyannote/audio/models/blocks/sincnet.py +++ b/pyannote/audio/models/blocks/sincnet.py @@ -1,6 +1,6 @@ # The MIT License (MIT) # -# Copyright (c) 2019-2020 CNRS +# Copyright (c) 2019- 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 @@ -23,16 +23,18 @@ # AUTHOR # Hervé Bredin - http://herve.niderb.fr - -from functools import cached_property, lru_cache +from functools import lru_cache import torch import torch.nn as nn import torch.nn.functional as F from asteroid_filterbanks import Encoder, ParamSincFB -from pyannote.core import SlidingWindow -from pyannote.audio.utils.frame import conv1d_num_frames, conv1d_receptive_field_size +from pyannote.audio.utils.receptive_field import ( + multi_conv_num_frames, + multi_conv_receptive_field_center, + multi_conv_receptive_field_size, +) class SincNet(nn.Module): @@ -78,17 +80,17 @@ def __init__(self, sample_rate: int = 16000, stride: int = 1): @lru_cache def num_frames(self, num_samples: int) -> int: - """Compute number of output frames for a given number of input samples + """Compute number of output frames Parameters ---------- num_samples : int - Number of input samples + Number of input samples. Returns ------- num_frames : int - Number of output frames + Number of output frames. """ kernel_size = [251, 3, 5, 3, 5, 3] @@ -96,16 +98,16 @@ def num_frames(self, num_samples: int) -> int: padding = [0, 0, 0, 0, 0, 0] dilation = [1, 1, 1, 1, 1, 1] - num_frames = num_samples - for k, s, p, d in zip(kernel_size, stride, padding, dilation): - num_frames = conv1d_num_frames( - num_frames, kernel_size=k, stride=s, padding=p, dilation=d - ) - - return num_frames + return multi_conv_num_frames( + num_samples, + kernel_size=kernel_size, + stride=stride, + padding=padding, + dilation=dilation, + ) def receptive_field_size(self, num_frames: int = 1) -> int: - """Compute receptive field size + """Compute size of receptive field Parameters ---------- @@ -115,48 +117,46 @@ def receptive_field_size(self, num_frames: int = 1) -> int: Returns ------- receptive_field_size : int - Receptive field size + Receptive field size. """ kernel_size = [251, 3, 5, 3, 5, 3] stride = [self.stride, 3, 1, 3, 1, 3] dilation = [1, 1, 1, 1, 1, 1] - receptive_field_size = num_frames - for k, s, d in reversed(list(zip(kernel_size, stride, dilation))): - receptive_field_size = conv1d_receptive_field_size( - num_frames=receptive_field_size, - kernel_size=k, - stride=s, - dilation=d, - ) + return multi_conv_receptive_field_size( + num_frames, + kernel_size=kernel_size, + stride=stride, + dilation=dilation, + ) - return receptive_field_size + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field - @cached_property - def receptive_field(self) -> SlidingWindow: - """Compute receptive field + Parameters + ---------- + frame : int, optional + Frame index Returns ------- - receptive field : SlidingWindow - - Source - ------ - https://distill.pub/2019/computing-receptive-fields/ - + receptive_field_center : int + Index of receptive field center. """ - # duration of the receptive field of each output frame - duration = self.receptive_field_size() / self.sample_rate - - # step between the receptive field region of two consecutive output frames - step = ( - self.receptive_field_size(num_frames=2) - - self.receptive_field_size(num_frames=1) - ) / self.sample_rate + kernel_size = [251, 3, 5, 3, 5, 3] + stride = [self.stride, 3, 1, 3, 1, 3] + padding = [0, 0, 0, 0, 0, 0] + dilation = [1, 1, 1, 1, 1, 1] - return SlidingWindow(start=0.0, duration=duration, step=step) + return multi_conv_receptive_field_center( + frame, + kernel_size=kernel_size, + stride=stride, + padding=padding, + dilation=dilation, + ) def forward(self, waveforms: torch.Tensor) -> torch.Tensor: """Pass forward diff --git a/pyannote/audio/models/embedding/debug.py b/pyannote/audio/models/embedding/debug.py index 775b6550f..a5e862a24 100644 --- a/pyannote/audio/models/embedding/debug.py +++ b/pyannote/audio/models/embedding/debug.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,6 +21,7 @@ # SOFTWARE. +from functools import lru_cache from typing import Optional import torch @@ -30,6 +31,11 @@ from pyannote.audio.core.model import Model from pyannote.audio.core.task import Task +from pyannote.audio.utils.receptive_field import ( + conv1d_num_frames, + conv1d_receptive_field_center, + conv1d_receptive_field_size, +) class SimpleEmbeddingModel(Model): @@ -57,6 +63,85 @@ def __init__( bidirectional=True, ) + @lru_cache + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames for a given number of input samples + + Parameters + ---------- + num_samples : int + Number of input samples + + Returns + ------- + num_frames : int + Number of output frames + + Source + ------ + https://pytorch.org/docs/stable/generated/torch.stft.html#torch.stft + + """ + + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + center = self.mfcc.MelSpectrogram.spectrogram.center + + return conv1d_num_frames( + num_samples=num_samples, + kernel_size=n_fft, + stride=hop_length, + padding=n_fft // 2 if center else 0, + dilation=1, + ) + + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute size of receptive field + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + + Returns + ------- + receptive_field_size : int + Receptive field size. + """ + + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + + return conv1d_receptive_field_size( + num_frames, kernel_size=n_fft, stride=hop_length, dilation=1 + ) + + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field + + Parameters + ---------- + frame : int, optional + Frame index + + Returns + ------- + receptive_field_center : int + Index of receptive field center. + """ + + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + center = self.mfcc.MelSpectrogram.spectrogram.center + + return conv1d_receptive_field_center( + frame=frame, + kernel_size=n_fft, + stride=hop_length, + padding=n_fft // 2 if center else 0, + dilation=1, + ) + @property def dimension(self) -> int: """Dimension of output""" diff --git a/pyannote/audio/models/embedding/wespeaker/__init__.py b/pyannote/audio/models/embedding/wespeaker/__init__.py index 8f1e62105..e75779dda 100644 --- a/pyannote/audio/models/embedding/wespeaker/__init__.py +++ b/pyannote/audio/models/embedding/wespeaker/__init__.py @@ -21,7 +21,7 @@ # SOFTWARE. -from functools import partial +from functools import lru_cache, partial from typing import Optional import torch @@ -29,6 +29,11 @@ from pyannote.audio.core.model import Model from pyannote.audio.core.task import Task +from pyannote.audio.utils.receptive_field import ( + conv1d_num_frames, + conv1d_receptive_field_center, + conv1d_receptive_field_size, +) from .resnet import ResNet34, ResNet152, ResNet221, ResNet293 @@ -100,6 +105,86 @@ def dimension(self) -> int: """Dimension of output""" return self.resnet.embed_dim + @lru_cache + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames + + Parameters + ---------- + num_samples : int + Number of input samples. + + Returns + ------- + num_frames : int + Number of output frames. + """ + window_size = int(self.hparams.sample_rate * self.hparams.frame_length * 0.001) + step_size = int(self.hparams.sample_rate * self.hparams.frame_shift * 0.001) + + num_frames = conv1d_num_frames( + num_samples=num_samples, + kernel_size=window_size, + stride=step_size, + padding=0, + dilation=1, + ) + return self.resnet.num_frames(num_frames) + + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute size of receptive field + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + + Returns + ------- + receptive_field_size : int + Receptive field size. + """ + receptive_field_size = num_frames + receptive_field_size = self.resnet.receptive_field_size(receptive_field_size) + + window_size = int(self.hparams.sample_rate * self.hparams.frame_length * 0.001) + step_size = int(self.hparams.sample_rate * self.hparams.frame_shift * 0.001) + + return conv1d_receptive_field_size( + num_frames=receptive_field_size, + kernel_size=window_size, + stride=step_size, + dilation=1, + ) + + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field + + Parameters + ---------- + frame : int, optional + Frame index + + Returns + ------- + receptive_field_center : int + Index of receptive field center. + """ + receptive_field_center = frame + receptive_field_center = self.resnet.receptive_field_center( + frame=receptive_field_center + ) + + window_size = int(self.hparams.sample_rate * self.hparams.frame_length * 0.001) + step_size = int(self.hparams.sample_rate * self.hparams.frame_shift * 0.001) + return conv1d_receptive_field_center( + frame=receptive_field_center, + kernel_size=window_size, + stride=step_size, + padding=0, + dilation=1, + ) + def forward( self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/pyannote/audio/models/embedding/wespeaker/resnet.py b/pyannote/audio/models/embedding/wespeaker/resnet.py index 21fc98fc5..b64dd386d 100644 --- a/pyannote/audio/models/embedding/wespeaker/resnet.py +++ b/pyannote/audio/models/embedding/wespeaker/resnet.py @@ -15,6 +15,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +from functools import lru_cache from typing import Optional import torch @@ -23,6 +24,14 @@ from einops import rearrange from pyannote.audio.models.blocks.pooling import StatsPool +from pyannote.audio.utils.receptive_field import ( + conv1d_num_frames, + conv1d_receptive_field_center, + conv1d_receptive_field_size, + multi_conv_num_frames, + multi_conv_receptive_field_center, + multi_conv_receptive_field_size, +) class TSTP(nn.Module): @@ -77,6 +86,7 @@ class BasicBlock(nn.Module): def __init__(self, in_planes, planes, stride=1): super(BasicBlock, self).__init__() + self.stride = stride self.conv1 = nn.Conv2d( in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False ) @@ -99,6 +109,33 @@ def __init__(self, in_planes, planes, stride=1): nn.BatchNorm2d(self.expansion * planes), ) + @lru_cache + def num_frames(self, num_samples: int) -> int: + return multi_conv_num_frames( + num_samples, + kernel_size=[3, 3], + stride=[self.stride, 1], + padding=[1, 1], + dilation=[1, 1], + ) + + def receptive_field_size(self, num_frames: int = 1) -> int: + return multi_conv_receptive_field_size( + num_frames, + kernel_size=[3, 3], + stride=[self.stride, 1], + dilation=[1, 1], + ) + + def receptive_field_center(self, frame: int = 0) -> int: + return multi_conv_receptive_field_center( + frame, + kernel_size=[3, 3], + stride=[self.stride, 1], + padding=[1, 1], + dilation=[1, 1], + ) + def forward(self, x): out = F.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) @@ -112,6 +149,7 @@ class Bottleneck(nn.Module): def __init__(self, in_planes, planes, stride=1): super(Bottleneck, self).__init__() + self.stride = stride self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = nn.Conv2d( @@ -136,6 +174,33 @@ def __init__(self, in_planes, planes, stride=1): nn.BatchNorm2d(self.expansion * planes), ) + @lru_cache + def num_frames(self, num_samples: int) -> int: + return multi_conv_num_frames( + num_samples, + kernel_size=[1, 3, 1], + stride=[1, self.stride, 1], + padding=[0, 1, 0], + dilation=[1, 1, 1], + ) + + def receptive_field_size(self, num_frames: int = 1) -> int: + return multi_conv_receptive_field_size( + num_frames, + kernel_size=[1, 3, 1], + stride=[1, self.stride, 1], + dilation=[1, 1, 1], + ) + + def receptive_field_center(self, frame: int = 0) -> int: + return multi_conv_receptive_field_center( + frame, + kernel_size=[1, 3, 1], + stride=[1, self.stride, 1], + padding=[0, 1, 0], + dilation=[1, 1, 1], + ) + def forward(self, x): out = F.relu(self.bn1(self.conv1(x))) out = F.relu(self.bn2(self.conv2(out))) @@ -192,6 +257,90 @@ def _make_layer(self, block, planes, num_blocks, stride): self.in_planes = planes * block.expansion return nn.Sequential(*layers) + @lru_cache + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames + + Parameters + ---------- + num_samples : int + Number of input samples. + + Returns + ------- + num_frames : int + Number of output frames. + """ + + num_frames = num_samples + num_frames = conv1d_num_frames( + num_frames, kernel_size=3, stride=1, padding=1, dilation=1 + ) + for layers in [self.layer1, self.layer2, self.layer3, self.layer4]: + for layer in layers: + num_frames = layer.num_frames(num_frames) + + return num_frames + + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute size of receptive field + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + + Returns + ------- + receptive_field_size : int + Receptive field size. + """ + + receptive_field_size = num_frames + for layers in reversed([self.layer1, self.layer2, self.layer3, self.layer4]): + for layer in reversed(layers): + receptive_field_size = layer.receptive_field_size(receptive_field_size) + + receptive_field_size = conv1d_receptive_field_size( + num_frames=receptive_field_size, + kernel_size=3, + stride=1, + dilation=1, + ) + + return receptive_field_size + + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field + + Parameters + ---------- + frame : int, optional + Frame index + + Returns + ------- + receptive_field_center : int + Index of receptive field center. + """ + + receptive_field_center = frame + for layers in reversed([self.layer1, self.layer2, self.layer3, self.layer4]): + for layer in reversed(layers): + receptive_field_center = layer.receptive_field_center( + frame=receptive_field_center + ) + + receptive_field_center = conv1d_receptive_field_center( + frame=receptive_field_center, + kernel_size=3, + stride=1, + padding=1, + dilation=1, + ) + + return receptive_field_center + def forward(self, x: torch.Tensor, weights: Optional[torch.Tensor] = None): """ diff --git a/pyannote/audio/models/embedding/xvector.py b/pyannote/audio/models/embedding/xvector.py index 85610509d..00916fbd0 100644 --- a/pyannote/audio/models/embedding/xvector.py +++ b/pyannote/audio/models/embedding/xvector.py @@ -20,6 +20,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from functools import lru_cache from typing import Optional import torch @@ -31,6 +32,14 @@ from pyannote.audio.models.blocks.pooling import StatsPool from pyannote.audio.models.blocks.sincnet import SincNet from pyannote.audio.utils.params import merge_dict +from pyannote.audio.utils.receptive_field import ( + conv1d_num_frames, + conv1d_receptive_field_center, + conv1d_receptive_field_size, + multi_conv_num_frames, + multi_conv_receptive_field_center, + multi_conv_receptive_field_size, +) class XVectorMFCC(Model): @@ -56,11 +65,13 @@ def __init__( self.tdnns = nn.ModuleList() in_channel = self.hparams.mfcc["n_mfcc"] out_channels = [512, 512, 512, 512, 1500] - kernel_sizes = [5, 3, 3, 1, 1] - dilations = [1, 2, 3, 1, 1] + self.kernel_size = [5, 3, 3, 1, 1] + self.dilation = [1, 2, 3, 1, 1] + self.padding = [0, 0, 0, 0, 0] + self.stride = [1, 1, 1, 1, 1] for out_channel, kernel_size, dilation in zip( - out_channels, kernel_sizes, dilations + out_channels, self.kernel_size, self.dilation ): self.tdnns.extend( [ @@ -85,6 +96,107 @@ def dimension(self) -> int: """Dimension of output""" return self.hparams.dimension + @lru_cache + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames + + Parameters + ---------- + num_samples : int + Number of input samples. + + Returns + ------- + num_frames : int + Number of output frames. + """ + + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + center = self.mfcc.MelSpectrogram.spectrogram.center + + num_frames = conv1d_num_frames( + num_samples, + kernel_size=n_fft, + stride=hop_length, + dilation=1, + padding=n_fft // 2 if center else 0, + ) + + return multi_conv_num_frames( + num_frames, + kernel_size=self.kernel_size, + stride=self.stride, + padding=self.padding, + dilation=self.dilation, + ) + + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute size of receptive field + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + + Returns + ------- + receptive_field_size : int + Receptive field size. + """ + + receptive_field_size = multi_conv_receptive_field_size( + num_frames, + kernel_size=self.kernel_size, + stride=self.stride, + padding=self.padding, + dilation=self.dilation, + ) + + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + + return conv1d_receptive_field_size( + num_frames=receptive_field_size, + kernel_size=n_fft, + stride=hop_length, + dilation=1, + ) + + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field + + Parameters + ---------- + frame : int, optional + Frame index + + Returns + ------- + receptive_field_center : int + Index of receptive field center. + """ + + receptive_field_center = multi_conv_receptive_field_center( + frame, + kernel_size=self.kernel_size, + stride=self.stride, + padding=self.padding, + dilation=self.dilation, + ) + + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + center = self.mfcc.MelSpectrogram.spectrogram.center + + return conv1d_receptive_field_center( + frame=receptive_field_center, + kernel_size=n_fft, + stride=hop_length, + padding=n_fft // 2 if center else 0, + dilation=1, + ) + def forward( self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -128,11 +240,13 @@ def __init__( self.tdnns = nn.ModuleList() out_channels = [512, 512, 512, 512, 1500] - kernel_sizes = [5, 3, 3, 1, 1] - dilations = [1, 2, 3, 1, 1] + self.kernel_size = [5, 3, 3, 1, 1] + self.dilation = [1, 2, 3, 1, 1] + self.padding = [0, 0, 0, 0, 0] + self.stride = [1, 1, 1, 1, 1] for out_channel, kernel_size, dilation in zip( - out_channels, kernel_sizes, dilations + out_channels, self.kernel_size, self.dilation ): self.tdnns.extend( [ @@ -157,6 +271,79 @@ def dimension(self) -> int: """Dimension of output""" return self.hparams.dimension + @lru_cache + def num_frames(self, num_samples: int) -> int: + """Compute number of output frames + + Parameters + ---------- + num_samples : int + Number of input samples. + + Returns + ------- + num_frames : int + Number of output frames. + """ + + num_frames = self.sincnet.num_frames(num_samples) + + return multi_conv_num_frames( + num_frames, + kernel_size=self.kernel_size, + stride=self.stride, + padding=self.padding, + dilation=self.dilation, + ) + + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute size of receptive field + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + + Returns + ------- + receptive_field_size : int + Receptive field size. + """ + + receptive_field_size = multi_conv_receptive_field_size( + num_frames, + kernel_size=self.kernel_size, + stride=self.stride, + padding=self.padding, + dilation=self.dilation, + ) + + return self.sincnet.receptive_field_size(num_frames=receptive_field_size) + + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field + + Parameters + ---------- + frame : int, optional + Frame index + + Returns + ------- + receptive_field_center : int + Index of receptive field center. + """ + + receptive_field_center = multi_conv_receptive_field_center( + frame, + kernel_size=self.kernel_size, + stride=self.stride, + padding=self.padding, + dilation=self.dilation, + ) + + return self.sincnet.receptive_field_center(frame=receptive_field_center) + def forward( self, waveforms: torch.Tensor, weights: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/pyannote/audio/models/segmentation/PyanNet.py b/pyannote/audio/models/segmentation/PyanNet.py index 9d397abcb..3481b40c6 100644 --- a/pyannote/audio/models/segmentation/PyanNet.py +++ b/pyannote/audio/models/segmentation/PyanNet.py @@ -20,14 +20,13 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -from functools import cached_property, lru_cache +from functools import lru_cache from typing import Optional import torch import torch.nn as nn import torch.nn.functional as F from einops import rearrange -from pyannote.core import SlidingWindow from pyannote.core.utils.generators import pairwise from pyannote.audio.core.model import Model @@ -178,20 +177,36 @@ def num_frames(self, num_samples: int) -> int: return self.sincnet.num_frames(num_samples) - @cached_property - def receptive_field(self) -> SlidingWindow: - """Compute receptive field + def receptive_field_size(self, num_frames: int = 1) -> int: + """Compute size of receptive field + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal Returns ------- - receptive field : SlidingWindow + receptive_field_size : int + Receptive field size. + """ + return self.sincnet.receptive_field_size(num_frames=num_frames) + + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field - Source - ------ - https://distill.pub/2019/computing-receptive-fields/ + Parameters + ---------- + frame : int, optional + Frame index + Returns + ------- + receptive_field_center : int + Index of receptive field center. """ - return self.sincnet.receptive_field + + return self.sincnet.receptive_field_center(frame=frame) def forward(self, waveforms: torch.Tensor) -> torch.Tensor: """Pass forward diff --git a/pyannote/audio/models/segmentation/SSeRiouSS.py b/pyannote/audio/models/segmentation/SSeRiouSS.py index e337f439c..ef550dfe1 100644 --- a/pyannote/audio/models/segmentation/SSeRiouSS.py +++ b/pyannote/audio/models/segmentation/SSeRiouSS.py @@ -20,20 +20,23 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -from functools import cached_property, lru_cache +from functools import lru_cache from typing import Optional, Union import torch import torch.nn as nn import torch.nn.functional as F import torchaudio -from pyannote.core import SlidingWindow 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.frame import conv1d_num_frames, conv1d_receptive_field_size from pyannote.audio.utils.params import merge_dict +from pyannote.audio.utils.receptive_field import ( + conv1d_num_frames, + conv1d_receptive_field_center, + conv1d_receptive_field_size, +) class SSeRiouSS(Model): @@ -198,17 +201,17 @@ def build(self): @lru_cache def num_frames(self, num_samples: int) -> int: - """Compute number of output frames for a given number of input samples + """Compute number of output frames Parameters ---------- num_samples : int - Number of input samples + Number of input samples. Returns ------- num_frames : int - Number of output frames + Number of output frames. """ num_frames = num_samples @@ -224,7 +227,7 @@ def num_frames(self, num_samples: int) -> int: return num_frames def receptive_field_size(self, num_frames: int = 1) -> int: - """Compute receptive field size + """Compute size of receptive field Parameters ---------- @@ -234,7 +237,7 @@ def receptive_field_size(self, num_frames: int = 1) -> int: Returns ------- receptive_field_size : int - Receptive field size + Receptive field size. """ receptive_field_size = num_frames @@ -245,33 +248,31 @@ def receptive_field_size(self, num_frames: int = 1) -> int: stride=conv_layer.stride, dilation=conv_layer.conv.dilation[0], ) - return receptive_field_size - @cached_property - def receptive_field(self) -> SlidingWindow: - """Compute receptive field + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field + + Parameters + ---------- + frame : int, optional + Frame index Returns ------- - receptive field : SlidingWindow - - Source - ------ - https://distill.pub/2019/computing-receptive-fields/ - + receptive_field_center : int + Index of receptive field center. """ - - # duration of the receptive field of each output frame - duration = self.receptive_field_size() / self.hparams.sample_rate - - # step between the receptive field region of two consecutive output frames - step = ( - self.receptive_field_size(num_frames=2) - - self.receptive_field_size(num_frames=1) - ) / self.hparams.sample_rate - - return SlidingWindow(start=0.0, duration=duration, step=step) + receptive_field_center = frame + for conv_layer in reversed(self.wav2vec.feature_extractor.conv_layers): + receptive_field_center = conv1d_receptive_field_center( + receptive_field_center, + kernel_size=conv_layer.kernel_size, + stride=conv_layer.stride, + padding=conv_layer.conv.padding[0], + dilation=conv_layer.conv.dilation[0], + ) + return receptive_field_center def forward(self, waveforms: torch.Tensor) -> torch.Tensor: """Pass forward diff --git a/pyannote/audio/models/segmentation/debug.py b/pyannote/audio/models/segmentation/debug.py index d41dba51a..93c205b3d 100644 --- a/pyannote/audio/models/segmentation/debug.py +++ b/pyannote/audio/models/segmentation/debug.py @@ -21,17 +21,21 @@ # SOFTWARE. -from functools import cached_property, lru_cache +from functools import lru_cache from typing import Optional import torch import torch.nn as nn from einops import rearrange -from pyannote.core import SlidingWindow from torchaudio.transforms import MFCC from pyannote.audio.core.model import Model from pyannote.audio.core.task import Task +from pyannote.audio.utils.receptive_field import ( + conv1d_num_frames, + conv1d_receptive_field_center, + conv1d_receptive_field_size, +) class SimpleSegmentationModel(Model): @@ -82,14 +86,17 @@ def num_frames(self, num_samples: int) -> int: hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft center = self.mfcc.MelSpectrogram.spectrogram.center - return int( - 1 + num_samples // hop_length - if center - else 1 + (num_samples - n_fft) // hop_length + + return conv1d_num_frames( + num_samples=num_samples, + kernel_size=n_fft, + stride=hop_length, + padding=n_fft // 2 if center else 0, + dilation=1, ) def receptive_field_size(self, num_frames: int = 1) -> int: - """Compute receptive field size + """Compute size of receptive field Parameters ---------- @@ -99,44 +106,42 @@ def receptive_field_size(self, num_frames: int = 1) -> int: Returns ------- receptive_field_size : int - Receptive field size + Receptive field size. """ hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft - center = self.mfcc.MelSpectrogram.spectrogram.center - if center: - return (num_frames - 1) * hop_length - else: - return (num_frames - 1) * hop_length + n_fft + return conv1d_receptive_field_size( + num_frames, kernel_size=n_fft, stride=hop_length, dilation=1 + ) - @cached_property - def receptive_field(self) -> SlidingWindow: - """Compute receptive field + def receptive_field_center(self, frame: int = 0) -> int: + """Compute center of receptive field + + Parameters + ---------- + frame : int, optional + Frame index Returns ------- - receptive field : SlidingWindow - - Source - ------ - https://distill.pub/2019/computing-receptive-fields/ - + receptive_field_center : int + Index of receptive field center. """ - # duration of the receptive field of each output frame - duration = ( - self.mfcc.MelSpectrogram.spectrogram.win_length / self.hparams.sample_rate - ) + hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length + n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft + center = self.mfcc.MelSpectrogram.spectrogram.center - # step between the receptive field region of two consecutive output frames - step = ( - self.mfcc.MelSpectrogram.spectrogram.hop_length / self.hparams.sample_rate + return conv1d_receptive_field_center( + frame=frame, + kernel_size=n_fft, + stride=hop_length, + padding=n_fft // 2 if center else 0, + dilation=1, ) - return SlidingWindow(start=0.0, duration=duration, step=step) - @property def dimension(self) -> int: """Dimension of output""" diff --git a/pyannote/audio/utils/frame.py b/pyannote/audio/utils/frame.py deleted file mode 100644 index cde7ee19c..000000000 --- a/pyannote/audio/utils/frame.py +++ /dev/null @@ -1,79 +0,0 @@ -# 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 math - - -def conv1d_num_frames( - num_samples, kernel_size=5, stride=1, padding=0, dilation=1 -) -> int: - """Compute expected number of frames after 1D convolution - - Parameters - ---------- - num_samples : int - Number of samples in the input signal - kernel_size : int - Kernel size - stride : int - Stride - padding : int - Padding - dilation : int - Dilation - - Returns - ------- - num_frames : int - Number of frames in the output signal - - Source - ------ - https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html#torch.nn.Conv1d - """ - return math.floor( - 1 + (num_samples + 2 * padding - dilation * (kernel_size - 1) - 1) / stride - ) - - -def conv1d_receptive_field_size(num_frames=1, kernel_size=5, stride=1, dilation=1): - """Compute receptive field size for `num_frames` frames after 1D convolution - - Parameters - ---------- - num_frames : int, optional - Number of frames in the output signal - kernel_size : int - Kernel size - stride : int - Stride - dilation : int - Dilation - - Returns - ------- - receptive_field : int - Receptive field size - """ - - return 1 + (kernel_size - 1) * dilation + (num_frames - 1) * stride diff --git a/pyannote/audio/utils/receptive_field.py b/pyannote/audio/utils/receptive_field.py new file mode 100644 index 000000000..324c60f16 --- /dev/null +++ b/pyannote/audio/utils/receptive_field.py @@ -0,0 +1,163 @@ +# 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 math +from typing import List + + +def conv1d_num_frames( + num_samples, kernel_size=5, stride=1, padding=0, dilation=1 +) -> int: + """Compute expected number of frames after 1D convolution + + Parameters + ---------- + num_samples : int + Number of samples in the input signal + kernel_size : int + Kernel size + stride : int + Stride + padding : int + Padding + dilation : int + Dilation + + Returns + ------- + num_frames : int + Number of frames in the output signal + + Source + ------ + https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html#torch.nn.Conv1d + """ + return math.floor( + 1 + (num_samples + 2 * padding - dilation * (kernel_size - 1) - 1) / stride + ) + + +def multi_conv_num_frames( + num_samples: int, + kernel_size: List[int] = None, + stride: List[int] = None, + padding: List[int] = None, + dilation: List[int] = None, +) -> int: + num_frames = num_samples + for k, s, p, d in zip(kernel_size, stride, padding, dilation): + num_frames = conv1d_num_frames( + num_frames, kernel_size=k, stride=s, padding=p, dilation=d + ) + + return num_frames + + +def conv1d_receptive_field_size(num_frames=1, kernel_size=5, stride=1, dilation=1): + """Compute size of receptive field + + Parameters + ---------- + num_frames : int, optional + Number of frames in the output signal + kernel_size : int + Kernel size + stride : int + Stride + dilation : int + Dilation + + Returns + ------- + size : int + Receptive field size + """ + + effective_kernel_size = 1 + (kernel_size - 1) * dilation + return effective_kernel_size + (num_frames - 1) * stride + + +def multi_conv_receptive_field_size( + num_frames: int, + kernel_size: List[int] = None, + stride: List[int] = None, + padding: List[int] = None, + dilation: List[int] = None, +) -> int: + receptive_field_size = num_frames + for k, s, d in reversed(list(zip(kernel_size, stride, dilation))): + receptive_field_size = conv1d_receptive_field_size( + num_frames=receptive_field_size, + kernel_size=k, + stride=s, + dilation=d, + ) + return receptive_field_size + + +def conv1d_receptive_field_center( + frame=0, kernel_size=5, stride=1, padding=0, dilation=1 +) -> int: + """Compute center of receptive field + + Parameters + ---------- + frame : int + Frame index + kernel_size : int + Kernel size + stride : int + Stride + padding : int + Padding + dilation : int + Dilation + + Returns + ------- + center : int + Index of receptive field center + """ + + effective_kernel_size = 1 + (kernel_size - 1) * dilation + return frame * stride + (effective_kernel_size - 1) / 2 - padding + + +def multi_conv_receptive_field_center( + frame: int, + kernel_size: List[int] = None, + stride: List[int] = None, + padding: List[int] = None, + dilation: List[int] = None, +) -> int: + receptive_field_center = frame + for k, s, p, d in reversed(list(zip(kernel_size, stride, padding, dilation))): + receptive_field_center = conv1d_receptive_field_center( + frame=receptive_field_center, + kernel_size=k, + stride=s, + padding=p, + dilation=d, + ) + + return receptive_field_center From c3cc56cba55d50dc577303fd19ea020948c9da02 Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Thu, 8 Feb 2024 16:16:46 +0100 Subject: [PATCH 51/57] fix(task): fix estimation of training set size (#1644) --- CHANGELOG.md | 1 + pyannote/audio/tasks/segmentation/mixins.py | 5 ++++- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 514499b13..8b3aee905 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,7 @@ ### Fixes - fix(task): fix random generators +- fix(task): fix estimation of training set size ### Improvements diff --git a/pyannote/audio/tasks/segmentation/mixins.py b/pyannote/audio/tasks/segmentation/mixins.py index 9c5bcd792..cbdbbb7a1 100644 --- a/pyannote/audio/tasks/segmentation/mixins.py +++ b/pyannote/audio/tasks/segmentation/mixins.py @@ -255,8 +255,11 @@ def collate_fn(self, batch, stage="train"): def train__len__(self): # Number of training samples in one epoch + train_file_ids = np.where( + self.prepared_data["audio-metadata"]["subset"] == Subsets.index("train") + )[0] - duration = np.sum(self.prepared_data["audio-annotated"]) + duration = np.sum(self.prepared_data["audio-annotated"][train_file_ids]) return max(self.batch_size, math.ceil(duration / self.duration)) def prepare_validation(self, prepared_data: Dict): From 8b66bfd7ead4bb016497500bc95c48e5dac73294 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 8 Feb 2024 16:17:32 +0100 Subject: [PATCH 52/57] fix(util): ensure integer receptive field size (#1645) --- pyannote/audio/utils/receptive_field.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/pyannote/audio/utils/receptive_field.py b/pyannote/audio/utils/receptive_field.py index 324c60f16..0e484e4ad 100644 --- a/pyannote/audio/utils/receptive_field.py +++ b/pyannote/audio/utils/receptive_field.py @@ -20,8 +20,6 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. - -import math from typing import List @@ -52,9 +50,7 @@ def conv1d_num_frames( ------ https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html#torch.nn.Conv1d """ - return math.floor( - 1 + (num_samples + 2 * padding - dilation * (kernel_size - 1) - 1) / stride - ) + return 1 + (num_samples + 2 * padding - dilation * (kernel_size - 1) - 1) // stride def multi_conv_num_frames( @@ -105,6 +101,7 @@ def multi_conv_receptive_field_size( dilation: List[int] = None, ) -> int: receptive_field_size = num_frames + for k, s, d in reversed(list(zip(kernel_size, stride, dilation))): receptive_field_size = conv1d_receptive_field_size( num_frames=receptive_field_size, @@ -140,7 +137,7 @@ def conv1d_receptive_field_center( """ effective_kernel_size = 1 + (kernel_size - 1) * dilation - return frame * stride + (effective_kernel_size - 1) / 2 - padding + return frame * stride + (effective_kernel_size - 1) // 2 - padding def multi_conv_receptive_field_center( From 6e22f41af9994f23f9b94ae4a09d9b9ca39ab4c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Thu, 8 Feb 2024 16:18:10 +0100 Subject: [PATCH 53/57] improve(pipeline): track all Module instances (not just Model's) (#1646) --- CHANGELOG.md | 1 + pyannote/audio/core/pipeline.py | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8b3aee905..2eead17a8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,7 @@ ### Improvements - improve(metric): add support for number of speakers mismatch in `diarization_error_rate` metric +- improve(pipeline): track both `Model` and `nn.Module` attributes in `Pipeline.to(device)` ## Breaking changes diff --git a/pyannote/audio/core/pipeline.py b/pyannote/audio/core/pipeline.py index f844d584f..24e266abf 100644 --- a/pyannote/audio/core/pipeline.py +++ b/pyannote/audio/core/pipeline.py @@ -29,6 +29,7 @@ from typing import Callable, Dict, List, Optional, Text, Union import torch +import torch.nn as nn import yaml from huggingface_hub import hf_hub_download from huggingface_hub.utils import RepositoryNotFoundError @@ -232,7 +233,7 @@ def remove_from(*dicts): _models = self.__dict__.get("_models") _inferences = self.__dict__.get("_inferences") - if isinstance(value, Model): + if isinstance(value, nn.Module): if _models is None: msg = "cannot assign models before Pipeline.__init__() call" raise AttributeError(msg) From a810a5a53ac6e241606fd4ec822ea842f4c0a9b5 Mon Sep 17 00:00:00 2001 From: FrenchKrab <14005967+FrenchKrab@users.noreply.github.com> Date: Thu, 15 Feb 2024 08:27:52 +0100 Subject: [PATCH 54/57] fix: fix seeding in `create_rng_for_worker` (#1649) --- CHANGELOG.md | 2 +- pyannote/audio/utils/random.py | 18 +++++++++--------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2eead17a8..bb1199509 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,7 +15,7 @@ ### Fixes -- fix(task): fix random generators +- fix(task): fix random generators and their reproducibility - fix(task): fix estimation of training set size ### Improvements diff --git a/pyannote/audio/utils/random.py b/pyannote/audio/utils/random.py index 4980d3520..0006ad612 100644 --- a/pyannote/audio/utils/random.py +++ b/pyannote/audio/utils/random.py @@ -22,6 +22,7 @@ import os +import zlib from random import Random import torch @@ -51,16 +52,15 @@ def create_rng_for_worker(model) -> Random: else: worker_id = worker_info.id - seed = hash( - ( - global_seed, - worker_id, - model.local_rank, - model.global_rank, - model.current_epoch, - ) + seed_tuple = ( + global_seed, + worker_id, + model.local_rank, + model.global_rank, + model.current_epoch, ) - + # use adler32 because python's `hash` is not deterministic. + seed = zlib.adler32(str(seed_tuple).encode()) rng.seed(seed) return rng From 5b3ed0612953e5d01fe67fb2474c390d8ec47083 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Sun, 25 Feb 2024 20:37:47 +0100 Subject: [PATCH 55/57] doc: update tutorials notebooks --- tutorials/adapting_pretrained_pipeline.ipynb | 16 +- tutorials/add_your_own_model.ipynb | 285 +----- tutorials/add_your_own_task.ipynb | 381 +------- tutorials/applying_a_model.ipynb | 438 +-------- tutorials/applying_a_pipeline.ipynb | 401 +-------- tutorials/assets/download-model.png | Bin 482731 -> 316384 bytes tutorials/intro.ipynb | 11 +- tutorials/overlapped_speech_detection.ipynb | 398 +++++++-- tutorials/training_a_model.ipynb | 887 +------------------ tutorials/training_with_cli.md | 61 +- tutorials/voice_activity_detection.ipynb | 650 +------------- 11 files changed, 401 insertions(+), 3127 deletions(-) diff --git a/tutorials/adapting_pretrained_pipeline.ipynb b/tutorials/adapting_pretrained_pipeline.ipynb index d7096fb77..ee749fd80 100644 --- a/tutorials/adapting_pretrained_pipeline.ipynb +++ b/tutorials/adapting_pretrained_pipeline.ipynb @@ -43,9 +43,7 @@ "id": "CZjbjOBBDrdm" }, "source": [ - "## Installation\n", - "\n", - "Let's start by installing `pyannote.audio` 2.1.1 (and `rich` for pretty progress bars)." + "## Installation\n" ] }, { @@ -66,7 +64,7 @@ "id": "ndQ10VIf2W1c" }, "source": [ - "⚠ Restart the runtime (Runtime > Restart runtime). \n", + "⚠ Restart the runtime (Runtime > Restart session). \n", "If you don't, `pyannote.database` will throw an error below." ] }, @@ -154,10 +152,10 @@ }, "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()})" + "from pyannote.database import registry, FileFinder\n", + "\n", + "registry.load_database(\"AMI-diarization-setup/pyannote/database.yml\")\n", + "dataset = registry.get_protocol(\"AMI-SDM.SpeakerDiarization.mini\", {\"audio\": FileFinder()})" ] }, { @@ -345,7 +343,7 @@ " vad_loss=\"bce\")\n", "model.task = task\n", "model.prepare_data()\n", - "model.setup(stage=\"fit\")" + "model.setup()" ] }, { diff --git a/tutorials/add_your_own_model.ipynb b/tutorials/add_your_own_model.ipynb index 30020f8a9..487932588 100644 --- a/tutorials/add_your_own_model.ipynb +++ b/tutorials/add_your_own_model.ipynb @@ -1,284 +1 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Defining a custom model\n", - "\n", - "A collection of models is readily available in `pyannote.audio.models` but you will eventually want to try your own architecture. \n", - "\n", - "This tutorial explains how to define (and then use) your own model. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Optional\n", - "import torch\n", - "import torch.nn as nn\n", - "from pyannote.audio import Model\n", - "from pyannote.audio.core.task import Task, Resolution\n", - "from torchaudio.transforms import MFCC\n", - "\n", - "# Your custom model must be a subclass of `pyannote.audio.Model`,\n", - "# which is a subclass of `pytorch_lightning.LightningModule`, \n", - "# which is a subclass of `torch.nn.Module`.\n", - "class MyCustomModel(Model):\n", - " \"\"\"My custom model\"\"\"\n", - "\n", - "\n", - " def __init__(\n", - " self,\n", - " sample_rate: int = 16000, \n", - " num_channels: int = 1, \n", - " task: Optional[Task] = None,\n", - " param1: int = 32,\n", - " param2: int = 16,\n", - " ):\n", - "\n", - " # First three parameters (sample_rate, num_channels, and task)\n", - " # must be there and passed to super().__init__()\n", - " super().__init__(sample_rate=sample_rate, \n", - " num_channels=num_channels, \n", - " task=task)\n", - "\n", - " # Mark param1 and param2 as hyper-parameters.\n", - " self.save_hyperparameters(\"param1\", \"param2\")\n", - "\n", - " # They will be saved automatically into checkpoints.\n", - " # They are now also available in self.hparams:\n", - " # - param1 == self.hparams.param1\n", - " # - param2 == self.hparams.param2\n", - "\n", - " # Layers that do not depend on the addressed task should be defined in '__init__'.\n", - " self.mfcc = MFCC()\n", - " self.linear1 = nn.Linear(self.mfcc.n_mfcc, self.hparams.param1)\n", - " self.linear2 = nn.Linear(self.hparams.param1, self.hparams.param2)\n", - "\n", - " def build(self):\n", - " # Add layers that depend on the specifications of the task addressed \n", - " # by this model.\n", - "\n", - " # For instance, this simple model could be used for \"speech vs. non-speech\"\n", - " # or \"speech vs. music vs. other\" classification and the only difference\n", - " # would lie in the number of classes (2 or 3) in the final classifier.\n", - " \n", - " # Since task specifications are not available at the time '__init__' is called,\n", - " # task-dependent layers can only be added a 'build' time (where task specifications\n", - " # are available in 'specifications' attribute)\n", - " \n", - " num_classes = len(self.specifications.classes)\n", - " self.classifier = nn.Linear(self.hparams.param2, num_classes)\n", - "\n", - " # 'specifications' has several attributes describing what the task is:\n", - " # - classes: the list of classes\n", - " # - problem: the type of machine learning problem (e.g. binary \n", - " # classification or representation learning) \n", - " # - duration: the duration of input audio chunks, in seconds\n", - " # - resolution: the resolution of the output (e.g. frame-wise scores\n", - " # for voice activity detection or chunk-wise vector for speaker \n", - " # embedding)\n", - " # - permutation_invariant : whether classes are permutation-invariant\n", - " # (e.g. in the case of speaker diarization)\n", - "\n", - " # Depending on the type of 'problem', 'default_activation' can be used\n", - " # to automatically guess what the final activation should be (e.g. softmax\n", - " # for multi-class classification or sigmoid for multi-label classification).\n", - " self.activation = self.default_activation()\n", - "\n", - " # You obviously do not _have_ to use 'default_activation' and can choose to\n", - " # use any activation you see fit (or even not use any activation layer). But\n", - " # note that pyannote.audio tasks also define default loss functions that are\n", - " # consistent with `default_activation` (e.g. binary cross entropy with softmax\n", - " # for binary classification tasks)\n", - " \n", - " def forward(self, waveforms: torch.Tensor) -> torch.Tensor:\n", - "\n", - " # Models are expected to work on batches of audio chunks provided as tensors\n", - " # with shape (batch_size, num_channels, num_samples) and using the sample rate \n", - " # passed to __init__. Resampling will be done automatically for you so you do \n", - " # not have to bother about that when preparing the data.\n", - "\n", - " # Extract sequence of MFCCs and passed them through two linear layers\n", - " mfcc = self.mfcc(waveforms).squeeze(dim=1).transpose(1, 2)\n", - " output = self.linear1(mfcc)\n", - " output = self.linear2(output)\n", - "\n", - " # Apply temporal pooling for tasks which need an output at chunk-level. \n", - " if self.specifications.resolution == Resolution.CHUNK:\n", - " output = torch.mean(output, dim=-1)\n", - " # Keep 'mfcc' frame resolution for frame-level tasks.\n", - " elif self.specifications.resolution == Resolution.FRAME:\n", - " pass\n", - " \n", - " # Apply final classifier and activation function\n", - " output = self.classifier(output)\n", - " return self.activation(output) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Using your model with `pyannote.audio` API \n", - "\n", - "Your model can now be used like any other builtin model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# initialize your experimental protocol\n", - "from pyannote.database import get_protocol\n", - "protocol = get_protocol('Debug.SpeakerDiarization.Debug')\n", - "\n", - "# initialize the task you want to address\n", - "from pyannote.audio.tasks import VoiceActivityDetection\n", - "task = VoiceActivityDetection(protocol)\n", - "\n", - "# initialize the model\n", - "model = MyCustomModel(task=task)\n", - "\n", - "# train the model\n", - "from pytorch_lightning import Trainer\n", - "trainer = Trainer(max_epochs=1)\n", - "trainer.fit(model)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Using your model with `pyannote-audio-train` CLI\n", - "\n", - "1. Define your model in a proper Python package:\n", - "\n", - "```\n", - "/your/favorite/directory/\n", - " your_package_name/\n", - " __init__.py # needs to be here but can be empty\n", - " custom_model.py # contains the above definition of your model \n", - "```\n", - "\n", - "2. Add the package to your `PYTHONPATH`:\n", - "\n", - "```bash\n", - "$ export PYTHONPATH=/your/favorite/directory\n", - "```\n", - "\n", - "3. Check that you can import it from Python:\n", - "\n", - "```python\n", - ">>> from your_package_name.custom_model import MyCustomModel\n", - "```\n", - "\n", - "4. Tell `Hydra` (on which `pyannote-audio-train` is based) about this new model:\n", - "\n", - "```\n", - "/your/favorite/directory/\n", - " custom_config/\n", - " model/\n", - " MyCustomModel.yaml\n", - "```\n", - "\n", - "where the content of `MyCustomModel.yaml` is as follows:\n", - "\n", - "```yaml\n", - "# @package _group_\n", - "_target_: your_package_name.custom_model.MyCustomModel\n", - "param1: 32\n", - "param2: 16\n", - "```\n", - "\n", - "5. Enjoy\n", - "\n", - "```bash\n", - "$ pyannote-audio-train --config-dir=/your/favorite/directory/custom_config \\\n", - " protocol=Debug.SpeakerDiarization.Debug \\\n", - " task=VoiceActivityDetection \\\n", - " model=MyCustomModel \\\n", - " model.param2=12 \n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Contributing your model to `pyannote-audio` \n", - "\n", - "1. Add your model in `pyannote.audio.models`.\n", - "\n", - "```\n", - "pyannote/\n", - " audio/\n", - " models/\n", - " custom_model.py \n", - "```\n", - "\n", - "2. Check that you can import it from Python:\n", - "\n", - "```python\n", - ">>> from pyannote.audio.models.custom_model import MyCustomModel\n", - "```\n", - "\n", - "3. Add the corresponding `Hydra` configuration file:\n", - "\n", - "```\n", - "pyannote/\n", - " audio/\n", - " cli/\n", - " train_config/\n", - " model/\n", - " MyCustomModel.yaml\n", - "```\n", - "\n", - "where the content of `MyCustomModel.yaml` is as follows:\n", - "\n", - "```yaml\n", - "# @package _group_\n", - "_target_: pyannote.audio.models.custom_model.MyCustomModel\n", - "param1: 32\n", - "param2: 16\n", - "```\n", - "\n", - "4. Enjoy\n", - "\n", - "```bash\n", - "$ pyannote-audio-train protocol=Debug.SpeakerDiarization.Debug \\\n", - " task=VoiceActivityDetection \\\n", - " model=MyCustomModel \\\n", - " model.param2=12 \n", - "```" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"markdown","metadata":{"id":"kY1p-wCLHw92"},"source":["# Add your own model"]},{"cell_type":"markdown","metadata":{"id":"iD_DNGmmHs9v"},"source":["\"Open"]},{"cell_type":"markdown","metadata":{"id":"hhBTSvk6H_JC"},"source":["## Tutorial setup"]},{"cell_type":"markdown","metadata":{"id":"r-ocA5Z8PqNl"},"source":["### `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"I7lc6ctfIBv-"},"source":["If you are running this tutorial on `Colab`, execute the following commands in order to setup `Colab` environment. These commands will install `pyannote.audio` and download a mini version of the `AMI` corpus."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"l07Xq_UAIUFE"},"outputs":[],"source":["!pip install -qq pyannote.audio==3.1.1\n","!pip install -qq ipython==7.34.0\n","!git clone https://github.com/pyannote/AMI-diarization-setup.git\n","%cd ./AMI-diarization-setup/pyannote/\n","!bash ./download_ami_mini.sh\n","%cd /content"]},{"cell_type":"markdown","metadata":{"id":"3rjw5hATOv_c"},"source":["⚠ Restart the runtime (Runtime > Restart session)."]},{"cell_type":"markdown","metadata":{},"source":["### Non `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"VdMVQD-9QAto"},"source":["If you are not using `Colab`, this tutorial assumes that\n","* `pyannote.audio` has been installed\n","* the [AMI corpus](https://groups.inf.ed.ac.uk/ami/corpus/) has already been [setup for use with `pyannote`](https://github.com/pyannote/AMI-diarization-setup/tree/main/pyannote)"]},{"cell_type":"markdown","metadata":{"id":"kuemd4PWHeqh"},"source":["## Defining a custom model\n","\n","A collection of models is readily available in `pyannote.audio.models` but you will eventually want to try your own architecture.\n","\n","This tutorial explains how to define (and then use) your own model. "]},{"cell_type":"code","execution_count":18,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":12960,"status":"ok","timestamp":1704802939163,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"kNwQfnTOHeqm","outputId":"5f71bde3-5f13-4431-918f-6e1ca3ddd518"},"outputs":[],"source":["from typing import Optional\n","import torch\n","import torch.nn as nn\n","from pyannote.audio import Model\n","from pyannote.core import SlidingWindow\n","from pyannote.audio.core.task import Task, Resolution\n","from torchaudio.transforms import MFCC\n","\n","# Your custom model must be a subclass of `pyannote.audio.Model`,\n","# which is a subclass of `pytorch_lightning.LightningModule`,\n","# which is a subclass of `torch.nn.Module`.\n","class MyCustomModel(Model):\n"," \"\"\"My custom model\"\"\"\n","\n","\n"," def __init__(\n"," self,\n"," sample_rate: int = 16000,\n"," num_channels: int = 1,\n"," task: Optional[Task] = None,\n"," param1: int = 32,\n"," param2: int = 16,\n"," ):\n","\n"," # First three parameters (sample_rate, num_channels, and task)\n"," # must be there and passed to super().__init__()\n"," super().__init__(sample_rate=sample_rate,\n"," num_channels=num_channels,\n"," task=task)\n","\n"," # Mark param1 and param2 as hyper-parameters.\n"," self.save_hyperparameters(\"param1\", \"param2\")\n","\n"," # They will be saved automatically into checkpoints.\n"," # They are now also available in self.hparams:\n"," # - param1 == self.hparams.param1\n"," # - param2 == self.hparams.param2\n","\n"," # Layers that do not depend on the addressed task should be defined in '__init__'.\n"," self.mfcc = MFCC()\n"," self.linear1 = nn.Linear(self.mfcc.n_mfcc, self.hparams.param1)\n"," self.linear2 = nn.Linear(self.hparams.param1, self.hparams.param2)\n","\n"," def num_frames(self, num_samples: int) -> int:\n"," # Compute number of output frames for a given number of input samples\n"," hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length\n"," n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft\n"," center = self.mfcc.MelSpectrogram.spectrogram.center\n"," return (\n"," 1 + num_samples // hop_length\n"," if center\n"," else 1 + (num_samples - n_fft) // hop_length\n"," )\n","\n"," def receptive_field_size(self, num_frames: int = 1) -> int:\n"," # Compute receptive field size\n"," hop_length = self.mfcc.MelSpectrogram.spectrogram.hop_length\n"," n_fft = self.mfcc.MelSpectrogram.spectrogram.n_fft\n"," center = self.mfcc.MelSpectrogram.spectrogram.center\n","\n"," if center:\n"," return (num_frames - 1) * hop_length\n"," else:\n"," return (num_frames - 1) * hop_length + n_fft\n","\n"," def receptive_field(self) -> SlidingWindow:\n"," # Compute receptive field\n","\n"," # duration of the receptive field of each output frame\n"," duration = (\n"," self.mfcc.MelSpectrogram.spectrogram.win_length / self.hparams.sample_rate\n"," )\n","\n"," # step between the receptive field region of two consecutive output frames\n"," step = (\n"," self.mfcc.MelSpectrogram.spectrogram.hop_length / self.hparams.sample_rate\n"," )\n","\n"," return SlidingWindow(start=0.0, duration=duration, step=step)\n","\n"," def build(self):\n"," # Add layers that depend on the specifications of the task addressed\n"," # by this model.\n","\n"," # For instance, this simple model could be used for \"speech vs. non-speech\"\n"," # or \"speech vs. music vs. other\" classification and the only difference\n"," # would lie in the number of classes (2 or 3) in the final classifier.\n","\n"," # Since task specifications are not available at the time '__init__' is called,\n"," # task-dependent layers can only be added a 'build' time (where task specifications\n"," # are available in 'specifications' attribute)\n","\n"," num_classes = len(self.specifications.classes)\n"," self.classifier = nn.Linear(self.hparams.param2, num_classes)\n","\n"," # 'specifications' has several attributes describing what the task is:\n"," # - classes: the list of classes\n"," # - problem: the type of machine learning problem (e.g. binary\n"," # classification or representation learning)\n"," # - duration: the duration of input audio chunks, in seconds\n"," # - resolution: the resolution of the output (e.g. frame-wise scores\n"," # for voice activity detection or chunk-wise vector for speaker\n"," # embedding)\n"," # - permutation_invariant : whether classes are permutation-invariant\n"," # (e.g. in the case of speaker diarization)\n","\n"," # Depending on the type of 'problem', 'default_activation' can be used\n"," # to automatically guess what the final activation should be (e.g. softmax\n"," # for multi-class classification or sigmoid for multi-label classification).\n"," self.activation = self.default_activation()\n","\n"," # You obviously do not _have_ to use 'default_activation' and can choose to\n"," # use any activation you see fit (or even not use any activation layer). But\n"," # note that pyannote.audio tasks also define default loss functions that are\n"," # consistent with `default_activation` (e.g. binary cross entropy with softmax\n"," # for binary classification tasks)\n","\n"," def forward(self, waveforms: torch.Tensor) -> torch.Tensor:\n","\n"," # Models are expected to work on batches of audio chunks provided as tensors\n"," # with shape (batch_size, num_channels, num_samples) and using the sample rate\n"," # passed to __init__. Resampling will be done automatically for you so you do\n"," # not have to bother about that when preparing the data.\n","\n"," # Extract sequence of MFCCs and passed them through two linear layers\n"," mfcc = self.mfcc(waveforms).squeeze(dim=1).transpose(1, 2)\n"," output = self.linear1(mfcc)\n"," output = self.linear2(output)\n","\n"," # Apply temporal pooling for tasks which need an output at chunk-level.\n"," if self.specifications.resolution == Resolution.CHUNK:\n"," output = torch.mean(output, dim=-1)\n"," # Keep 'mfcc' frame resolution for frame-level tasks.\n"," elif self.specifications.resolution == Resolution.FRAME:\n"," pass\n","\n"," # Apply final classifier and activation function\n"," output = self.classifier(output)\n"," return self.activation(output)"]},{"cell_type":"markdown","metadata":{"id":"BuieqViJHeqp"},"source":["## Using your model with `pyannote.audio` API\n","\n","Your model can now be used like any other builtin model."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"qwTjuGuvHeqr"},"outputs":[],"source":["# initialize your experimental protocol\n","from pyannote.database import registry, FileFinder\n","\n","registry.load_database(\"./AMI-diarization-setup/pyannote/database.yml\")\n","protocol = registry.get_protocol('AMI.SpeakerDiarization.mini', preprocessors={\"audio\": FileFinder()})\n","\n","# initialize the task you want to address\n","from pyannote.audio.tasks import VoiceActivityDetection\n","task = VoiceActivityDetection(protocol)\n","\n","# initialize the model\n","model = MyCustomModel(task=task)\n","\n","# train the model\n","from pytorch_lightning import Trainer\n","trainer = Trainer(max_epochs=1)\n","trainer.fit(model)"]},{"cell_type":"markdown","metadata":{"id":"4qidmGQyHeqt"},"source":["## Using your model with `pyannote-audio-train` CLI\n","\n","1. Define your model in a proper Python package:\n","\n","```\n","/your/favorite/directory/\n"," your_package_name/\n"," __init__.py # needs to be here but can be empty\n"," custom_model.py # contains the above definition of your model\n","```\n","\n","2. Add the package to your `PYTHONPATH`:\n","\n","```bash\n","$ export PYTHONPATH=/your/favorite/directory\n","```\n","\n","3. Check that you can import it from Python:\n","\n","```python\n",">>> from your_package_name.custom_model import MyCustomModel\n","```\n","\n","4. Tell `Hydra` (on which `pyannote-audio-train` is based) about this new model:\n","\n","```\n","/your/favorite/directory/\n"," custom_config/\n"," model/\n"," MyCustomModel.yaml\n","```\n","\n","where the content of `MyCustomModel.yaml` is as follows:\n","\n","```yaml\n","# @package _group_\n","_target_: your_package_name.custom_model.MyCustomModel\n","param1: 32\n","param2: 16\n","```\n","\n","5. Enjoy\n","\n","```bash\n","$ pyannote-audio-train --config-dir=/your/favorite/directory/custom_config \\\n"," protocol=Debug.SpeakerDiarization.Debug \\\n"," task=VoiceActivityDetection \\\n"," model=MyCustomModel \\\n"," model.param2=12\n","```"]},{"cell_type":"markdown","metadata":{"id":"8W2UT1IpHequ"},"source":["## Contributing your model to `pyannote-audio`\n","\n","1. Add your model in `pyannote.audio.models`.\n","\n","```\n","pyannote/\n"," audio/\n"," models/\n"," custom_model.py \n","```\n","\n","2. Check that you can import it from Python:\n","\n","```python\n",">>> from pyannote.audio.models.custom_model import MyCustomModel\n","```\n","\n","3. Add the corresponding `Hydra` configuration file:\n","\n","```\n","pyannote/\n"," audio/\n"," cli/\n"," train_config/\n"," model/\n"," MyCustomModel.yaml\n","```\n","\n","where the content of `MyCustomModel.yaml` is as follows:\n","\n","```yaml\n","# @package _group_\n","_target_: pyannote.audio.models.custom_model.MyCustomModel\n","param1: 32\n","param2: 16\n","```\n","\n","4. Enjoy\n","\n","```bash\n","$ pyannote-audio-train protocol=Debug.SpeakerDiarization.Debug \\\n"," task=VoiceActivityDetection \\\n"," model=MyCustomModel \\\n"," model.param2=12\n","```"]}],"metadata":{"accelerator":"GPU","colab":{"gpuType":"T4","provenance":[]},"kernelspec":{"display_name":"Python 3","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.10.13"}},"nbformat":4,"nbformat_minor":0} diff --git a/tutorials/add_your_own_task.ipynb b/tutorials/add_your_own_task.ipynb index 7fe7858cb..b572e3d28 100644 --- a/tutorials/add_your_own_task.ipynb +++ b/tutorials/add_your_own_task.ipynb @@ -1,380 +1 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Defining a custom task\n", - "\n", - "In `pyannote.audio`, a *task* is a combination of a **_problem_** that needs to be addressed and an **experimental protocol**.\n", - "\n", - "For example, one can address **_voice activity detection_** following the **AMI only_words** experimental protocol, by instantiating the following *task*:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# this assumes that the AMI corpus has been setup for diarization\n", - "# according to https://github.com/pyannote/AMI-diarization-setup\n", - "import os\n", - "os.environ['PYANNOTE_DATABASE_CONFIG'] = '/Users/bredin/Development/pyannote/pyannote-db/AMI-diarization-setup/pyannote/database.yml'\n", - "\n", - "from pyannote.database import get_protocol, FileFinder\n", - "ami = get_protocol('AMI.SpeakerDiarization.only_words', \n", - " preprocessors={'audio': FileFinder()})\n", - "\n", - "# address voice activity detection\n", - "from pyannote.audio.tasks import VoiceActivityDetection\n", - "task = VoiceActivityDetection(ami)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A growing collection of tasks is readily available in `pyannote.audio.tasks`..." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.tasks import __all__ as TASKS; print('\\n'.join(TASKS))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... but you will eventually want to use `pyannote.audio` to address a different task. \n", - "In this example, we will add a new task addressing the **sound event detection** problem.\n", - "\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Problem specification\n", - "\n", - "A problem is expected to be solved by a model $f$ that takes an audio chunk $X$ as input and returns its predicted solution $\\hat{y} = f(X)$. \n", - "\n", - "### Resolution\n", - "\n", - "Depending on the addressed problem, you might expect the model to output just one prediction for the whole audio chunk (`Resolution.CHUNK`) or a temporal sequence of predictions (`Resolution.FRAME`).\n", - "\n", - "In our particular case, we would like the model to provide one decision for the whole chunk:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.core.task import Resolution\n", - "resolution = Resolution.CHUNK" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Type of problem\n", - "\n", - "Similarly, the type of your problem may fall into one of these generic machine learning categories:\n", - "* `Problem.BINARY_CLASSIFICATION` for binary classification\n", - "* `Problem.MONO_LABEL_CLASSIFICATION` for multi-class classification \n", - "* `Problem.MULTI_LABEL_CLASSIFICATION` for multi-label classification\n", - "* `Problem.REGRESSION` for regression\n", - "* `Problem.REPRESENTATION` for representation learning\n", - "\n", - "In our particular case, we would like the model to do multi-label classification because one audio chunk may contain multiple sound events:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.core.task import Problem\n", - "problem = Problem.MULTI_LABEL_CLASSIFICATION" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.core.task import Specifications\n", - "specifications = Specifications(\n", - " problem=problem,\n", - " resolution=resolution,\n", - " duration=5.0,\n", - " classes=[\"Speech\", \"Dog\", \"Cat\", \"Alarm_bell_ringing\", \"Dishes\", \n", - " \"Frying\", \"Blender\", \"Running_water\", \"Vacuum_cleaner\", \n", - " \"Electric_shaver_toothbrush\"],\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A task is expected to be solved by a model $f$ that (usually) takes an audio chunk $X$ as input and returns its predicted solution $\\hat{y} = f(X)$. \n", - "\n", - "To help training the model $f$, the task $\\mathcal{T}$ is in charge of \n", - "- generating $(X, y)$ training samples using the **dataset**\n", - "- defining the loss function $\\mathcal{L}(y, \\hat{y})$\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from math import ceil\n", - "from typing import Dict, Optional, Tuple, Union\n", - "import numpy as np\n", - "from pyannote.core import Segment, SlidingWindow\n", - "from pyannote.audio.utils.random import create_rng_for_worker\n", - "from pyannote.audio.core.task import Task, Resolution\n", - "from pyannote.database import Protocol\n", - "from torchmetrics.classification import MultilabelAUROC\n", - "\n", - "# Your custom task must be a subclass of `pyannote.audio.core.task.Task`\n", - "class SoundEventDetection(Task):\n", - " \"\"\"Sound event detection\"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " protocol: Protocol,\n", - " duration: float = 5.0,\n", - " min_duration: float = 5.0,\n", - " warm_up: Union[float, Tuple[float, float]] = 0.0,\n", - " batch_size: int = 32,\n", - " num_workers: Optional[int] = None,\n", - " pin_memory: bool = False,\n", - " augmentation = None,\n", - " cache: Optional[Union[str, None]] = None,\n", - " **other_params,\n", - " ):\n", - "\n", - " super().__init__(\n", - " protocol,\n", - " duration=duration,\n", - " min_duration=min_duration,\n", - " warm_up=warm_up,\n", - " batch_size=batch_size,\n", - " num_workers=num_workers,\n", - " pin_memory=pin_memory,\n", - " augmentation=augmentation,\n", - " cache=cache,\n", - " )\n", - " \n", - " def prepare_data(self):\n", - " # this method is called to prepare data from the specified protocol. \n", - " # For most tasks, calling Task.prepare_data() is sufficient. If you \n", - " # need to prepare task-specific data, define a post_prepare_data method for your task.\n", - " super().prepare_data()\n", - "\n", - " def post_prepare_data(self, prepared_data: Dict):\n", - " # this method is called at the end of Task.prepare_data() \n", - " # to complete data preparation with task-specific data, here \n", - " # the list of classes and some training metadata\n", - "\n", - " # load metadata for training subset\n", - " prepared_data[\"train_metadata\"] = list()\n", - " for training_file in self.protocol.train():\n", - " prepared_data[\"train_metadata\"].append({\n", - " # path to audio file (str)\n", - " \"audio\": training_file[\"audio\"],\n", - " # duration of audio file (float)\n", - " \"duration\": training_file[\"torchaudio.info\"].num_frames / training_file[\"torchaudio.info\"].sample_rate,\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 prepared_data[\"train_metadata\"]:\n", - " classes.update(training_file[\"annotation\"].labels())\n", - " prepared_data[\"classes\"] = sorted(classes)\n", - "\n", - " # `has_validation` is True if protocol defines a development set\n", - " if not self.has_validation:\n", - " return\n", - " \n", - " def prepare_validation(self, prepared_data : Dict):\n", - " # this method is called at the end of Task.prepare_data(), to complete data preparation\n", - " # with task validation elements\n", - " \n", - " # load metadata for validation subset\n", - " prepared_data[\"validation\"] = list()\n", - " for validation_file in self.protocol.development():\n", - " prepared_data[\"validation\"].append({\n", - " \"audio\": validation_file[\"audio\"],\n", - " \"num_samples\": validation_file[\"torchaudio.info\"].num_frames,\n", - " \"annotation\": validation_file[\"annotation\"],\n", - " })\n", - " \n", - " \n", - " def setup(self, stage: Optional[Union[str, None]] = None):\n", - " # this method assigns prepared data from task.prepare_data() to the task\n", - " # and declares the task specifications\n", - "\n", - " super().setup(stage)\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=self.prepared_data[\"classes\"])\n", - " \n", - " def default_metric(self):\n", - " # this method defines the default metrics used to evaluate the model during\n", - " # a training\n", - " num_classes = len(self.specifications.classes)\n", - " return MultilabelAUROC(num_classes, average=\"macro\", compute_on_cpu=True)\n", - "\n", - " def train__iter__(self):\n", - " # this method generates training samples, one at a time, \"ad infinitum\". each worker \n", - " # of the dataloader will run it, independently from other workers. pyannote.audio and\n", - " # pytorch-lightning will take care of making batches out of it.\n", - "\n", - " # create worker-specific random number generator (RNG) to avoid this common bug:\n", - " # tanelp.github.io/posts/a-bug-that-plagues-thousands-of-open-source-ml-projects/\n", - " rng = create_rng_for_worker(self.model)\n", - "\n", - " # load list and number of classes\n", - " classes = self.specifications.classes\n", - " num_classes = len(classes)\n", - "\n", - " # yield training samples \"ad infinitum\"\n", - " while True:\n", - "\n", - " # select training file at random\n", - " random_training_file, *_ = rng.choices(self.prepared_data[\"train_metadata\"], k=1)\n", - "\n", - " # select one chunk at random \n", - " random_start_time = rng.uniform(0, random_training_file[\"duration\"] - self.duration)\n", - " random_chunk = Segment(random_start_time, random_start_time + self.duration)\n", - "\n", - " # load audio excerpt corresponding to random chunk\n", - " X = self.model.audio.crop(random_training_file[\"audio\"], \n", - " random_chunk, \n", - " fixed=self.duration)\n", - " \n", - " # load labels corresponding to random chunk as {0|1} numpy array\n", - " # y[k] = 1 means that kth class is active\n", - " y = np.zeros((num_classes,))\n", - " active_classes = random_training_file[\"annotation\"].crop(random_chunk).labels()\n", - " for active_class in active_classes:\n", - " y[classes.index(active_class)] = 1\n", - " \n", - " # yield training samples as a dict (use 'X' for input and 'y' for target)\n", - " yield {'X': X, 'y': y}\n", - "\n", - " def train__len__(self):\n", - " # since train__iter__ runs \"ad infinitum\", we need a way to define what an epoch is.\n", - " # this is the purpose of this method. it outputs the number of training samples that\n", - " # make an epoch.\n", - "\n", - " # we compute this number as the total duration of the training set divided by \n", - " # duration of training chunks. we make sure that an epoch is at least one batch long,\n", - " # or pytorch-lightning will complain\n", - " train_duration = sum(training_file[\"duration\"] for training_file in self.prepared_data[\"train_metadata\"])\n", - " return max(self.batch_size, ceil(train_duration / self.duration))\n", - "\n", - " def val__getitem__(self, sample_idx):\n", - "\n", - " # load list and number of classes\n", - " classes = self.specifications.classes\n", - " num_classes = len(classes)\n", - "\n", - "\n", - " # find which part of the validation set corresponds to sample_idx\n", - " num_samples = np.cumsum([\n", - " validation_file[\"num_samples\"] for validation_file in self.prepared_data[\"validation\"]])\n", - " file_idx = np.where(num_samples < sample_idx)[0][0]\n", - " validation_file = self.prepared_data[\"validation\"][file_idx]\n", - " idx = sample_idx - (num_samples[file_idx] - validation_file[\"num_samples\"]) \n", - " chunk = SlidingWindow(start=0., duration=self.duration, step=self.duration)[idx]\n", - "\n", - " # load audio excerpt corresponding to current chunk\n", - " X = self.model.audio.crop(validation_file[\"audio\"], chunk, fixed=self.duration)\n", - "\n", - " # load labels corresponding to random chunk as {0|1} numpy array\n", - " # y[k] = 1 means that kth class is active\n", - " y = np.zeros((num_classes,))\n", - " active_classes = validation_file[\"annotation\"].crop(chunk).labels()\n", - " for active_class in active_classes:\n", - " y[classes.index(active_class)] = 1\n", - "\n", - " return {'X': X, 'y': y}\n", - "\n", - " def val__len__(self):\n", - " return sum(validation_file[\"num_samples\"] \n", - " for validation_file in self.prepared_data[\"validation\"])\n", - "\n", - " # `pyannote.audio.core.task.Task` base class provides a `LightningModule.training_step` and \n", - " # `LightningModule.validation_step` methods that rely on self.specifications to guess which \n", - " # loss and metrics should be used. you can obviously choose to customize them. \n", - " # More details can be found in pytorch-lightning documentation and in \n", - " # pyannote.audio.core.task.Task source code. \n", - "\n", - " # def training_step(self, batch, batch_idx: int):\n", - " # return loss\n", - "\n", - " # def validation_step(self, batch, batch_idx: int):\n", - " # return metric\n", - "\n", - " # pyannote.audio.tasks.segmentation.mixin also provides a convenient mixin\n", - " # for \"segmentation\" tasks (ie. with Resolution.FRAME) that already defines\n", - " # a bunch of useful methods. You can use it by inheriting your task from the \n", - " # pyannote.audio.tasks.segmentation.mixinSegmentationTask\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.10.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"markdown","metadata":{"id":"W7BMj2EZlWqU"},"source":["\"Open"]},{"cell_type":"markdown","metadata":{"id":"HG6OvaE4lWqZ"},"source":["# Defining a custom task"]},{"cell_type":"markdown","metadata":{"id":"c6LwrLYVlWqZ"},"source":["## Tutorial setup"]},{"cell_type":"markdown","metadata":{"id":"6lR9bgJBlWqb"},"source":["### `Google Colab` setup"]},{"cell_type":"markdown","metadata":{},"source":["If you are running this tutorial on `Colab`, execute the following commands in order to setup `Colab` environment. These commands will install `pyannote.audio` and download a mini version of the `AMI` corpus."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":127254,"status":"ok","timestamp":1704809957597,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"6LoOS-PjlWqd","outputId":"cd92e2d4-83cc-4bb0-ad5c-824cb2ca11ac"},"outputs":[],"source":["!pip install -qq pyannote.audio==3.1.1\n","!pip install -qq ipython==7.34.0\n","!git clone https://github.com/pyannote/AMI-diarization-setup.git\n","%cd ./AMI-diarization-setup/pyannote/\n","!bash ./download_ami_mini.sh\n","%cd /content"]},{"cell_type":"markdown","metadata":{"id":"LsZTSX-ulWqf"},"source":["⚠ Restart the runtime (Runtime > Restart session)."]},{"cell_type":"markdown","metadata":{"id":"904hVjv8lWqg"},"source":["### Non `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"serWAfFxlWqh"},"source":["If you are not using `Colab`, this tutorial assumes that\n","* `pyannote.audio` has been installed\n","* the [AMI corpus](https://groups.inf.ed.ac.uk/ami/corpus/) has already been [setup for use with `pyannote`](https://github.com/pyannote/AMI-diarization-setup/tree/main/pyannote)"]},{"cell_type":"markdown","metadata":{"id":"uWyNce9FlkA3"},"source":["## Task in `pyannote.audio`"]},{"cell_type":"markdown","metadata":{"id":"BK4hbdq6lWqj"},"source":["\n","In `pyannote.audio`, a *task* is a combination of a **_problem_** that needs to be addressed and an **experimental protocol**.\n","\n","For example, one can address **_voice activity detection_** following the **AMI only_words** experimental protocol, by instantiating the following *task*:\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"-4B8nLDmlWql"},"outputs":[],"source":["# this assumes that the AMI corpus has been setup for diarization\n","# according to https://github.com/pyannote/AMI-diarization-setup\n","\n","from pyannote.database import registry, FileFinder\n","registry.load_database(\"AMI-diarization-setup/pyannote/database.yml\")\n","ami = registry.get_protocol('AMI.SpeakerDiarization.mini',\n"," preprocessors={'audio': FileFinder()})\n","\n","# address voice activity detection\n","from pyannote.audio.tasks import VoiceActivityDetection\n","task = VoiceActivityDetection(ami)"]},{"cell_type":"markdown","metadata":{"id":"A9nxwDQGlWqn"},"source":["A growing collection of tasks is readily available in `pyannote.audio.tasks`..."]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":232,"status":"ok","timestamp":1704810010556,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"qbbDA2P5lWqp","outputId":"bf1988fb-9140-4d6a-8a2c-970578331f35"},"outputs":[{"name":"stdout","output_type":"stream","text":["SpeakerDiarization\n","VoiceActivityDetection\n","OverlappedSpeechDetection\n","MultiLabelSegmentation\n","SpeakerEmbedding\n","Segmentation\n"]}],"source":["from pyannote.audio.tasks import __all__ as TASKS; print('\\n'.join(TASKS))"]},{"cell_type":"markdown","metadata":{"id":"hihPu4iElWqr"},"source":["... but you will eventually want to use `pyannote.audio` to address a different task. \n","In this example, we will add a new task addressing the **sound event detection** problem.\n","\n"]},{"cell_type":"markdown","metadata":{"id":"RZOs3C4HlWqr"},"source":["## Problem specification\n","\n","A problem is expected to be solved by a model $f$ that takes an audio chunk $X$ as input and returns its predicted solution $\\hat{y} = f(X)$.\n","\n","### Resolution\n","\n","Depending on the addressed problem, you might expect the model to output just one prediction for the whole audio chunk (`Resolution.CHUNK`) or a temporal sequence of predictions (`Resolution.FRAME`).\n","\n","In our particular case, we would like the model to provide one decision for the whole chunk:"]},{"cell_type":"code","execution_count":3,"metadata":{"executionInfo":{"elapsed":234,"status":"ok","timestamp":1704810016464,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"G96Mz8vPlWqs"},"outputs":[],"source":["from pyannote.audio.core.task import Resolution\n","resolution = Resolution.CHUNK"]},{"cell_type":"markdown","metadata":{"id":"_Efd28eclWqt"},"source":["### Type of problem\n","\n","Similarly, the type of your problem may fall into one of these generic machine learning categories:\n","* `Problem.BINARY_CLASSIFICATION` for binary classification\n","* `Problem.MONO_LABEL_CLASSIFICATION` for multi-class classification\n","* `Problem.MULTI_LABEL_CLASSIFICATION` for multi-label classification\n","* `Problem.REGRESSION` for regression\n","* `Problem.REPRESENTATION` for representation learning\n","\n","In our particular case, we would like the model to do multi-label classification because one audio chunk may contain multiple sound events:"]},{"cell_type":"code","execution_count":4,"metadata":{"executionInfo":{"elapsed":315,"status":"ok","timestamp":1704810020230,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"Cl0VqB5jlWqu"},"outputs":[],"source":["from pyannote.audio.core.task import Problem\n","problem = Problem.MULTI_LABEL_CLASSIFICATION"]},{"cell_type":"code","execution_count":5,"metadata":{"executionInfo":{"elapsed":251,"status":"ok","timestamp":1704810021646,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"Hz_B7FCplWqv"},"outputs":[],"source":["from pyannote.audio.core.task import Specifications\n","specifications = Specifications(\n"," problem=problem,\n"," resolution=resolution,\n"," duration=5.0,\n"," classes=[\"Speech\", \"Dog\", \"Cat\", \"Alarm_bell_ringing\", \"Dishes\",\n"," \"Frying\", \"Blender\", \"Running_water\", \"Vacuum_cleaner\",\n"," \"Electric_shaver_toothbrush\"],\n",")"]},{"cell_type":"markdown","metadata":{"id":"5N72ksU7lWqv"},"source":["A task is expected to be solved by a model $f$ that (usually) takes an audio chunk $X$ as input and returns its predicted solution $\\hat{y} = f(X)$.\n","\n","To help training the model $f$, the task $\\mathcal{T}$ is in charge of\n","- generating $(X, y)$ training samples using the **dataset**\n","- defining the loss function $\\mathcal{L}(y, \\hat{y})$\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"lrTD1RwUlWqw"},"outputs":[],"source":["from math import ceil\n","from typing import Dict, Optional,Tuple, Union\n","import numpy as np\n","from pyannote.core import Segment, SlidingWindow\n","from pyannote.audio.utils.random import create_rng_for_worker\n","from pyannote.audio.core.task import Task, Resolution\n","from pyannote.database import Protocol\n","from torchmetrics.classification import MultilabelAUROC\n","\n","# Your custom task must be a subclass of `pyannote.audio.core.task.Task`\n","class SoundEventDetection(Task):\n"," \"\"\"Sound event detection\"\"\"\n","\n"," def __init__(\n"," self,\n"," protocol: Protocol,\n"," duration: float = 5.0,\n"," min_duration: float = 5.0,\n"," warm_up: Union[float, Tuple[float, float]] = 0.0,\n"," batch_size: int = 32,\n"," num_workers: int = None,\n"," pin_memory: bool = False,\n"," augmentation = None,\n"," cache: Optional[Union[str, None]] = None,\n"," **other_params,\n"," ):\n","\n"," super().__init__(\n"," protocol,\n"," duration=duration,\n"," min_duration=min_duration,\n"," warm_up=warm_up,\n"," batch_size=batch_size,\n"," num_workers=num_workers,\n"," pin_memory=pin_memory,\n"," augmentation=augmentation,\n"," cache=cache,\n"," )\n"," \n"," def prepare_data(self):\n"," # this method is called to prepare data from the specified protocol. \n"," # For most tasks, calling Task.prepare_data() is sufficient. If you \n"," # need to prepare task-specific data, define a post_prepare_data method for your task.\n"," super().prepare_data()\n","\n"," def post_prepare_data(self, prepared_data: Dict):\n"," # this method is called at the end of Task.prepare_data() \n"," # to complete data preparation with task-specific data, here \n"," # the list of classes and some training metadata\n","\n"," # load metadata for training subset\n"," prepared_data[\"train_metadata\"] = list()\n"," for training_file in self.protocol.train():\n"," prepared_data[\"train_metadata\"].append({\n"," # path to audio file (str)\n"," \"audio\": training_file[\"audio\"],\n"," # duration of audio file (float)\n"," \"duration\": training_file[\"torchaudio.info\"].num_frames / training_file[\"torchaudio.info\"].sample_rate,\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 prepared_data[\"train_metadata\"]:\n"," classes.update(training_file[\"annotation\"].labels())\n"," prepared_data[\"classes\"] = sorted(classes)\n","\n"," # `has_validation` is True if protocol defines a development set\n"," if not self.has_validation:\n"," return\n"," \n"," def prepare_validation(self, prepared_data : Dict):\n"," # this method is called at the end of Task.prepare_data(), to complete data preparation\n"," # with task validation elements\n"," \n"," # load metadata for validation subset\n"," prepared_data[\"validation\"] = list()\n"," for validation_file in self.protocol.development():\n"," prepared_data[\"validation\"].append({\n"," \"audio\": validation_file[\"audio\"],\n"," \"num_samples\": validation_file[\"torchaudio.info\"].num_frames,\n"," \"annotation\": validation_file[\"annotation\"],\n"," })\n"," \n"," \n"," def setup(self, stage: Optional[Union[str, None]] = None):\n"," # this method assigns prepared data from task.prepare_data() to the task\n"," # and declares the task specifications\n","\n"," super().setup(stage)\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=self.prepared_data[\"classes\"])\n"," \n"," def default_metric(self):\n"," # this method defines the default metrics used to evaluate the model during\n"," # a training\n"," num_classes = len(self.specifications.classes)\n"," return MultilabelAUROC(num_classes, average=\"macro\", compute_on_cpu=True)\n","\n"," def train__iter__(self):\n"," # this method generates training samples, one at a time, \"ad infinitum\". each worker \n"," # of the dataloader will run it, independently from other workers. pyannote.audio and\n"," # pytorch-lightning will take care of making batches out of it.\n","\n"," # create worker-specific random number generator (RNG) to avoid this common bug:\n"," # tanelp.github.io/posts/a-bug-that-plagues-thousands-of-open-source-ml-projects/\n"," rng = create_rng_for_worker(self.model)\n","\n"," # load list and number of classes\n"," classes = self.specifications.classes\n"," num_classes = len(classes)\n","\n"," # yield training samples \"ad infinitum\"\n"," while True:\n","\n"," # select training file at random\n"," random_training_file, *_ = rng.choices(self.prepared_data[\"train_metadata\"], k=1)\n","\n"," # select one chunk at random \n"," random_start_time = rng.uniform(0, random_training_file[\"duration\"] - self.duration)\n"," random_chunk = Segment(random_start_time, random_start_time + self.duration)\n","\n"," # load audio excerpt corresponding to random chunk\n"," X = self.model.audio.crop(random_training_file[\"audio\"], \n"," random_chunk, \n"," fixed=self.duration)\n"," \n"," # load labels corresponding to random chunk as {0|1} numpy array\n"," # y[k] = 1 means that kth class is active\n"," y = np.zeros((num_classes,))\n"," active_classes = random_training_file[\"annotation\"].crop(random_chunk).labels()\n"," for active_class in active_classes:\n"," y[classes.index(active_class)] = 1\n"," \n"," # yield training samples as a dict (use 'X' for input and 'y' for target)\n"," yield {'X': X, 'y': y}\n","\n"," def train__len__(self):\n"," # since train__iter__ runs \"ad infinitum\", we need a way to define what an epoch is.\n"," # this is the purpose of this method. it outputs the number of training samples that\n"," # make an epoch.\n","\n"," # we compute this number as the total duration of the training set divided by \n"," # duration of training chunks. we make sure that an epoch is at least one batch long,\n"," # or pytorch-lightning will complain\n"," train_duration = sum(training_file[\"duration\"] for training_file in self.prepared_data[\"train_metadata\"])\n"," return max(self.batch_size, ceil(train_duration / self.duration))\n","\n"," def val__getitem__(self, sample_idx):\n","\n"," # load list and number of classes\n"," classes = self.specifications.classes\n"," num_classes = len(classes)\n","\n","\n"," # find which part of the validation set corresponds to sample_idx\n"," num_samples = np.cumsum([\n"," validation_file[\"num_samples\"] for validation_file in self.prepared_data[\"validation\"]])\n"," file_idx = np.where(num_samples < sample_idx)[0][0]\n"," validation_file = self.prepared_data[\"validation\"][file_idx]\n"," idx = sample_idx - (num_samples[file_idx] - validation_file[\"num_samples\"]) \n"," chunk = SlidingWindow(start=0., duration=self.duration, step=self.duration)[idx]\n","\n"," # load audio excerpt corresponding to current chunk\n"," X = self.model.audio.crop(validation_file[\"audio\"], chunk, fixed=self.duration)\n","\n"," # load labels corresponding to random chunk as {0|1} numpy array\n"," # y[k] = 1 means that kth class is active\n"," y = np.zeros((num_classes,))\n"," active_classes = validation_file[\"annotation\"].crop(chunk).labels()\n"," for active_class in active_classes:\n"," y[classes.index(active_class)] = 1\n","\n"," return {'X': X, 'y': y}\n","\n"," def val__len__(self):\n"," return sum(validation_file[\"num_samples\"] \n"," for validation_file in self.prepared_data[\"validation\"])\n","\n"," # `pyannote.audio.core.task.Task` base class provides a `LightningModule.training_step` and \n"," # `LightningModule.validation_step` methods that rely on self.specifications to guess which \n"," # loss and metrics should be used. you can obviously choose to customize them. \n"," # More details can be found in pytorch-lightning documentation and in \n"," # pyannote.audio.core.task.Task source code. \n","\n"," # def training_step(self, batch, batch_idx: int):\n"," # return loss\n","\n"," # def validation_step(self, batch, batch_idx: int):\n"," # return metric\n","\n"," # pyannote.audio.tasks.segmentation.mixin also provides a convenient mixin\n"," # for \"segmentation\" tasks (ie. with Resolution.FRAME) that already defines\n"," # a bunch of useful methods. You can use it by inheriting your task from the \n"," # pyannote.audio.tasks.segmentation.mixinSegmentationTask"]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3","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.10.13"}},"nbformat":4,"nbformat_minor":0} diff --git a/tutorials/applying_a_model.ipynb b/tutorials/applying_a_model.ipynb index e035d0654..68524eb57 100644 --- a/tutorials/applying_a_model.ipynb +++ b/tutorials/applying_a_model.ipynb @@ -1,437 +1 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# preparing notebook for visualization purposes\n", - "# (only show outputs between t=0s and t=30s)\n", - "from pyannote.core import notebook, Segment\n", - "notebook.crop = Segment(0, 30)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Applying a pretrained model\n", - "\n", - "In this tutorial, you will learn how to apply `pyannote.audio` models on an audio file, whose manual annotation is depicted below" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# clone pyannote-audio Github repository and update ROOT_DIR accordingly\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, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.database.util import load_rttm\n", - "REFERENCE = f\"{ROOT_DIR}/tutorials/assets/sample.rttm\"\n", - "reference = load_rttm(REFERENCE)[\"sample\"]\n", - "reference" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading models from 🤗 hub\n", - "\n", - "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": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['pyannote/Segmentation-PyanNet-DIHARD',\n", - " 'pyannote/TestModelForContinuousIntegration',\n", - " 'pyannote/embedding',\n", - " 'pyannote/segmentation',\n", - " 'pyannote/brouhaha']" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from huggingface_hub import HfApi\n", - "available_models = [m.modelId for m in HfApi().list_models(filter=\"pyannote-audio-model\")]\n", - "list(filter(lambda p: p.startswith(\"pyannote/\"), available_models))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "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", - "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": 5, - "metadata": {}, - "outputs": [ - { - "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": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "specs = model.specifications\n", - "specs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... which can be understood like that:\n", - "\n", - "* `duration = 5.0`: the model ingests 5s-long audio chunks\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" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To apply the model on the audio file, we wrap it into an `Inference` instance:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.audio import Inference\n", - "inference = Inference(model, step=2.5)\n", - "output = inference(AUDIO_FILE)\n", - "output" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "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": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(11, 293, 3)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "output.data.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Processing a file from memory\n", - "\n", - "In case the audio file is not stored on disk, pipelines can also process audio provided as a `{\"waveform\": ..., \"sample_rate\": ...}` dictionary. " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "type(waveform)=\n", - "waveform.shape=torch.Size([1, 480000])\n", - "waveform.dtype=torch.float32\n" - ] - } - ], - "source": [ - "import torchaudio\n", - "waveform, sample_rate = torchaudio.load(AUDIO_FILE)\n", - "\n", - "print(f\"{type(waveform)=}\")\n", - "print(f\"{waveform.shape=}\")\n", - "print(f\"{waveform.dtype=}\")\n", - "\n", - "audio_in_memory = {\"waveform\": waveform, \"sample_rate\": sample_rate}" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "output = inference(audio_in_memory)\n", - "output" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Processing part of a file\n", - "\n", - "If needed, `Inference` can be used to process only part of a file:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "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": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.core import Segment\n", - "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.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, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"markdown","metadata":{"id":"rkz0m90MTNdU"},"source":["**\"Open**"]},{"cell_type":"markdown","metadata":{"id":"vDBFFNeGWF0v"},"source":["# Applying a pretrained model\n","\n","In this tutorial, you will learn how to apply `pyannote.audio` models on an audio file, whose manual annotation is depicted below"]},{"cell_type":"markdown","metadata":{"id":"DcXUj3lVTkWz"},"source":["## Tutorial setup"]},{"cell_type":"code","execution_count":3,"metadata":{"executionInfo":{"elapsed":221,"status":"ok","timestamp":1704806538788,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"p7uwJtF1W0Od"},"outputs":[],"source":["# preparing notebook for visualization purposes\n","# (only show outputs between t=0s and t=30s)\n","from pyannote.core import notebook, Segment\n","notebook.crop = Segment(0, 30)"]},{"cell_type":"markdown","metadata":{"id":"yr4ONuV9Tlgj"},"source":["### `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"OaXXRLf5Tp2D"},"source":["If you are running this tutorial on `Colab`, execute the following commands in order to setup `Colab` environment. These commands will install `pyannote.audio`, and download resources used in this tutorial."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"wQub0z0VTzpU"},"outputs":[],"source":["!pip install -qq pyannote.audio==3.1.1\n","!pip install -qq ipython==7.34.0\n","!wget -q \"https://github.com/pyannote/pyannote-audio/raw/develop/tutorials/assets/sample.wav\"\n","!wget -q \"https://github.com/pyannote/pyannote-audio/raw/develop/tutorials/assets/sample.rttm\"\n","!wget -q -P ./assets/ \"https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/assets/download-model.png\""]},{"cell_type":"markdown","metadata":{"id":"4Qy1iMvGVaHF"},"source":["⚠ Restart the runtime (Runtime > Restart session)."]},{"cell_type":"code","execution_count":18,"metadata":{"executionInfo":{"elapsed":203,"status":"ok","timestamp":1704807063824,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"vHwJOO-sUdF2"},"outputs":[],"source":["AUDIO_FILE = \"sample.wav\"\n","REFERENCE = \"sample.rttm\""]},{"cell_type":"markdown","metadata":{"id":"CUmGkiY-V-wI"},"source":["### Non `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"_E4buYUQWXE5"},"source":["If you are not using Colab, clone `pyannote.audio` [GitHub repository](https://github.com/pyannote/pyannote-audio) and update ROOT_DIR accordingly"]},{"cell_type":"code","execution_count":2,"metadata":{"executionInfo":{"elapsed":232,"status":"ok","timestamp":1704806051725,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"Wii7pyvSTIa1"},"outputs":[],"source":["# clone pyannote-audio Github repository and update ROOT_DIR accordingly\n","ROOT_DIR = \"/pyannote-audio\"\n","AUDIO_FILE = f\"{ROOT_DIR}/tutorials/assets/sample.wav\"\n","REFERENCE = f\"{ROOT_DIR}/tutorials/assets/sample.rttm\""]},{"cell_type":"markdown","metadata":{"id":"o01jf1VTXC8u"},"source":["## References\n","\n","First, let's take a look at the audio reference used in this tutorial. It can be accessed as follows:"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":259},"executionInfo":{"elapsed":542,"status":"ok","timestamp":1704807074571,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"Q4hYAMEiTIa3","outputId":"9fecf73e-2448-4a4e-93e4-f35d2ec4da8b"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["from pyannote.database.util import load_rttm\n","\n","reference = load_rttm(REFERENCE)[\"sample\"]\n","reference"]},{"cell_type":"markdown","metadata":{"id":"3cpR2brxTIa6"},"source":["## Loading models from 🤗 hub\n","\n","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":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":1201,"status":"ok","timestamp":1704807077972,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"OXNju-sFTIa7","outputId":"6c587fd6-f14f-4162-81ba-0609153aa7f2"},"outputs":[{"data":{"text/plain":["['pyannote/TestModelForContinuousIntegration',\n"," 'pyannote/embedding',\n"," 'pyannote/segmentation',\n"," 'pyannote/brouhaha',\n"," 'pyannote/segmentation-3.0',\n"," 'pyannote/wespeaker-voxceleb-resnet34-LM']"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["from huggingface_hub import HfApi\n","available_models = [m.modelId for m in HfApi().list_models(filter=\"pyannote-audio-model\")]\n","list(filter(lambda p: p.startswith(\"pyannote/\"), available_models))"]},{"cell_type":"markdown","metadata":{"id":"LrQ2ykU4TIa-"},"source":["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","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,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145,"referenced_widgets":["a73cecb8608f491e8f996c5114df4d0f","bc10c6804346449b8e349728a1acb8d2","73915caf6d1042ca9a27853986217ae2","2d1965df902b4b7eb6e4e28e44d6e32b","b2e03b10050d46548932f429bcc18d81","0c537fef94bd4a3d8c42d981a70ea35b","79d55946b3764666a0b57a72722f6c19","988c83c85f7d44d0be949de6eedcf977","53919e13e42441d9b8cf5eb4f2effe96","47da80658de14604a7cc5268b951c172","c7fbfffbbc304f0ba025e03beb8f638a","416ffb7703b1404ab1c19c6b1ecafb4c","5be7421c575d41128d0675dc9abbc196","8b3353af24074ce5b5d2d9b162c61062","cd40e31c191044b7a0f8fa4694ad6380","ecbb880cf0044404ab9bfc5995656807","79287ffea49a4e4a80191b1157de15cc","0e04a45510f346b8ab3c465b10ccdfd2","bf5c88fe90f0462b95aa8a81467c1e9d","09ee64808a5c431b928066a4cb287a78","52a4a1aab39741f2a0499428f07a4c25","f23cc133109c4ecb9b383f118bcc71aa","2b91f4b11d5848c0b6795b649bc2d7bc","b437981acb894f97ad45daaebe2734c7","01a79756e1104be0bcbe1d233677d605","990375a830eb4cd79c69ad78b9ac685b","49cb317b141a43b7b8ce342e2d62ab03","abc23089f4ef4d2a9f8a104fb1dba14a","57cf64e9c70e4057a76c2f3fb1e9b191","5e90e4818f1f43f2aa4714e0e40dc15d","fb027db34fd740c2a4758d650ae3f73c","1a30ac8b519948bbad72886049b53d55"]},"executionInfo":{"elapsed":215,"status":"ok","timestamp":1704807086866,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"x9iQwHjfTIa_","outputId":"b5b3c597-4c2e-4306-e6a5-9ccc9ed19d08"},"outputs":[],"source":["from huggingface_hub import notebook_login\n","notebook_login()"]},{"cell_type":"markdown","metadata":{"id":"fUvB3kwwTIbA"},"source":["Once authenticated, you can load the model..."]},{"cell_type":"code","execution_count":null,"metadata":{"executionInfo":{"elapsed":3254,"status":"ok","timestamp":1704807117456,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"IzYUeS99TIbE"},"outputs":[],"source":["from pyannote.audio import Model\n","model = Model.from_pretrained(\"pyannote/segmentation-3.0\", use_auth_token=True)"]},{"cell_type":"markdown","metadata":{"id":"UxuGtfPoTIbF"},"source":["... which consists in SincNet feature extraction (`sincnet`) , LSTM sequence modeling (`lstm`), a few feed-forward layers (`linear`), and a final multi-label `classifier`:"]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":223,"status":"ok","timestamp":1704807124564,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"BQ2RDdqUTIbH","outputId":"6caf82ff-7a19-401d-ad79-8350315ec9de"},"outputs":[{"data":{"text/plain":[" | Name | Type | Params | In sizes | Out sizes \n","---------------------------------------------------------------------------------------------------------\n","0 | sincnet | SincNet | 42.6 K | [1, 1, 160000] | [1, 60, 589] \n","1 | lstm | LSTM | 1.4 M | [1, 589, 60] | [[1, 589, 256], [[8, 1, 128], [8, 1, 128]]]\n","2 | linear | ModuleList | 49.4 K | ? | ? \n","3 | classifier | Linear | 903 | [1, 589, 128] | [1, 589, 7] \n","4 | activation | LogSoftmax | 0 | [1, 589, 7] | [1, 589, 7] \n","---------------------------------------------------------------------------------------------------------\n","1.5 M Trainable params\n","0 Non-trainable params\n","1.5 M Total params\n","5.893 Total estimated model params size (MB)"]},"execution_count":8,"metadata":{},"output_type":"execute_result"}],"source":["from pytorch_lightning.utilities.model_summary import summarize\n","\n","summarize(model)"]},{"cell_type":"markdown","metadata":{"id":"ahfL4saFTIbI"},"source":["More details about the model are provided by its specifications..."]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":195,"status":"ok","timestamp":1704807127275,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"B0OFti5ITIbJ","outputId":"c2d74d99-7727-4f36-9a0f-4ec2aa76bd25"},"outputs":[{"data":{"text/plain":["Specifications(problem=, resolution=, duration=10.0, min_duration=None, warm_up=(0.0, 0.0), classes=['speaker#1', 'speaker#2', 'speaker#3'], powerset_max_classes=2, permutation_invariant=True)"]},"execution_count":9,"metadata":{},"output_type":"execute_result"}],"source":["specs = model.specifications\n","specs"]},{"cell_type":"markdown","metadata":{"id":"kP5sRrrdTIbK"},"source":["... which can be understood like that:\n","\n","* `duration = 10.0`: the model ingests 10s-long audio chunks\n","* `Resolution.FRAME`: the model output a sequence of frame-wise scores\n","* `len(classes) = 3`: model handle chunks with up to 3 speakers\n","* `powerset_max_classes = 2`: at most 2 speakers can talk at the same time (overlapped speech)\n","The previous two specifications give the classes that the model can predict: {no speech}, {spk1}, {spk2}, {spk3}, {spk1, spk2}, {spk1, spk3}, {spk2, spk3}, so a total of 7 classes.\n","More details about powerset can be found in the article `A. Plaquet and H. Bredin, “Powerset multi-class cross entropy loss for neural speaker diarization,” 2023.`, available [here](https://arxiv.org/abs/2310.13025).\n","* `Problem.MONO_LABEL_CLASSIFICATION`: the model prediction associates one class to each time frame"]},{"cell_type":"markdown","metadata":{"id":"wTY4-nT2TIbM"},"source":["To apply the model on the audio file, we wrap it into an `Inference` instance:"]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":657},"executionInfo":{"elapsed":1614,"status":"ok","timestamp":1704807131091,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"vKcaevu8TIbN","outputId":"e020fdb9-3c92-4f76-fcec-5053c1842d19"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["from pyannote.audio import Inference\n","inference = Inference(model, step=2.5)\n","output = inference(AUDIO_FILE)\n","output"]},{"cell_type":"markdown","metadata":{"id":"MoqfhoX_TIbO"},"source":["For each of the 9 positions of the 10s window, the model outputs a 3-dimensional vector every 17ms (589 frames for 10 seconds), corresponding to the probabilities that each of (up to) 3 speakers is active. "]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":196,"status":"ok","timestamp":1704807141814,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"JObvduJMTIbO","outputId":"af45591c-c30d-401a-8906-db029140cea2"},"outputs":[{"data":{"text/plain":["(9, 589, 3)"]},"execution_count":11,"metadata":{},"output_type":"execute_result"}],"source":["output.data.shape"]},{"cell_type":"markdown","metadata":{"id":"Zdk-iqOaTIbQ"},"source":["## Processing a file from memory\n","\n","In case the audio file is not stored on disk, pipelines can also process audio provided as a `{\"waveform\": ..., \"sample_rate\": ...}` dictionary."]},{"cell_type":"code","execution_count":12,"metadata":{"executionInfo":{"elapsed":229,"status":"ok","timestamp":1704807145587,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"oFQrkl01TIbQ"},"outputs":[{"name":"stdout","output_type":"stream","text":["type(waveform)=\n","waveform.shape=torch.Size([1, 480000])\n","waveform.dtype=torch.float32\n"]}],"source":["import torchaudio\n","waveform, sample_rate = torchaudio.load(AUDIO_FILE)\n","\n","print(f\"{type(waveform)=}\")\n","print(f\"{waveform.shape=}\")\n","print(f\"{waveform.dtype=}\")\n","\n","audio_in_memory = {\"waveform\": waveform, \"sample_rate\": sample_rate}"]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":657},"executionInfo":{"elapsed":1904,"status":"ok","timestamp":1704807149946,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"j2zi1CzHTIbR","outputId":"fb8ac3d0-c9f0-4b0a-c01f-a10612bdf254"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":13,"metadata":{},"output_type":"execute_result"}],"source":["output = inference(audio_in_memory)\n","output"]},{"cell_type":"markdown","metadata":{"id":"aB5QNx7lTIbS"},"source":["## Processing part of a file\n","\n","If needed, `Inference` can be used to process only part of a file:"]},{"cell_type":"code","execution_count":19,"metadata":{"id":"E0Pydt0VTIbT"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":19,"metadata":{},"output_type":"execute_result"}],"source":["from pyannote.core import Segment\n","output = inference.crop(audio_in_memory, Segment(0, 20))\n","output"]},{"cell_type":"markdown","metadata":{"id":"K_Z-ciLaTIbU"},"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":null,"metadata":{"id":"t_kZgFSSTIbV"},"outputs":[],"source":["# look ma: no hands!\n","offline_model = Model.from_pretrained(\"pytorch_model.bin\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"wBkIFwR-TIbV"},"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":{"accelerator":"GPU","colab":{"gpuType":"T4","provenance":[]},"kernelspec":{"display_name":"Python 3","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.10.13"},"vscode":{"interpreter":{"hash":"36a3a48a52702f18671693adf589423ec3f7db45d50f6ee539f1b0696bb58d43"}},"widgets":{"application/vnd.jupyter.widget-state+json":{"01a79756e1104be0bcbe1d233677d605":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"09ee64808a5c431b928066a4cb287a78":{"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":""}},"0c537fef94bd4a3d8c42d981a70ea35b":{"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_ecbb880cf0044404ab9bfc5995656807","placeholder":"​","style":"IPY_MODEL_79287ffea49a4e4a80191b1157de15cc","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.
"}},"0e04a45510f346b8ab3c465b10ccdfd2":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_bf5c88fe90f0462b95aa8a81467c1e9d","placeholder":"​","style":"IPY_MODEL_09ee64808a5c431b928066a4cb287a78","value":"Connecting..."}},"1a30ac8b519948bbad72886049b53d55":{"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":""}},"2b91f4b11d5848c0b6795b649bc2d7bc":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_57cf64e9c70e4057a76c2f3fb1e9b191","placeholder":"​","style":"IPY_MODEL_5e90e4818f1f43f2aa4714e0e40dc15d","value":"Your token has been saved to /root/.cache/huggingface/token"}},"2d1965df902b4b7eb6e4e28e44d6e32b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"CheckboxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"CheckboxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"CheckboxView","description":"Add token as git credential?","description_tooltip":null,"disabled":false,"indent":true,"layout":"IPY_MODEL_416ffb7703b1404ab1c19c6b1ecafb4c","style":"IPY_MODEL_5be7421c575d41128d0675dc9abbc196","value":true}},"416ffb7703b1404ab1c19c6b1ecafb4c":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"47da80658de14604a7cc5268b951c172":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"49cb317b141a43b7b8ce342e2d62ab03":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"52a4a1aab39741f2a0499428f07a4c25":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_01a79756e1104be0bcbe1d233677d605","placeholder":"​","style":"IPY_MODEL_990375a830eb4cd79c69ad78b9ac685b","value":"Token is valid (permission: write)."}},"53919e13e42441d9b8cf5eb4f2effe96":{"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":""}},"57cf64e9c70e4057a76c2f3fb1e9b191":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"5be7421c575d41128d0675dc9abbc196":{"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":""}},"5e90e4818f1f43f2aa4714e0e40dc15d":{"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":""}},"73915caf6d1042ca9a27853986217ae2":{"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_47da80658de14604a7cc5268b951c172","placeholder":"​","style":"IPY_MODEL_c7fbfffbbc304f0ba025e03beb8f638a","value":""}},"79287ffea49a4e4a80191b1157de15cc":{"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":""}},"79d55946b3764666a0b57a72722f6c19":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":"center","align_self":null,"border":null,"bottom":null,"display":"flex","flex":null,"flex_flow":"column","grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":"50%"}},"8b3353af24074ce5b5d2d9b162c61062":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"988c83c85f7d44d0be949de6eedcf977":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"990375a830eb4cd79c69ad78b9ac685b":{"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":""}},"a73cecb8608f491e8f996c5114df4d0f":{"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_52a4a1aab39741f2a0499428f07a4c25","IPY_MODEL_f23cc133109c4ecb9b383f118bcc71aa","IPY_MODEL_2b91f4b11d5848c0b6795b649bc2d7bc","IPY_MODEL_b437981acb894f97ad45daaebe2734c7"],"layout":"IPY_MODEL_79d55946b3764666a0b57a72722f6c19"}},"abc23089f4ef4d2a9f8a104fb1dba14a":{"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":""}},"b2e03b10050d46548932f429bcc18d81":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ButtonModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ButtonModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ButtonView","button_style":"","description":"Login","disabled":false,"icon":"","layout":"IPY_MODEL_8b3353af24074ce5b5d2d9b162c61062","style":"IPY_MODEL_cd40e31c191044b7a0f8fa4694ad6380","tooltip":""}},"b437981acb894f97ad45daaebe2734c7":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_fb027db34fd740c2a4758d650ae3f73c","placeholder":"​","style":"IPY_MODEL_1a30ac8b519948bbad72886049b53d55","value":"Login successful"}},"bc10c6804346449b8e349728a1acb8d2":{"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_988c83c85f7d44d0be949de6eedcf977","placeholder":"​","style":"IPY_MODEL_53919e13e42441d9b8cf5eb4f2effe96","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.
"}},"bf5c88fe90f0462b95aa8a81467c1e9d":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"c7fbfffbbc304f0ba025e03beb8f638a":{"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":""}},"cd40e31c191044b7a0f8fa4694ad6380":{"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":""}},"ecbb880cf0044404ab9bfc5995656807":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"f23cc133109c4ecb9b383f118bcc71aa":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_49cb317b141a43b7b8ce342e2d62ab03","placeholder":"​","style":"IPY_MODEL_abc23089f4ef4d2a9f8a104fb1dba14a","value":"Your token has been saved in your configured git credential helpers (store)."}},"fb027db34fd740c2a4758d650ae3f73c":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}}}}},"nbformat":4,"nbformat_minor":0} diff --git a/tutorials/applying_a_pipeline.ipynb b/tutorials/applying_a_pipeline.ipynb index c1080071d..945caab4e 100644 --- a/tutorials/applying_a_pipeline.ipynb +++ b/tutorials/applying_a_pipeline.ipynb @@ -1,400 +1 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Applying a pretrained pipeline\n", - "\n", - "In this tutorial, you will learn how to apply `pyannote.audio` pipelines on an audio file.\n", - "\n", - "A pipeline takes an audio file as input and returns a labeled temporal segmentation of the audio file. \n", - "\n", - "More precisely, it usually applies a pretrained model (= neural network) on the audio file, post-processes the output of the model, and returns its output as a [`pyannote.core.Annotation`](http://pyannote.github.io/pyannote-core/structure.html#annotation) instance. It should become clearer as you keep reading..." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading pipeline from 🤗 hub\n", - "\n", - "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": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['pyannote/overlapped-speech-detection',\n", - " 'pyannote/speaker-diarization',\n", - " 'pyannote/speaker-segmentation',\n", - " 'pyannote/voice-activity-detection']" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from huggingface_hub import HfApi\n", - "available_pipelines = [p.modelId for p in HfApi().list_models(filter=\"pyannote-audio-pipeline\")]\n", - "list(filter(lambda p: p.startswith(\"pyannote/\"), available_pipelines))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "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", - "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": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9466934e67254fe6a7ff67b727a3f3ab", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HTML(value='
" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# we visualize [0, 30] time range\n", - "from pyannote.core import notebook, Segment\n", - "notebook.crop = Segment(0, 30)\n", - "dia" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "When available, the reference annotation can be visualized too, for comparison:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.database.util import load_rttm\n", - "REFERENCE = f\"{ROOT_DIR}/tutorials/assets/sample.rttm\"\n", - "reference = load_rttm(REFERENCE)[\"sample\"]\n", - "\n", - "# map hypothesized and reference speakers for visualization purposes\n", - "pipeline.optimal_mapping(dia, reference)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Processing a file from memory\n", - "\n", - "In case the audio file is not stored on disk, pipelines can also process audio provided as a `{\"waveform\": ..., \"sample_rate\": ...}` dictionary. " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "type(waveform)=\n", - "waveform.shape=torch.Size([1, 480000])\n", - "waveform.dtype=torch.float32\n" - ] - } - ], - "source": [ - "import torchaudio\n", - "waveform, sample_rate = torchaudio.load(AUDIO_FILE)\n", - "\n", - "print(f\"{type(waveform)=}\")\n", - "print(f\"{waveform.shape=}\")\n", - "print(f\"{waveform.dtype=}\")\n", - "\n", - "audio_in_memory = {\"waveform\": waveform, \"sample_rate\": sample_rate}" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "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.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, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"markdown","metadata":{},"source":["**\"Open**"]},{"cell_type":"markdown","metadata":{"id":"uiNbotxCeq4b"},"source":["# Applying a pretrained pipeline\n","\n","In this tutorial, you will learn how to apply `pyannote.audio` pipelines on an audio file.\n","\n","A pipeline takes an audio file as input and returns a labeled temporal segmentation of the audio file.\n","\n","More precisely, it usually applies a pretrained model (= neural network) on the audio file, post-processes the output of the model, and returns its output as a [`pyannote.core.Annotation`](http://pyannote.github.io/pyannote-core/structure.html#annotation) instance. It should become clearer as you keep reading..."]},{"cell_type":"markdown","metadata":{"id":"z_4VUpZxesS2"},"source":["## Tutorial setup"]},{"cell_type":"markdown","metadata":{"id":"gbonpHYte3FC"},"source":["### `Google Colab` setup\n"]},{"cell_type":"markdown","metadata":{"id":"hxhhcj8Fe7v7"},"source":["If you are running this tutorial on `Colab`, execute the following commands in order to setup `Colab` environment. These commands will install `pyannote.audio`, and download resources used in this tutorial."]},{"cell_type":"code","execution_count":4,"metadata":{"executionInfo":{"elapsed":17283,"status":"ok","timestamp":1704808539241,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"NFdANMKsfD1p"},"outputs":[],"source":["!pip install -qq pyannote.audio==3.1.1\n","!pip install -qq ipython==7.34.0\n","!wget -q \"https://github.com/pyannote/pyannote-audio/raw/develop/tutorials/assets/sample.wav\"\n","!wget -q \"https://github.com/pyannote/pyannote-audio/raw/develop/tutorials/assets/sample.rttm\"\n","!wget -q -P ./assets/ \"https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/assets/download-model.png\"\n","!wget -q -P ./assets/ \"https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/assets/download-pipeline.png\""]},{"cell_type":"markdown","metadata":{"id":"PScZ6o_9gkfo"},"source":["⚠ Restart the runtime (Runtime > Restart session)."]},{"cell_type":"code","execution_count":13,"metadata":{"executionInfo":{"elapsed":458,"status":"ok","timestamp":1704809048938,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"ZU_QIx1UhcV6"},"outputs":[],"source":["AUDIO_FILE = \"sample.wav\"\n","REFERENCE = \"sample.rttm\""]},{"cell_type":"markdown","metadata":{"id":"d-qKbc9shI6o"},"source":["### Non `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"0KEh-IGqho6F"},"source":["If you are not using Colab, clone `pyannote.audio` [GitHub repository](https://github.com/pyannote/pyannote-audio) and update ROOT_DIR accordingly"]},{"cell_type":"code","execution_count":10,"metadata":{"id":"DuoohiL6hOiJ"},"outputs":[],"source":["ROOT_DIR = \"/pyannote-audio\"\n","AUDIO_FILE = f\"{ROOT_DIR}/tutorials/assets/sample.wav\"\n","REFERENCE = f\"{ROOT_DIR}/tutorials/assets/sample.rttm\""]},{"cell_type":"markdown","metadata":{"id":"yA9JsY84eq4e"},"source":["## Loading pipeline from 🤗 hub\n","\n","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":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":2323,"status":"ok","timestamp":1704808592263,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"eAXGgYt8eq4f","outputId":"86772355-3bf0-42e5-c478-2d35a80853e9"},"outputs":[{"data":{"text/plain":["['pyannote/overlapped-speech-detection',\n"," 'pyannote/speaker-diarization',\n"," 'pyannote/speaker-segmentation',\n"," 'pyannote/voice-activity-detection',\n"," 'pyannote/speaker-diarization-3.0',\n"," 'pyannote/speaker-diarization-3.1']"]},"execution_count":2,"metadata":{},"output_type":"execute_result"}],"source":["from huggingface_hub import HfApi\n","available_pipelines = [p.modelId for p in HfApi().list_models(filter=\"pyannote-audio-pipeline\")]\n","list(filter(lambda p: p.startswith(\"pyannote/\"), available_pipelines))"]},{"cell_type":"markdown","metadata":{"id":"fry3qMrJeq4h"},"source":["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","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,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145,"referenced_widgets":["6fe26270a8794dea85b9ac8dedde6353","f9969c7acd834359bd67e83c31b82c0b","ef6be001daaa465598bdf20c304bae0b","a8e61b300a324911b1d3babf6b1ebac1","45c2352ba41b46288c8ba74c661e1f85","78f428e1d8ac4c78bd84d208a78b1fe5","9d7b5e47af9448c98a2a434f02b54633","253408a6cab947c7b9ae40a14e255328","a435c85128f148cb80152d03825710e2","90533da4fc1341a28bc247bc9fbbbe9e","6556790d1997431a8476447297e3f595","5253489738b249f69b30f1c84884a95a","3f500b1182a945c3b8b546b1bd04f98e","c3b3069a93994e55b993cab04c066f17","f77186e2976d4a7daa798fd9f0f7b4cb","7ffa4930e0a7421e9464abff87bbde7f","1dd6bfb824ba4919ba392e0d4cd5ac82","7c23cd10c573438c840148ba1afaa5f3","bc4d3f45eaf04cccb7a655ef87d7a927","36f60aa99ea84b739f066c6ee216f159","5033834cc66f49efaa16b240245ec1d3","0b127e22a6de4339aecc1e76a6719d7f","8a7afaf126ac49dcaf24d64c2d918086","1b5f49211db54348924a05482ca7379d","1f3be36a57074214a5f92e08165e41be","275642719b694328ad3b0fb06b53e42a","ae378b480ed747438bcbe147a7e8d277","b22a1d21940e4995b72642b003ae1301","58e423b86bf349aa89fc81a2b0d0f697","a3ebe0f0e6e44522a2545db0ed47af62","dc9c065286e544df921e5bc4a51faf64","16244ab1dc76493d9fafad80a9b65700"]},"executionInfo":{"elapsed":418,"status":"ok","timestamp":1704808601143,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"IdXJumYveq4i","outputId":"cb87e106-b30f-4ec8-e726-d797ca98698b"},"outputs":[],"source":["from huggingface_hub import notebook_login\n","notebook_login()"]},{"cell_type":"markdown","metadata":{"id":"ym2671Fweq4j"},"source":["Once authenticated, you can load the pipeline (and the internal models)..."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":266,"referenced_widgets":["5a2a95f41f014663b5d131635844e3c8","f8df65e5ad6444648681230f415b8d08","17e14569a3f74cbf991b582c27fdf280","4e0ca7f084804d30a89cb9dc439b6cdc","d304f698c6f34f3692548267ca0aba47","3f69734124f7449da0efffbbfd1153fe","686b58e0ccee468f938ea5659f3a9623","e98b1f7ec5e04e748069340fa2fcec2d","616f35eccdd34bcdb5c9f700103ff538","185457147fe44751a1c6e7ae6ad23570","b02b253086e34249ae1d896a75a08960","0b191fb0d6db4f1a98a641dc50445f1e","4a589ea883de4409b7a8275127747fa7","b5f4829158cf4a5c8350966d8eacbf60","7cab72ad0ace45d58d6954021082ace7","5440ac4cffa0438c99c0daeca27a4087","0d0dfc2576784812b6abf673752fa812","84e416e01cfa4a79b0294a44cfd77f32","b33021db4313476ab8bcb85bb1b190d7","6d5431955c09424a96e825aa9bba1b62","54eacc5604f64f658617cde596a728dd","1749a0e7fc6847849ab40ac7f764b699","ff048516fdba44a48a69c51a82aa7aaa","775611277f1948a5ab95641c4e92ff2e","c955f8144b46451493474e02726b5deb","c9eeb26bd5e049f89205e494d54e3818","d4d428f0b0c44756a128adae747716d2","70d672feec1c452aa49a40a3b8c1a4f0","e8b3188ee4934ab4becbc431fc4ccb0b","754a843fd634446b8d246998eaded1fa","1e53e26668aa4f8dabdd6973b79b5b9f","cf5ae82d36384a728d8ca893cc27392b","5cc77ca8ba304ad88342ed6ced6c6a4a","6412ef268e11484f8bbcdb510f66ee21","a987408c2f994329a9a80208b22e3c52","9446f61936c4421d9610464984890353","a80c0fb6a1254bb9a00741c1346b9d9a","b55e95f31216480fa6c81bd1b57ad729","517a1b1faec045f7847ca84f0538f4e1","008a47e4d1174b188e75232fed325398","30864d7b4d074994ba643c73875a67b8","b852998433e24f7fad1fe27e249085f9","46ac2d0bfedc47c8836e8dde0fc91662","58b140d0453a4a219bc64e0152cc5c5e","3bb60a8db7c0406f8debdc8dd88bcdb4","bf644ae3e2894787bb416740749200cd","0fccc53081a34d58a46912d1ceae0533","39cd6fe37b6f4476b6032c29f026d570","87a0e712c0b045449b98ee368c62fff2","2be7c1f5fe32462f8d1cd7ea57cfbf3a","d6135ce9cfaa4f8496a70cee4f1e89a7","00ac431507a54c0d9a41244013b1c0f3","6f318bc3e900434a9134a79e4057f666","7580595b498a4c50b748af9df67132e2","3f1d750804a54d78a6abff2623441360"]},"executionInfo":{"elapsed":30028,"status":"ok","timestamp":1704808674003,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"1NihzPUPeq4k","outputId":"04275648-23ef-4453-9bf4-8d8dfadd99e0"},"outputs":[],"source":["from pyannote.audio import Pipeline\n","pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization-3.1\", use_auth_token=True)"]},{"cell_type":"markdown","metadata":{"id":"cZhtRXAHeq4l"},"source":["## Processing a file from disk"]},{"cell_type":"markdown","metadata":{"id":"X7hQRbzeeq4m"},"source":["... and apply it to an audio file. \n","\n","The pipeline will automatically use GPUs when available.\n","On CPU it might take a long while (up to 10x RT)."]},{"cell_type":"code","execution_count":9,"metadata":{"executionInfo":{"elapsed":82100,"status":"ok","timestamp":1704808982782,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"digxFLaueq4n"},"outputs":[],"source":["dia = pipeline(AUDIO_FILE)"]},{"cell_type":"markdown","metadata":{"id":"9WTsQVjjeq4o"},"source":["## Visualizing the output\n","\n","Most pipelines return a [`pyannote.core.Annotation`](http://pyannote.github.io/pyannote-core/structure.html#annotation) instance..."]},{"cell_type":"code","execution_count":10,"metadata":{"executionInfo":{"elapsed":1079,"status":"ok","timestamp":1704809008347,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"Ch7SaA4-eq4p"},"outputs":[],"source":["from pyannote.core import Annotation\n","assert isinstance(dia, Annotation)"]},{"cell_type":"markdown","metadata":{"id":"T4BsOhmXeq4p"},"source":["... whose [API](https://pyannote.github.io/pyannote-core/structure.html#annotation) you can use to print the result:"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":610,"status":"ok","timestamp":1704809011691,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"OzEPn1hqeq4p","outputId":"e61015ad-c0df-4890-acc6-f65c87d7c30d"},"outputs":[{"name":"stdout","output_type":"stream","text":[" 6.7 7.2 SPEAKER_01\n"," 7.2 7.2 SPEAKER_02\n"," 7.6 8.3 SPEAKER_01\n"," 8.3 9.9 SPEAKER_02\n"," 9.9 10.9 SPEAKER_01\n","10.5 14.7 SPEAKER_02\n","10.9 11.0 SPEAKER_00\n","14.3 17.9 SPEAKER_00\n","18.0 21.5 SPEAKER_02\n","18.2 18.4 SPEAKER_00\n","21.8 28.5 SPEAKER_00\n","27.9 30.0 SPEAKER_02\n"]}],"source":["for speech_turn, track, speaker in dia.itertracks(yield_label=True):\n"," print(f\"{speech_turn.start:4.1f} {speech_turn.end:4.1f} {speaker}\")"]},{"cell_type":"markdown","metadata":{"id":"PqiV2D2geq4q"},"source":["If you happen to be running this example in a _Jupyter notebook_, `dia` can be [visualized directly](http://pyannote.github.io/pyannote-core/visualization.html):"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":220},"executionInfo":{"elapsed":841,"status":"ok","timestamp":1704809016036,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"80D-4Yhreq4r","outputId":"ee02c234-ebc6-40f3-94b1-0838fac05f81"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":12,"metadata":{},"output_type":"execute_result"}],"source":["# we visualize [0, 30] time range\n","from pyannote.core import notebook, Segment\n","notebook.crop = Segment(0, 30)\n","dia"]},{"cell_type":"markdown","metadata":{"id":"TC_ZiDYoeq4s"},"source":["When available, the reference annotation can be visualized too, for comparison:"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":220},"executionInfo":{"elapsed":1085,"status":"ok","timestamp":1704809060416,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"xlcEFiHUeq4s","outputId":"d30ad6ba-a0c6-416d-eb8c-5c8e93f309da"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":14,"metadata":{},"output_type":"execute_result"}],"source":["from pyannote.database.util import load_rttm\n","\n","reference = load_rttm(REFERENCE)[\"sample\"]\n","\n","# map hypothesized and reference speakers for visualization purposes\n","pipeline.optimal_mapping(dia, reference)"]},{"cell_type":"markdown","metadata":{"id":"rfTV3nSSeq4t"},"source":["## Processing a file from memory\n","\n","In case the audio file is not stored on disk, pipelines can also process audio provided as a `{\"waveform\": ..., \"sample_rate\": ...}` dictionary."]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":410,"status":"ok","timestamp":1704809066383,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"Nha4sg76eq4u","outputId":"69192d82-c240-47d1-fe01-d373c2b4e500"},"outputs":[{"name":"stdout","output_type":"stream","text":["type(waveform)=\n","waveform.shape=torch.Size([1, 480000])\n","waveform.dtype=torch.float32\n"]}],"source":["import torchaudio\n","waveform, sample_rate = torchaudio.load(AUDIO_FILE)\n","\n","print(f\"{type(waveform)=}\")\n","print(f\"{waveform.shape=}\")\n","print(f\"{waveform.dtype=}\")\n","\n","audio_in_memory = {\"waveform\": waveform, \"sample_rate\": sample_rate}"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":388,"referenced_widgets":["514552137d7442368b39aaddce056bb8","f744ac29ccdd4d9d91050fabaed13e16","f18c80869ccc4ce1b2a215293d493e19","2c0b1ed212544e14b4934e036e8736d7","9988b4433d6e4c58a819a2e1b54f57b2","b8861f8cb72c4e65afac6519b7004170","668a49e70c2b4c8a9dcb534cb30714d6","9025d2b6c7b14162a692b98c3e86ec8a","6c361855da5e4eb78e311defb2ca2f2b","3be13f7f05da47b1ae3795ead9f2546a","07bb94f0dcda45a9a5e2d553fd239106","57ef34701b594a60a9fd269943b49888","1d051eb2d87e4671aa08039761c7899a","9537f195677745cba18618764b2290ab","4f0d63f098b0491097c6b72f3baee04f","f7be373f08c64c8bb5b6e070a7373cca","be8b64ce7f8247499c8bbcb62c5dd902","491c3dcba4474a52b860080fa7a627e7","4abbe0d8e0fa4e1b9d712743013b2d4e","661c7494ef2d47c794e6236e5f2c8978","6358920ecd46403a87cca46509465076","4f25b89365b24056b803119d415ac056","1d97d11a99454cc990cc5e374d0f8197","425146d4e0fb453486629d9d6af0a999","8fad50e0475341d9801e9f86e04e15c7","ea03f9526a7440a0a9a281ee877892fd","d1863b2c9ebc4efa9cac2dad7dfaf53a","8bda58a4c0c6430ca1470282ddbe8222","5d38b6ceec1844068f48da7bedf471fa","2a72c7660c2f498089c63c78eaa69fc8","05283cf0054d412c9a1ebfcc44bf41cb","b9d9acd287c345debdff1e72a85641af","91ca95844e084619b9ae01fe8176f875"]},"executionInfo":{"elapsed":12810,"status":"ok","timestamp":1704809082573,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"LvboMeeYeq4u","outputId":"225dd352-6367-4793-ae11-f8125d930c2b"},"outputs":[],"source":["vad = Pipeline.from_pretrained(\"pyannote/voice-activity-detection\", use_auth_token=True)"]},{"cell_type":"code","execution_count":12,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":12,"metadata":{},"output_type":"execute_result"}],"source":["vad(audio_in_memory)"]},{"cell_type":"markdown","metadata":{"id":"LllNe0s3eq4u"},"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","![](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/assets/download-pipeline.png?raw=1)\n","\n","* Step 2: download the `pytorch_model.bin` model\n","\n","![](https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/assets/download-model.png?raw=1)\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":null,"metadata":{"id":"a1bZGOoEeq4v","outputId":"a8851164-100c-4cc1-afd2-d387a5fc4fd5"},"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":null,"metadata":{"id":"eepjEec8eq4w"},"outputs":[],"source":["# just checking output is the same\n","assert (vad(audio_in_memory) == offline_vad(audio_in_memory))"]}],"metadata":{"accelerator":"GPU","colab":{"gpuType":"T4","provenance":[{"file_id":"https://github.com/pyannote/pyannote-audio/blob/develop/tutorials/applying_a_pipeline.ipynb","timestamp":1704808199718}]},"kernelspec":{"display_name":"Python 3","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.10.13"},"vscode":{"interpreter":{"hash":"36a3a48a52702f18671693adf589423ec3f7db45d50f6ee539f1b0696bb58d43"}},"widgets":{"application/vnd.jupyter.widget-state+json":{"008a47e4d1174b188e75232fed325398":{"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":""}},"00ac431507a54c0d9a41244013b1c0f3":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"05283cf0054d412c9a1ebfcc44bf41cb":{"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":""}},"07bb94f0dcda45a9a5e2d553fd239106":{"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":""}},"0b127e22a6de4339aecc1e76a6719d7f":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_ae378b480ed747438bcbe147a7e8d277","placeholder":"​","style":"IPY_MODEL_b22a1d21940e4995b72642b003ae1301","value":"Your token has been saved in your configured git credential helpers (store)."}},"0b191fb0d6db4f1a98a641dc50445f1e":{"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_4a589ea883de4409b7a8275127747fa7","IPY_MODEL_b5f4829158cf4a5c8350966d8eacbf60","IPY_MODEL_7cab72ad0ace45d58d6954021082ace7"],"layout":"IPY_MODEL_5440ac4cffa0438c99c0daeca27a4087"}},"0d0dfc2576784812b6abf673752fa812":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"0fccc53081a34d58a46912d1ceae0533":{"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_00ac431507a54c0d9a41244013b1c0f3","max":221,"min":0,"orientation":"horizontal","style":"IPY_MODEL_6f318bc3e900434a9134a79e4057f666","value":221}},"16244ab1dc76493d9fafad80a9b65700":{"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":""}},"1749a0e7fc6847849ab40ac7f764b699":{"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":""}},"17e14569a3f74cbf991b582c27fdf280":{"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_e98b1f7ec5e04e748069340fa2fcec2d","max":469,"min":0,"orientation":"horizontal","style":"IPY_MODEL_616f35eccdd34bcdb5c9f700103ff538","value":469}},"185457147fe44751a1c6e7ae6ad23570":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"1b5f49211db54348924a05482ca7379d":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_dc9c065286e544df921e5bc4a51faf64","placeholder":"​","style":"IPY_MODEL_16244ab1dc76493d9fafad80a9b65700","value":"Login successful"}},"1d051eb2d87e4671aa08039761c7899a":{"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_be8b64ce7f8247499c8bbcb62c5dd902","placeholder":"​","style":"IPY_MODEL_491c3dcba4474a52b860080fa7a627e7","value":"pytorch_model.bin: 100%"}},"1d97d11a99454cc990cc5e374d0f8197":{"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_425146d4e0fb453486629d9d6af0a999","IPY_MODEL_8fad50e0475341d9801e9f86e04e15c7","IPY_MODEL_ea03f9526a7440a0a9a281ee877892fd"],"layout":"IPY_MODEL_d1863b2c9ebc4efa9cac2dad7dfaf53a"}},"1dd6bfb824ba4919ba392e0d4cd5ac82":{"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":""}},"1e53e26668aa4f8dabdd6973b79b5b9f":{"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":""}},"1f3be36a57074214a5f92e08165e41be":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"253408a6cab947c7b9ae40a14e255328":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"275642719b694328ad3b0fb06b53e42a":{"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":""}},"2a72c7660c2f498089c63c78eaa69fc8":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"2be7c1f5fe32462f8d1cd7ea57cfbf3a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"2c0b1ed212544e14b4934e036e8736d7":{"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_3be13f7f05da47b1ae3795ead9f2546a","placeholder":"​","style":"IPY_MODEL_07bb94f0dcda45a9a5e2d553fd239106","value":" 277/277 [00:00<00:00, 14.5kB/s]"}},"30864d7b4d074994ba643c73875a67b8":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"36f60aa99ea84b739f066c6ee216f159":{"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":""}},"39cd6fe37b6f4476b6032c29f026d570":{"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_7580595b498a4c50b748af9df67132e2","placeholder":"​","style":"IPY_MODEL_3f1d750804a54d78a6abff2623441360","value":" 221/221 [00:00<00:00, 14.0kB/s]"}},"3bb60a8db7c0406f8debdc8dd88bcdb4":{"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_bf644ae3e2894787bb416740749200cd","IPY_MODEL_0fccc53081a34d58a46912d1ceae0533","IPY_MODEL_39cd6fe37b6f4476b6032c29f026d570"],"layout":"IPY_MODEL_87a0e712c0b045449b98ee368c62fff2"}},"3be13f7f05da47b1ae3795ead9f2546a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"3f1d750804a54d78a6abff2623441360":{"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":""}},"3f500b1182a945c3b8b546b1bd04f98e":{"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":""}},"3f69734124f7449da0efffbbfd1153fe":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"425146d4e0fb453486629d9d6af0a999":{"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_8bda58a4c0c6430ca1470282ddbe8222","placeholder":"​","style":"IPY_MODEL_5d38b6ceec1844068f48da7bedf471fa","value":"config.yaml: 100%"}},"45c2352ba41b46288c8ba74c661e1f85":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ButtonModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ButtonModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ButtonView","button_style":"","description":"Login","disabled":false,"icon":"","layout":"IPY_MODEL_c3b3069a93994e55b993cab04c066f17","style":"IPY_MODEL_f77186e2976d4a7daa798fd9f0f7b4cb","tooltip":""}},"46ac2d0bfedc47c8836e8dde0fc91662":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"491c3dcba4474a52b860080fa7a627e7":{"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":""}},"4a589ea883de4409b7a8275127747fa7":{"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_0d0dfc2576784812b6abf673752fa812","placeholder":"​","style":"IPY_MODEL_84e416e01cfa4a79b0294a44cfd77f32","value":"pytorch_model.bin: 100%"}},"4abbe0d8e0fa4e1b9d712743013b2d4e":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"4e0ca7f084804d30a89cb9dc439b6cdc":{"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_185457147fe44751a1c6e7ae6ad23570","placeholder":"​","style":"IPY_MODEL_b02b253086e34249ae1d896a75a08960","value":" 469/469 [00:00<00:00, 34.3kB/s]"}},"4f0d63f098b0491097c6b72f3baee04f":{"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_6358920ecd46403a87cca46509465076","placeholder":"​","style":"IPY_MODEL_4f25b89365b24056b803119d415ac056","value":" 17.7M/17.7M [00:00<00:00, 66.5MB/s]"}},"4f25b89365b24056b803119d415ac056":{"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":""}},"5033834cc66f49efaa16b240245ec1d3":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_1f3be36a57074214a5f92e08165e41be","placeholder":"​","style":"IPY_MODEL_275642719b694328ad3b0fb06b53e42a","value":"Token is valid (permission: write)."}},"514552137d7442368b39aaddce056bb8":{"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_f744ac29ccdd4d9d91050fabaed13e16","IPY_MODEL_f18c80869ccc4ce1b2a215293d493e19","IPY_MODEL_2c0b1ed212544e14b4934e036e8736d7"],"layout":"IPY_MODEL_9988b4433d6e4c58a819a2e1b54f57b2"}},"517a1b1faec045f7847ca84f0538f4e1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"5253489738b249f69b30f1c84884a95a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"5440ac4cffa0438c99c0daeca27a4087":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"54eacc5604f64f658617cde596a728dd":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"57ef34701b594a60a9fd269943b49888":{"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_1d051eb2d87e4671aa08039761c7899a","IPY_MODEL_9537f195677745cba18618764b2290ab","IPY_MODEL_4f0d63f098b0491097c6b72f3baee04f"],"layout":"IPY_MODEL_f7be373f08c64c8bb5b6e070a7373cca"}},"58b140d0453a4a219bc64e0152cc5c5e":{"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":""}},"58e423b86bf349aa89fc81a2b0d0f697":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"5a2a95f41f014663b5d131635844e3c8":{"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_f8df65e5ad6444648681230f415b8d08","IPY_MODEL_17e14569a3f74cbf991b582c27fdf280","IPY_MODEL_4e0ca7f084804d30a89cb9dc439b6cdc"],"layout":"IPY_MODEL_d304f698c6f34f3692548267ca0aba47"}},"5cc77ca8ba304ad88342ed6ced6c6a4a":{"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":""}},"5d38b6ceec1844068f48da7bedf471fa":{"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":""}},"616f35eccdd34bcdb5c9f700103ff538":{"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":""}},"6358920ecd46403a87cca46509465076":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"6412ef268e11484f8bbcdb510f66ee21":{"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_a987408c2f994329a9a80208b22e3c52","IPY_MODEL_9446f61936c4421d9610464984890353","IPY_MODEL_a80c0fb6a1254bb9a00741c1346b9d9a"],"layout":"IPY_MODEL_b55e95f31216480fa6c81bd1b57ad729"}},"6556790d1997431a8476447297e3f595":{"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":""}},"661c7494ef2d47c794e6236e5f2c8978":{"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":""}},"668a49e70c2b4c8a9dcb534cb30714d6":{"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":""}},"686b58e0ccee468f938ea5659f3a9623":{"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":""}},"6c361855da5e4eb78e311defb2ca2f2b":{"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":""}},"6d5431955c09424a96e825aa9bba1b62":{"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":""}},"6f318bc3e900434a9134a79e4057f666":{"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":""}},"6fe26270a8794dea85b9ac8dedde6353":{"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_5033834cc66f49efaa16b240245ec1d3","IPY_MODEL_0b127e22a6de4339aecc1e76a6719d7f","IPY_MODEL_8a7afaf126ac49dcaf24d64c2d918086","IPY_MODEL_1b5f49211db54348924a05482ca7379d"],"layout":"IPY_MODEL_9d7b5e47af9448c98a2a434f02b54633"}},"70d672feec1c452aa49a40a3b8c1a4f0":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"754a843fd634446b8d246998eaded1fa":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"7580595b498a4c50b748af9df67132e2":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"775611277f1948a5ab95641c4e92ff2e":{"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_70d672feec1c452aa49a40a3b8c1a4f0","placeholder":"​","style":"IPY_MODEL_e8b3188ee4934ab4becbc431fc4ccb0b","value":"config.yaml: 100%"}},"78f428e1d8ac4c78bd84d208a78b1fe5":{"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_7ffa4930e0a7421e9464abff87bbde7f","placeholder":"​","style":"IPY_MODEL_1dd6bfb824ba4919ba392e0d4cd5ac82","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.
"}},"7c23cd10c573438c840148ba1afaa5f3":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_bc4d3f45eaf04cccb7a655ef87d7a927","placeholder":"​","style":"IPY_MODEL_36f60aa99ea84b739f066c6ee216f159","value":"Connecting..."}},"7cab72ad0ace45d58d6954021082ace7":{"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_54eacc5604f64f658617cde596a728dd","placeholder":"​","style":"IPY_MODEL_1749a0e7fc6847849ab40ac7f764b699","value":" 5.91M/5.91M [00:00<00:00, 88.7MB/s]"}},"7ffa4930e0a7421e9464abff87bbde7f":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"84e416e01cfa4a79b0294a44cfd77f32":{"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":""}},"87a0e712c0b045449b98ee368c62fff2":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"8a7afaf126ac49dcaf24d64c2d918086":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_58e423b86bf349aa89fc81a2b0d0f697","placeholder":"​","style":"IPY_MODEL_a3ebe0f0e6e44522a2545db0ed47af62","value":"Your token has been saved to /root/.cache/huggingface/token"}},"8bda58a4c0c6430ca1470282ddbe8222":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"8fad50e0475341d9801e9f86e04e15c7":{"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_2a72c7660c2f498089c63c78eaa69fc8","max":1980,"min":0,"orientation":"horizontal","style":"IPY_MODEL_05283cf0054d412c9a1ebfcc44bf41cb","value":1980}},"9025d2b6c7b14162a692b98c3e86ec8a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"90533da4fc1341a28bc247bc9fbbbe9e":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"91ca95844e084619b9ae01fe8176f875":{"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":""}},"9446f61936c4421d9610464984890353":{"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_30864d7b4d074994ba643c73875a67b8","max":26645418,"min":0,"orientation":"horizontal","style":"IPY_MODEL_b852998433e24f7fad1fe27e249085f9","value":26645418}},"9537f195677745cba18618764b2290ab":{"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_4abbe0d8e0fa4e1b9d712743013b2d4e","max":17739960,"min":0,"orientation":"horizontal","style":"IPY_MODEL_661c7494ef2d47c794e6236e5f2c8978","value":17739960}},"9988b4433d6e4c58a819a2e1b54f57b2":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"9d7b5e47af9448c98a2a434f02b54633":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":"center","align_self":null,"border":null,"bottom":null,"display":"flex","flex":null,"flex_flow":"column","grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":"50%"}},"a3ebe0f0e6e44522a2545db0ed47af62":{"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":""}},"a435c85128f148cb80152d03825710e2":{"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":""}},"a80c0fb6a1254bb9a00741c1346b9d9a":{"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_46ac2d0bfedc47c8836e8dde0fc91662","placeholder":"​","style":"IPY_MODEL_58b140d0453a4a219bc64e0152cc5c5e","value":" 26.6M/26.6M [00:00<00:00, 104MB/s]"}},"a8e61b300a324911b1d3babf6b1ebac1":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"CheckboxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"CheckboxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"CheckboxView","description":"Add token as git credential?","description_tooltip":null,"disabled":false,"indent":true,"layout":"IPY_MODEL_5253489738b249f69b30f1c84884a95a","style":"IPY_MODEL_3f500b1182a945c3b8b546b1bd04f98e","value":true}},"a987408c2f994329a9a80208b22e3c52":{"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_517a1b1faec045f7847ca84f0538f4e1","placeholder":"​","style":"IPY_MODEL_008a47e4d1174b188e75232fed325398","value":"pytorch_model.bin: 100%"}},"ae378b480ed747438bcbe147a7e8d277":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b02b253086e34249ae1d896a75a08960":{"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":""}},"b22a1d21940e4995b72642b003ae1301":{"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":""}},"b33021db4313476ab8bcb85bb1b190d7":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b55e95f31216480fa6c81bd1b57ad729":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b5f4829158cf4a5c8350966d8eacbf60":{"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_b33021db4313476ab8bcb85bb1b190d7","max":5905440,"min":0,"orientation":"horizontal","style":"IPY_MODEL_6d5431955c09424a96e825aa9bba1b62","value":5905440}},"b852998433e24f7fad1fe27e249085f9":{"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":""}},"b8861f8cb72c4e65afac6519b7004170":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b9d9acd287c345debdff1e72a85641af":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bc4d3f45eaf04cccb7a655ef87d7a927":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"be8b64ce7f8247499c8bbcb62c5dd902":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bf644ae3e2894787bb416740749200cd":{"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_2be7c1f5fe32462f8d1cd7ea57cfbf3a","placeholder":"​","style":"IPY_MODEL_d6135ce9cfaa4f8496a70cee4f1e89a7","value":"config.yaml: 100%"}},"c3b3069a93994e55b993cab04c066f17":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"c955f8144b46451493474e02726b5deb":{"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_754a843fd634446b8d246998eaded1fa","max":399,"min":0,"orientation":"horizontal","style":"IPY_MODEL_1e53e26668aa4f8dabdd6973b79b5b9f","value":399}},"c9eeb26bd5e049f89205e494d54e3818":{"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_cf5ae82d36384a728d8ca893cc27392b","placeholder":"​","style":"IPY_MODEL_5cc77ca8ba304ad88342ed6ced6c6a4a","value":" 399/399 [00:00<00:00, 24.8kB/s]"}},"cf5ae82d36384a728d8ca893cc27392b":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"d1863b2c9ebc4efa9cac2dad7dfaf53a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"d304f698c6f34f3692548267ca0aba47":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"d4d428f0b0c44756a128adae747716d2":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"d6135ce9cfaa4f8496a70cee4f1e89a7":{"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":""}},"dc9c065286e544df921e5bc4a51faf64":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"e8b3188ee4934ab4becbc431fc4ccb0b":{"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":""}},"e98b1f7ec5e04e748069340fa2fcec2d":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"ea03f9526a7440a0a9a281ee877892fd":{"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_b9d9acd287c345debdff1e72a85641af","placeholder":"​","style":"IPY_MODEL_91ca95844e084619b9ae01fe8176f875","value":" 1.98k/1.98k [00:00<00:00, 122kB/s]"}},"ef6be001daaa465598bdf20c304bae0b":{"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_90533da4fc1341a28bc247bc9fbbbe9e","placeholder":"​","style":"IPY_MODEL_6556790d1997431a8476447297e3f595","value":""}},"f18c80869ccc4ce1b2a215293d493e19":{"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_9025d2b6c7b14162a692b98c3e86ec8a","max":277,"min":0,"orientation":"horizontal","style":"IPY_MODEL_6c361855da5e4eb78e311defb2ca2f2b","value":277}},"f744ac29ccdd4d9d91050fabaed13e16":{"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_b8861f8cb72c4e65afac6519b7004170","placeholder":"​","style":"IPY_MODEL_668a49e70c2b4c8a9dcb534cb30714d6","value":"config.yaml: 100%"}},"f77186e2976d4a7daa798fd9f0f7b4cb":{"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":""}},"f7be373f08c64c8bb5b6e070a7373cca":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"f8df65e5ad6444648681230f415b8d08":{"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_3f69734124f7449da0efffbbfd1153fe","placeholder":"​","style":"IPY_MODEL_686b58e0ccee468f938ea5659f3a9623","value":"config.yaml: 100%"}},"f9969c7acd834359bd67e83c31b82c0b":{"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_253408a6cab947c7b9ae40a14e255328","placeholder":"​","style":"IPY_MODEL_a435c85128f148cb80152d03825710e2","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.
"}},"ff048516fdba44a48a69c51a82aa7aaa":{"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_775611277f1948a5ab95641c4e92ff2e","IPY_MODEL_c955f8144b46451493474e02726b5deb","IPY_MODEL_c9eeb26bd5e049f89205e494d54e3818"],"layout":"IPY_MODEL_d4d428f0b0c44756a128adae747716d2"}}}}},"nbformat":4,"nbformat_minor":0} diff --git a/tutorials/assets/download-model.png b/tutorials/assets/download-model.png index 4ca5350f537969f2f3ba1e6e7f6315acd8555474..8105001789c0aa89717770873a41400ca3419636 100644 GIT binary patch literal 316384 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

W>_#6y`~>|=@lUjZ)U0^e0gtgbVV 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�+Amha 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 A0ssI2 literal 482731 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

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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 diff --git a/tutorials/intro.ipynb b/tutorials/intro.ipynb index 572ea2f6d..328ddceaf 100644 --- a/tutorials/intro.ipynb +++ b/tutorials/intro.ipynb @@ -10,15 +10,6 @@ "\"Open" ] }, - { - "cell_type": "markdown", - "metadata": { - "id": "9-KmdPlBYnp6" - }, - "source": [ - "\"Open" - ] - }, { "cell_type": "markdown", "metadata": { @@ -622,7 +613,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.10.13" }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/tutorials/overlapped_speech_detection.ipynb b/tutorials/overlapped_speech_detection.ipynb index 1ad5d4090..9211f0626 100644 --- a/tutorials/overlapped_speech_detection.ipynb +++ b/tutorials/overlapped_speech_detection.ipynb @@ -1,13 +1,41 @@ { "cells": [ { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# TODO: switch to AMI\n", - "PROTOCOL = 'Debug.SpeakerDiarization.Debug'" + "\"Open" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Finetuning a segmentation model on an overlapped speech detection task with `pyannote.audio`\n", + "\n", + "Overlapped speech detection (OSD) is the task of detecting regions where at least two speakers are speaking at the same time. In this notebook, we will finetune a segmentation model on the OSD task, then evaluate an OSD pipeline on AMI database." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tutorial setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `Google Colab` setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you are running this tutorial on `Colab`, execute the following commands in order to setup `Colab` environment. These commands will install `pyannote.audio` and download a mini version of the `AMI` corpus." ] }, { @@ -16,17 +44,49 @@ "metadata": {}, "outputs": [], "source": [ - "# TODO: update this tutorial to do fine tuning of a model pretrained on DIHARD" + "!pip install -qq pyannote.audio==3.1.1\n", + "!pip install -qq ipython==7.34.0\n", + "!git clone https://github.com/pyannote/AMI-diarization-setup.git\n", + "%cd ./AMI-diarization-setup/pyannote/\n", + "!bash ./download_ami_mini.sh\n", + "%cd /content" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "# Overlapped speech detection with `pyannote.audio`\n", - "\n", - "Overlapped speech detection (OSD) is the task of detecting regions where at least two speakers are speaking at the same time. In this notebook, we will train and evaluate an OSD pipeline on Debug database." + "⚠ Restart the runtime (Runtime > Restart session)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Non `Google Colab` setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you are not using `Colab`, this tutorial assumes that\n", + "* `pyannote.audio` has been installed\n", + "* the [AMI corpus](https://groups.inf.ed.ac.uk/ami/corpus/) has already been [setup for use with `pyannote`](https://github.com/pyannote/AMI-diarization-setup/tree/main/pyannote)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Protocol" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Firstly, we define a protocol, here `AMI.SpeakerDiarization.mini`" ] }, { @@ -35,8 +95,10 @@ "metadata": {}, "outputs": [], "source": [ - "from pyannote.database import get_protocol, FileFinder\n", - "protocol = get_protocol(PROTOCOL, preprocessors={\"audio\": FileFinder()})" + "from pyannote.database import registry, FileFinder\n", + "\n", + "registry.load_database(\"AMI-diarization-setup/pyannote/database.yml\")\n", + "protocol = registry.get_protocol(\"AMI.SpeakerDiarization.mini\", preprocessors={\"audio\": FileFinder()})" ] }, { @@ -60,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -79,9 +141,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABiIAAADyCAYAAADAzN2uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABSgUlEQVR4nO3dd3xV9eH/8Xf2IJOEJIwkhD0ES8Vq3BO0VHFUCy4cdeLCftVaK7b6c7euWpy4EawtiAsQBVEUZMgeCRAyGEnIDmSSnN8f8V7vvbkz956E8Xo+Hjy843M+57M/n3M+5twgwzAMAQAAAAAAAAAAmCC4qxMAAAAAAAAAAACOXGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAAAAAAAMA0bEQAAAAAAAAAAwDRsRAAAAAAAAAAAANOwEQEAAAAAAAAAAEzDRgQAAAAAAAAAADANGxEAAAAAAAAAAMA0bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAAAAAAAMM0RvxFx7bXXKigoqN2/7du369prr9VFF13kMex5551nDdPQ0KDJkycrKSlJMTExuvTSS1VSUmJ3zpUrV+rss89WQkKCEhMTNXbsWK1bt84ujmuvvVYjRoxQaGioXRrgnKVubrnllnbfTZ48WUFBQbr22mutYR3LtKioSNdff7169eql8PBwZWZm6q677lJ5ebldOMMwNHXqVPXs2VNRUVE655xztG3bNrswjz32mE466SRFR0crISHBZZrffvttjRw5UpGRkUpJSdHkyZM7lPejwaFUv3379m03Bjz55JN2YdavX69TTz1VkZGRSk9P19NPP+1/IRzBDqX6zc3N1fjx45WcnKy4uDidcsopWrx4sfX7devWaeLEiUpPT1dUVJSGDh2qF154ITAFAQAAAAAAcJQK9TeC+uqGQKTDK1HxkR067rzzztNbb71l91mPHj28DhsREWF9PWXKFH3++ef66KOPFB8fr9tvv12XXHKJvv/+e0nS/v37dd555+nCCy/UtGnTdPDgQT388MMaO3asioqKFBYWppaWFkVFRenOO+/U//73vw7lKZAqDzR16vkSu4V36Lj09HTNmjVLzz33nKKioiS1bep88MEHysjIcHlcXl6esrOzNWjQIM2cOVNZWVnatGmT7r33Xs2bN0/Lly9X9+7dJUlPP/20XnzxRb3zzjvKysrSQw89pLFjx2rz5s2KjGxrf01NTbrsssuUnZ2t6dOnOz3ns88+q3/+85965plndMIJJ+jAgQPKz8/vUL4DocXhhq2ZQpKSOnTcoVK/kvTII4/oxhtvtL6PjY21vq6pqdGYMWN0zjnn6JVXXtGGDRt0/fXXKyEhQTfddFOH8u6P6sbqTj1ffER8h447VOr3d7/7nQYOHKhFixYpKipKzz//vH73u99px44dSktL0+rVq5WSkqL3339f6enp+uGHH3TTTTcpJCREt99+e4fyDgAAAAAAcLTzeyPi3Wv+G4h0eOXmuVd16LiIiAilpaX5Hba6ulrTp0/XBx98oLPOOkuS9NZbb2no0KFavny5TjzxRG3dulUVFRV65JFHlJ6eLkl6+OGHNXLkSBUUFGjAgAHq1q2bXn75ZUnS999/r6qqqg7lK1DOf3qx50ABtPzvYzt03K9//Wvt2LFDs2fP1pVXXilJmj17tjIyMpSVleXyuMmTJys8PFxffvml9QZoRkaGRo0apf79++vBBx/Uyy+/LMMw9Pzzz+uvf/2rxo8fL0l69913lZqaqo8//lgTJkyQJP3973+X1PYXD85UVlbqr3/9qz799FOdffbZ1s9HjhzZoXwHQvHIX3XauXrvLurQcYdK/UptGw+uxoEZM2aoqalJb775psLDwzV8+HCtXbtWzz77bJdsRFw974pOPd8nF33eoeMOhfotKyvTtm3bNH36dGt/fPLJJzVt2jRt3LhRaWlpuv766+3O369fPy1btkyzZ89mIwIAAAAAAKCDjvhHMwXS6tWr1dzcrHPOOcf62ZAhQ5SRkaFly5ZJkgYPHqykpCRNnz5dTU1Nqq+v1/Tp0zV06FD17du3i1J+5Lj++uvt/mLlzTff1HXXXecyfEVFhRYsWKDbbrvNehPTIi0tTVdeeaU+/PBDGYahnTt3qri42K5+4+PjdcIJJ1jr1xsLFy5Ua2urdu/eraFDh6pPnz66/PLLVVTUsRv0R5NDpX6ffPJJJSUladSoUXrmmWd08OBB63fLli3TaaedpvDwX/6yZ+zYscrJyVFlZWWH83406Or6TUpK0uDBg/Xuu+/qwIEDOnjwoF599VWlpKTouOOOc5mO6upq619dAAAAAAAAwHdHxUbEZ599ppiYGOu/yy67zOuwMTExevzxxyVJxcXFCg8Pb/e7AKmpqSouLpbU9n9Sf/PNN3r//fcVFRWlmJgYzZ8/X/PmzVNoqN9/gHLUu+qqq7R06VIVFBSooKBA33//va66yvVfymzbtk2GYWjo0KFOvx86dKgqKyu1b98+ax2mpqbahbGtX2/k5eWptbVVjz/+uJ5//nn997//VUVFhc4991w1NXXuY7AON4dC/d55552aNWuWFi9erJtvvlmPP/647rvvPuv3xcXFTuOwfAfXurp+g4KC9NVXX2nNmjWKjY1VZGSknn32Wc2fP1+JiYlOz/HDDz/oww8/7JK/dgEAAAAAADhSHBV3xs8880zro5AkqVu3bl6HleTT/wlbX1+vG264QSeffLJmzpyplpYW/eMf/9C4ceO0cuXKdv9XL3zTo0cPjRs3Tm+//bYMw9C4ceOUnJzs8TjDMDohdW1aW1vV3NysF198UWPGjJEkzZw5U2lpaVq8eLHGju3Yo6mOBodC/d5zzz3W1yNHjlR4eLhuvvlmPfHEE3a/FwPfdXX9GoahyZMnKyUlRd99952ioqL0xhtv6IILLtDKlSvVs2dPu/AbN27U+PHj9fDDD1v7MgAAAAAAAHzn90bENe/+PhDpMFW3bt00YMAAv8OmpaWpqalJVVVVdn8VUVJSYn2e/AcffKD8/HwtW7ZMwcHB1s8SExM1d+5cu+fQHyrm3XdmVyfBJ9dff731We3//ve/3YYdMGCAgoKCtGXLFl188cXtvt+yZYsSExPVo0cP7d+/X1JbfdrekCwpKdGvfvUrr9NnOXbYsGHWz3r06KHk5GQVFhZ6HU8gpa1f2yXn7YhDrX5POOEEHTx4UPn5+Ro8eLDS0tJUUlJiF8by3tvfogmk987/oNPP6Y+urN9Fixbps88+U2VlpeLi4iRJ06ZN08KFC/XOO+/oz3/+s/W4zZs36+yzz9ZNN92kv/71r37lGQAAAAAA4Gjn90ZEVHxkINJxWDjuuOMUFhamr7/+WpdeeqkkKScnR4WFhcrOzpYk1dXVKTg4WEFBQdbjLO9bW1u7JN2eJHYL9xzoEHLeeeepqalJQUFBHv+6ICkpSeeee66mTZumKVOm2P1FSnFxsWbMmKFrrrlGQUFBysrKUlpamr7++mvrjcuamhr9+OOPuvXWW71O38knnyyprW306dNHUtuz7svKypSZmeljbgMjJCmpS87bEYda/a5du1bBwcFKSUmRJGVnZ+vBBx9Uc3OzwsLCJLX9LsjgwYNdPt7HTPER8Z1+Tn90Zf3W1dVJknWT2CI4ONhufN60aZPOOussTZo0SY899lggsg0AAAAAAHBUOyp+I8IXjY2NKi4utvtXVlYmqe2HT2+44Qbdc889Wrx4sVavXq3rrrtO2dnZOvHEEyVJ5557riorKzV58mRt2bJFmzZt0nXXXafQ0FCdeeYvf3mwefNmrV27VhUVFaqurtbatWu1du3arsjyYSckJERbtmzR5s2bFRIS4jH8Sy+9pMbGRo0dO1bffvutioqKNH/+fJ177rnq3bu39UZjUFCQ7r77bv2///f/9Mknn2jDhg265ppr1KtXL1100UXW+AoLC7V27VoVFhaqpaXFWneW/yN70KBBGj9+vO666y798MMP2rhxoyZNmqQhQ4bYtQE415X1u2zZMj3//PNat26d8vLyNGPGDE2ZMkVXXXWVdZPhiiuuUHh4uG644QZt2rRJH374oV544QW7RzrBta6s3+zsbCUmJmrSpElat26dcnNzde+992rnzp0aN26cpLbHMZ155pkaM2aM7rnnHus8sG/fPtPKBAAAAAAA4Eh3VPxGhC/mz5/f7jnhgwcP1tatWyVJzz33nIKDg3XppZdab45NmzbNGnbIkCH69NNP9fe//13Z2dkKDg7WqFGj2sX729/+VgUFBdb3o0aNktS5v2VwOLM8VsUbAwcO1KpVq/Twww/r8ssvV0VFhdLS0nTRRRfp4YcftvsNkPvuu08HDhzQTTfdpKqqKp1yyimaP3++IiN/+cufqVOn6p133rG+t9Td4sWLdcYZZ0iS3n33XU2ZMkXjxo1TcHCwTj/9dM2fP9/6f9DDva6q34iICM2aNUt/+9vf1NjYqKysLE2ZMsVukyE+Pl5ffvmlJk+erOOOO07JycmaOnUqP2bsg66q3+TkZM2fP18PPvigzjrrLDU3N2v48OGaO3eujj32WEnSf//7X+3bt0/vv/++3n//fWvcmZmZys/PD0wBAAAAAAAAHGWCDO58AwAAAAAAAAAAk/BoJgAAAAAAAAAAYBo2IgAAAAAAAAAAgGnYiAAAAAAAAAAAAKZhIwIAAAAAAAAAAJiGjQgAAAAAAAAAAGAaNiIAAAAAAAAAAIBpQr0J1Nraqj179ig2NlZBQUFmpwkAAAAAAAAAABzCDMNQbW2tevXqpeBg93/z4NVGxJ49e5Senh6QxAEAAAAAAAAAgCNDUVGR+vTp4zaMVxsRsbGx1gjj4uL8TxkAAAAAAAAAADhs1dTUKD093bp/4I5XGxGWxzHFxcWxEQEAAAAAAAAAACTJq59z4MeqAQAAAAAAAACAadiIAAAAAAAAAAAApmEjAgAAAAAAAAAAmIaNCAAAAAAAAAAAYBo2IgAAAAAAAAAAgGnYiAAAAAAAAAAAAKZhIwIAAAAAAAAAAJiGjQgAAAAAAAAAAGAaNiIAAAAAAAAAAIBp2IgAAAAAAAAAAACmYSMCAAAAAAAAAACYho0IAAAAAAAAAABgGjYiAAAAAAAAAACAadiIAAAAAAAAAAAApmEjAgAAAAAAAAAAmIaNCAAAAAAAAAAAYBo2IgAAAAAAAAAAgGnYiAAAAAAAAAAAAKZhIwIAAAAAAAAAAJiGjQgAAAAAAAAAAGAaNiIAAAAAAAAAAIBp2IgAAAAAAAAAAACmYSMCAAAAAAAAAACYho0IAAAAAAAAAABgGjYiAAAAAAAAAACAadiIAAAAAAAAAAAApmEjAgAAAAAAAAAAmIaNCAAAAAAAAAAAYJpQXwLnPfFPrTjpYp0xup+WbC3VxaPTlRwboZaSEh14f4a6XXWlQlJT7Y5x952vbOOSFLB4bVU0VGj+znk6L+t8dY/s3u69o7LaRs1ZVaSLR6dLkvV1Yl2VXVoL3/1QC4ecpjNG99PyZVt07uovFBUeothbbram39O5bJUX5mjbP/6mvglZ6jH5LoWkpiqvKk+vb3hVN464WXEhvTVnVZHOSA7S7lffUq8rxuj7rf/RKWdM0srGXJ3YM1uLixap4WCDJCkyNFIXD7xEZZWhem7eVk05f4gG9YyTJDVt3KTqh/+m+L//TTWZAzRnVZFOH5Ki5cu26DfrP9YPaeU6dcyNWtmYq9/sT9b8L/+tiJNO0qXZN7UrQ0mav3OeftPjbC3esF+nD0mxtqWC6gI989Ui3XvOWTquz6B25ZscG+F3/R6oqNP6jzfLkHTsRcPUrXt0u/TN3PKB8mt26tZjJ6tfQr92cVjCn9gzW8v3LtPQ7sM0Y+t7yorrp4lDr2hXd5bwA6NP0+uLcjVo6FZFRRjWMvdU1+5UNFRozrbZkqQz08/S8r3LrOlybMOOn3c0Pn/ZnsMx/87aiqfz+npMR87REb6Uu6fjnKXTl/HCMX5X5e9PGEsavc2vu3w6i8PT+YY1jdDKt9brrFtOVmLfeJ/LxpKeod2H6b0Ns5XWfKEu+tVgLdi8TVHJG3XJ4Atc9m3LeOY4TjmOX2W1jXpz6ToVNH+job3j9Nv+Y9z2Vcf/Oqv/od2H6T+5s3TjiJuVEJmg+TvnaXDs8Xp9ySb1jk9Sz/SdTtPurhy+WPeFeq3rq5CDoQqLDLWOlZJUm5Ov3U9MU+8HblPs4L6S2ubm6mef08HNW1T58GS9Xf+1dR6a8f1OSdKVJ2dZy8a2XKoaK/TSivc1IDVWVwy/XFUNVXp9w6u6fNAEbanY7LQOLXk/PeFMFc7bI0NSxvk99W3VN+3Ce9NPnLXFmO17VfDkw1p8w2g1J8RIkssx29OY4mzeOVBRpy0Ltmno2IHWsrX9rCS42Dqfp7am2YV1d2zmCX1U8OMuu+9y99ZY5/XeEaHa+N5SxS6dqx4DkqTbrtTC/avatTHb9YSzedAVyzotcuxY7Z73tRYkDVX/lYv1q/+7VT36p7sM27BggXU957hudLaOdLW2tNZl6CDlvfoPbR4YqeARwxUV2906bnyx7gulL41X8polynjodms73leUo88W/ku/O/cOhfToofk752l0ZabmvfedLrt+nHodP1Lby/batdf46maX61Jn9WTh7jt/lK7YqqIHn1GvEalKuf8ua9m4Op+rtvTD3B+1PPJ79RiQpMtH/MFp33HWrh3jzTyhjzb+uFk5AzYqLDLM2n+crbUt4063+jr1r12jxBuvbVemFrbr0vBjhqulpES1r7wqSYq95WY1hMVa8yVJ6z/eLOVvU8Tyd7Tu/87W+NNucJoOSzytdXUKjo5W7C03q66qUetfmqeRt5+v4B7JbuttX165lr2xWr+6bLh2r9nbrmxcjUe2+W9SuPL6xOryU/s5XfeW1TZq9pIdGlLWoKGnZargx11KOyNZC8rmqa4+WFWlA1RmrNHvU07RT7Ny1HjSQF1/3ki3c5OFZay44exU5dYtbTfnfPb9F+q2MFGn3XSievRLctIC7Xla/89bt0f1TQcVFR5qnSOczZuWeeT8Y3tpydZSnTmim1bsW2SN19N6xVl6fFmP+bP2su1jkqx9Juk3vTVr0Q5dd/ExykhPsDtm344ibXruVQ2fcrO6x4Rr18uztHZ/f510W7Zqu1c7HZtt+6PtfGiU7tPWaU9oyG0PKCljsN15anMKtf6leRp4zVkq3F6noWMHqjG6wVqe5yX/Vnu/2WeX9qaGgyoNkhaGGPq/C4YrOfGgy/nP2XV7/cWXa1bufklt9Tlv3R5J0rjR8dY6tfRNb+vVGW+PdxVue1mxXly0THeelS3J0Csr/6tbjv+9BiT39CkdgUhneWGOtk57QoMvv0nhi5er21VXqjo+rMPXAJ6ugbaXFev5j7/XwPwoDYjtpqbyOp38+yxFfveF3Vhcm1Oo1S/MV+PwPirOLtWp/U7r8HWj7TrMcn+io9fJ/l5L2rbd1uyztPb9FdY8XjDsQrt4dmzdqUWvfK+zbjlZ/YdkWeeAoZP6a2Xrcp0YOkh7p//baf/zxLb/tOwrU9UDf1Fo374KTk5S028navmcnRpy3gBtn71Kvwpeo+j4KLv7SrZjQp9RPbX2o03K/uNxqqhYrddXvaibu1+k+Pc+tcYZe8vNqjgQqi9f+49iSj/Sr+KGKD4xzS5Ob9NraZ+2baGqoUozvn1el38Xpdy6Htr8myZdOWaS+vTsba0Db/vs/J3zNLbbaIV99HnA7gU6W5NKcrpOdWQZS0fefr6k1nbXSY7lE5Ka6tVcYjsODUhO8yt/RYVV+uL9NfrtVaOUnpHgMbwv61Rf72G6mpNcKcnbpY9mLtZlE89Uar8+7b5fsb1Mj3+ySX+5cLh+MyDZ6f3Z8dG1Cnr6ceu60aJp4yYVPPmwlt94ssadMKnd2uy7hdN1/Jvfq/bB2/Rq1XeKP/A7JUTE64qB3bT/tRlaU5SkU6acodARSU7HHdvX/o6HZ6afpcVFiyS13afb8N3/NGjmUq26+Yx2aXcV56ml6cp99mtFnHySRv3xVKfrU8m7dZWlfGzTUNNQ41UeJR//IqL4k/l6c1WJ8kr3a/o3O1RW2yhJaiktVe2zz6mltLTdMe6+85VtXIGM11ZlQ4Vm5XygyoYKp+8dldU2WsvC9rVjWne996G17OZ9vU6tb7+pA6+9bpd+T+eyVb1rh9L/t1Qt09+zxlFYW6BN5RtVWFtgTcvu3AINnPOO9mxbrzndd6qgeItm5XygwtoCzd0xRwsK5mlBwTzN3TFHlQ0VyivdrzUFlcor3W89V3NurpqWL1dzbq41Xks+Kuf/Tx+n7bbGu2fbGn05vEWfVn/ntAwtr/PLy63xWMps674i5e/M0tZ9RU7LNxDqKuu1fu5WbZi7VXWV9U7Tt6BgnnIqt6qwtsBpHJbwhbUFmpXzgXKrcpRbmaMFBfOc1p0l/JY9ZdpcskffFn9hV+b+qGyo0NwdczR3xxxreiz/dSx/x887Gp+/bM/hGKeztuLpvL4e05FzdIQv5e7pOGfp7Gja3ZW/P2F8za+7fDqLw9P5CnYUqnWntDevpENlYzkmtypHW0qLNHt523j44crN+mTnf9z2bct45jhOOY5fZbWN+mRdjopal+jLok899lV3fdA2vZZx3/LZ1n1FWpsbrQUbC1ym3V05zN8wX9s+z9fWBdvtxkpJqtuxS7ELZ6puxy7rZy2lpap/f4aaf/pJ+YXr7OahmcsKNHNZgV3Z2JZLfmWp8pq+0ZdFn6qyocI6j+VW5bisQ0s+S0v2Wcfz4vJip+F9GRNsy7k5N1dl29frs+rv2s2Tro531VedzTt1lfVaPWuDfdnafGY7nzuGdXdsZVF1u+9s5/W6ynrlfbpG8T98oqZ331J5yU6nbcz2/L6wrH2ac3O1670PtWT1Tg375D1VFux2G9Z2Pee4vnO23nO1BrSUf0n+RnVbukZfpZbpy9IlduPG/A3ztWfeZiUs/tCuHZeX7NSc7jtVXrLTGs+uzbmamfJrleTkSVK79upuXeqsnhzry9l3/qjZnK+0zV+q9cP37MrG1flctaU1323Qyqhl+mL3Zy77jrN27RhvZVG1Vi5coy92f2bXf5yttS3jTt6na9T48ktu1/q261KprT0ceO1167raNl+WdJZ9vUqNNXmaU/eNy3RY4ql/f4Y1rtr8vdpY2E21+Xs91ltlUbX2birVvm3lTsvG1Xhkm//Vi/L07o+FLte9ZbWNmrskT1vmbLb29+LyYs3dMUdfbP9WCzYWaGfLl8rLLdT+vcGavbHC49xkYRkrtpTscTrnfL/mB5VtqVRlUbXTtLUrDw/r/5nLCvTx6t12c4SzedMyj1iuGfIrS+3i9bRe8VT+voT3NQ5nbXHD3K0qyK/UvPID2r23/UV7ZcFuDZzzjioLdqultFQl/1uo4m1Vqiyqdjk228ZtOx9W79qhvu99repdO9qdx9K2y3L2WNNoW56lJfvapX3rgu1asbxI63fXKK90v9v5z9n4WLqrxK4+La9t69RSzt7WqzPeHu8qXH55uVZsilZ+ebnyK0uV2zhf+ZWBvefgbTotdVi7eb21PP25BvB0DZRfXq6dORGK3FChXT8UqTSnXDWb89uNxbX5e5WzO1rrVm/X/wo/8uu60XYdZrk/4U/d+3MtKf3Sdms2bbfLo2M8e/NKrNce0i9zQNGuXda1iKv+54lt/2nOzVXzTz+pfvZsHXjtdZXl7NHeTaUq3lyq6o07ZXz4frv7SrZjwr5t5dq7qVSVRdXKL1yn3DRD5WuW2cXZUtr2fXnxVo1esE2hH33aLk5v0+tsXV1YW6Di/A1q+fgbbakP1/fx36u4vNiuDrzts7NyPlD1rh0BvRfobE3qap3qyG6d4OQ6ybF8bPPhLq+245C/ivfUSD/ubvuvF3xZp/oyHrmbk1wp3VWi95tSVLqrxOn3G3dVq7i6QRt3ta1NnN2frdm0xW7daGG53vuo8iuna7N1y2bLWLFa+YXrtKW0SPN+qtLMZQWqLNitfV8s1b4DUSrL2eNy3PHnnoTjeGh5b3m9btlsVeVtcZp2V3FWrN+q7RqoTd/vc7k+9aUvOqahqqHS63zyaCYAAAAAAAAAAGAaNiIAAAAAAAAAAIBpfPqNCIu6xoNOP2+tqlaLw58OtVZ59+e7vjAjTkf7m/arurFa+5v2ew4sqba+2ennjml1VXbOzu1OXXOdvPnFhIamlp8PqJPipfrWBi+O8swxH97E66wsnZVHXaNUeaBJkutyNYO3dW1R31znNA7HunMXrzd17Y5t3I7pcdWG3Z3Tm/j8ZXsOxzidlZWn8/p6TEfO0RG+lLun4zyF9yXt7srfnzC+psubfNrG4el8zQebfE6Dp/Pbjk/e9O3a+mbr2GV57+25nfVVd33QXbtoPNgg2+nd33Jo3N+k+uq2Mb65vllBkrT/l/m+o3NybX2zxznR3zHVl3Hd2ZjuC1/nEMm+bBv3t2/DzsK6C9dc17E509+8OzL225dFUI3n9aFlDemqPdmuMT21ucaDDe3WSE7rx7Yd17Z9v7+lTmGO41NL27rE3frXZVps6tj2s67gmBaz0+GpPbpbawdire8qf96u8VurqmX8/IigpvoWtQaovLwZpxznE9vPLdyVb3Or/Vzkz9zkKo3e8nb9b8uSZtu0Oh7j6zqro3kIRDk4tsWDDQd/ju9gu3quaziobmobN1vDPF83urK/ab9CLNeL1bXtxmDj5zHvYEOrT2l3dS5XfOnLzvpmR9bo3h7vKlz9wbY58UBDi4JCDv782QFTrxVcpdN6zb//gNPjO3oN4CoOS96dsZ2HLe3Hepwf142u2o+/de9tPC7bb1291LbqdRpP40H39z+s3zvpf550xv0ubzi7v+cqnCNPa8sDNn2qI33Wl/R54mxN6iyMs3NZ+kJTfYtCW9pfJ7mKT3KfV9txyNl6wBeW+bP5QHO7NakzHVkf+nQP04c+YSnf/U2tTsuhodn5POnrfUR/riE9HROI8dC2P/k63nqbl47eN7S8P9Dcfp5ypUMbEU9/vsXp5+UTJnYkOp91xnke+uFBn8Lf8e4qp59b05qUIamt7LICcO70wjr9xYt0vbN0p/4hKeKdN6Q/D9TrZXO9OMozx3x4E6+zfDlrS9PnHdT0eYv9SV6H+FrnL6+f5nccvoZ3xzE9ruL29pzexucPb+LsyHm7sh4CfQ5Px/mT9kCVv7MwgagDX9rwwsKv9Gud5FcaHD39+RaFRnkfl6t5wBNXcXe0D3607SNJv8yTvpZDnBLt3n8+9etfvjuwW6dJOjjlFhXLP3e8u0qhUaXqPsR1mM7sy87GdLPPbVu2gQi79JWVPqdB8j/vjqof+It13SNJ0ZP/6LG9eFrb+bL2+2jbf3SVw2eW+rFt37btuDo9SvrzQD2yd7q01/7Ye/OipKcXu2yv7tLmSx2brbPTsvSVlZKb3zS27TOO404g1vqu8uttXy2fMFHV0b2kYXdowVt5kvL8TpOr8zvm3918YilSd/195b4lytBpHuNyxzGdPZUZkHgk19eSFs7S7HiMY7xmreUCEa9jW1zz383S4EQ9tHCbtHCb3XdZZQX6h9rGzXJJ6n5sh8750A8PWq8XI/74f+3GYEvbXvZp+9/wcZd2V+dyxZe+HIj1ZEePtw3XXNdD0kQ9MXuvddx/PecxvZ7jV1K8Pr8tSx2GP/q818f4c97muh4K1u+dhrWtS0v7sTDjujFQfbqj8ex/6SW7PLYbE7dntrv2sPXRtv+47H+HC3/mYk9ry3/mPyXlt//cl/oy676gs3hdnct2neDrdZK7vNqOQ084Lkx9lFTXrAslbXhxmTb4FZNrvtzD9KVPVCdlSBdP1ZTvKqTvvL9H6Ovax1n6R/sUg//339yx7U8vr59mlzazxkpP8TqmwZf/IY5HMwEAAAAAAAAAANOwEQEAAAAAAAAAAEzDRgQAAAAAAAAAADBNh34j4r5xQ50+2zNp1kyFDRtq91nz5i0Bf3Zb0qyZksz9rYhHT3pMfeOzlF+906tnbv3rmrYnZDk+i8yS1rzJ90tqK7uP3inw6tzuFC1fKGmKx3RNOiVL+lhqnPRHSUt0Y/L4gPxOhGM+vIn30ZMek2T/rDFnbemG80P1+xGnSpK2F9d2+Nm2vnKWPnduHXlbu2cfOqs7d23Im7p2xzZux/S4asPuzulNfP6yPYdjnM7KytN5fT2mI+foCF/K3dNxkut26Wva3ZW/P2Ec0+hrvXmKw9P5zs04R+Wy/+EmX8rGWbu4b9xQPbuo1GVcjsf865rRGpAWa33v7fjlqq+664PuxpXLBl6m12yeY+xrOTzzyT/sPhv3yNlK6tv2/PLyr5ZJd0qhz72i5LNPlNTxef5f14zW3vp8vbHddRh/x1Rv53DJ+ZjuC1/nEMmhbPMr3T6L2xLWXbhTbjm+Q78T4W/eHcU/8bj0j1es7+v+/Yb6nWr/pFXHdmNZQ7pqT7ZrTE9t7rKBl0t6zu4zS/3Ytm/bdly9frFU/Zam9rxBYVn97OrxmX71Oub3v9V3Ozc4ba/u1qW2dWzhqa7N4pgWs9Nxyi3H6/OPFrj83nbscxx3ArHWH/fI2ZLaP+Pe2zV+0qyZUkmj9N5ejb2un0KzsgJSXs7GKcf8O84nFtuLa/W3V5ZJct/fj+9xukpkOI3L17nJksZp21/zeIyreCTP639bljTbptXxGMd4O7Je9Db93sy97ji2xVG/H6ZPN+zVo+cO1OhRfezCFixZIX3cNm6mJ3XT7tue9Pl8lnSHJG6XNEWNb/xDmb85xz7A4rXSe3uVfUFvt78T4aofOZ5Lcj7/+dKXnfXNjqzRvT3eVbhvt+fqsZwKPXBJTwWFJOuN7dKNgx/Uaf2G+5SOQKTTcs3f9NDd7X4nwp9rAFdxfLs9V6+sKXF6vN29np/bj4U/142u+pW/de9tPK7OH3P77dIi1/GsWrBG27/b5TLetrXI4877nwdm3EPrCGf395xxll5Pa8s/9b1fvxra9hs4HemzvqTPE2drUklO16nt/NwXxl7XT6EtvdtdJzmL38JdXm3HodMGuPlBPS+sX7VLW5/9QSPuzNao0b09hu/I+tCXe5i+9Iny5RulFQ167tTuGpLd/jeTZv6wU+8uzW/3uav7s644W5vNXXGrV8faxiG1nwsDMR7a9qdbR96mlSv+n9fxe7t28WVd5Vg+j570mPbX7td8LfR4HqmDGxHREc4PC06IV0iS/a/StSTEd+QUbgWbEKejmPAYxUfEKyY8xqvwsVFhTj93TKursnN2bnfKw6K9SldkeMjPJ24LHxUc6dVxnjjmw5t4nZWls/KIjpASu4VLcl2uZvC2ri2inNSBs7pzF683de2ObdyO6XHVht2d05v4/GV7Dsc4nZWVp/P6ekxHztERvpS7p+M8hfcl7e7K358wvqbLm3zaxuHpfGGh4ZLDRoQvZeNpfPKmb8dGhVnHLst7b8/trK+664Pu2kVEaKSkg27T7i4t7eKLCVdUfNsYHxYV1hZzzC/zfUfn+dioMFW3up8T/R1TfRnXnY3pvvB1DpHsyzYiJtyrsO7ChUV3bM70N++OgmLsy8KI87w+tKwhXbUn2zWmpzbX1gfsOa0fm3YcHBsjVUsxIdEKcxyfQtrWJe7Wvy7TYlPHtp91Bce0mJ0OT+3R3Vo7EGt9V/nzdo0fnBCvoLq2eSU8KkRhASovb8Ypx/nE9nMLd+UbFhwuqdFpXL7OTa7S6C1v1/+2LGm2TavjMb6uszqah0CUg2NbDI0M/Tm+0Hb1vO/n74y4eAUndOvQ+drijlGQZWyPj203BgfFxvycFvcPSPBmnHBXLr70ZWd9syNrdG+PdxUuKjRaUoW6RYZIwcbPn3Uz9VrBVTqt1/wx7duCP9cAruJoy7tztvOwpf1Yj/PjutFV+/G37r2Nx2X7jY6S1OAyHmdrDVvW7530P0/MuIfWEc7u7znjLL2e1pbdbPpUR/qsL+nzxNma1JGrc1n6QnhUiEJa2l8nOYvfwl1ebcchZ+sBX1jmz7BuYe3WpM50ZH3o0z1MH/pEW/k2KCY82Gk5RIY5X0/4eh/Rn2tIT8cEYjy07U++jrfe5qWj9w0t740ww6vzSDyaCQAAAAAAAAAAmIiNCAAAAAAAAAAAYBo2IgAAAAAAAAAAgGnYiAAAAAAAAAAAAKbx6ceq0y48T9ePTlW/lBjdcEZ/JcdGSJJCUlIUe88UhaSktDvG3Xe+cowrUPHaSozsrgmDr1BiZHen7x0lx0bYlYXldUiIfVr7XP0HXT+krezOP/tYBSdcr6jwELv0ezqXrfg+/bXt0lPUNyHLGkdGbKaGJx2jjNhMxYW0pat3cpC2XTxJvQaO1MVbtypz5FBNSLxCGbGZGt//YjUcbPsBpsjQSCVGdle/lFCNykxUv5RffnwkbNAghZ94osIGDbLm15KPxB6X6qLicmu8vfYna8yXPyjipJNcluGEwVeob1KSbjgjwq4tDWlNV9+sRRrS4yyX5euv6MQojRw/RMbPr52lb2zm+cqv2amM2EyncVjCZ8RmasLgKzQoYbAGJQ5WVlw/p3VnCT8wOlnDUntpUNpvFRVhWMvcH4mR3TW+/8WSZE2P5b+O5e/4eUfj85ftORzjdNZWPJ3X12M6co6O8KXcvTnOMQ5fxgvH+F2Vv79hfMmvu3w6i8PT+TKbMlSaVaWe/VKVGBnvc9lY0jMoYbCGpmxSWmJ39UuJ0R+OH6ao5Mvd9m3LeOY4TjmOX8mxEbrw2MEqaD5dQ3vHeeyr7vqgbXot435CZIImDL5Cg2PT9atBm9Q7PlM9052n3V05nDfiPPVq7auQg6EKiwy1jpWSFN2/j3afO1G9+/exfhaSkqKoq67Uwc1b1DfjWA2vL7POQxOzM615d1YuoeEp6hd+hgakxioxsruCFKzhScdoUMJgl3VoyXtKQg/reJ6WlKYJIe3De9NPnLXFsEGDlDxgpH4XP1rNCW3zoasx29OY4mzeiU6M0nETRtiXrc1nGcG/zOfRrfZh3R2bmB7f7rt+KTHWeT06IlT9Lhil6sQL1WNAkpJSszShW/s2Zrue8IVlnRY2aJD6XP0HnZ6Upc2tV+tXmb3dhrVdLzmu9ZytI12tLS11kRo6SHmnjNI5JZEKHjFcUbHdrXk7b8R56lUdr6q0PyjDph0npWbp4vVZSjouSyE/x9MnJVMTV3+n1N+NkyT1TbRvryEpzS7Xpc7qybG+nH3nj7hhfVU0bIx6jUi1KxtX53PVlkadOkKN9TXqMSDJZd9x1q4d401Mj9fx545SXO8whUWGuVwX2o473epTFHHG7W7X+rbrUqmtPXS76Ubr6+gw+3yNHD9Eyg9RxPJNujj6DJfpsMTTWlen4OjotnYW3qhjMtYqtm9PBXuot8T0ePUcnqIeA5Oclo2r8cg2/5kKV2KfWJfr3uTYCI0/vZ+GDG+w9ve0pGSNNy5WXX2wquIyVWaMUb9BGar6KUeXHNPd49xkYRkrhqamakJs+znn5FEnqVtZohLTvfvBRU/r/4nZmapvOqio8FC7edJx3rTMI5Zrhr6J3ezi9bRecZUeX9PfkTgc+5ilXST1TdT5eRXq3TOu/Xkze2vTxZM0PLO3QmLClXrpuUrbn6DE9HiFuhibbfuj7Xxo9OmvrVefrSF9+rc7T2zfnjomY62SB/fScRMSFJ0YpZDIIGt5piT3aJf2poaD6h4kVYcY6pcSo8TISJfzn7Pr9tA+qZqY3fajy5Y2IEl9E+PbjQne1qsz3h7vKlzfpCT9Zniu+iYlSTI0KOI89U0M7D0Hb9MZ/3MdDh42UuE/l2diZFiHrwE8XQP1TUpS1uCtaojorgGx3dRUXqe4YX0V6TAWx/btqcG916lx+AClZsT5dd1ouw6z3J/o6HVyIK4lLW23dfgADV6zwppHx3h69kvVlqzt6tkvtS2en+eA9D59NKG1bS2S76L/eWLXf4KCFfbrXyu0b18FJycpbHAv9RzeqLRhKdp/TJaCRl6l6PiodvO+ZUzoMTBJPYenKDE9Xka3YzVo1RIljcpW2MYya5whKSlK7BaqpLQhWjV2oH4VN0TxiWle32uzTa+lfdq2hSAFK63vCIVcFKWhdU0yqk9WWlKaXR1422cnDL5C8d36KyyA9wJdrUmdfebIMpbG9u0pqbXddZJt/JY4vJlL7Mch/6T1ipNO6N32Xy/4sk719R6mqznJlZQ+qboqfLNS+gx3+v0xfeKVFh+pY/q0rU2c3Z+Ni05RkM260cJyvXdZ4slO12bHZl+ioC3fq2/GsRpaVaP4bglKiIhXYmY3hf32FPUoqlfy4F4KdTPuBGo8tLyX2q7Tjs2+RAn5S3VZ4hlej3HdE9M14KuvFXHySW7Xp972Rcc0hDR5v70QZBiGx5+2rqmpUXx8vKqrqxUX513jBQAAAAAAAAAARyZf9g14NBMAAAAAAAAAADANGxEAAAAAAAAAAMA0bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAAAAAAAMA0bEQAAAAAAAAAAwDRsRAAAAAAAAAAAANOwEQEAAAAAAAAAAEzDRgQAAAAAAAAAADANGxEAAAAAAAAAAMA0bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAAAAAAAMA0bEW60lJSo5p/PqqWkxO51RzRt3KR9l16mpo2bAnJMWW2jXpi/VS/M36qy2kaPcfka3htltY16ffF25e6t0euLt6ustlFltY16ddb3WnjrX1T64xq/yqyioUIfbJmhioYKt58Fwr68cn3yly+1L69cByrqtGrmOu3LK9eqmet0oKIuYOextKOmjZv8KpvD0b68cn1x93+0554HVPX3R46qvMNcLSUlqvr7I4dUu+rM8SuQ3I3htvNIUWGVlr25SkumLdcPb67SgYo669gZyDHTdmx2ZCnPvKo8l+XqmCZXaTxQUadlb66y5sVXzuINVHl0Rvs2c97rTO7q96dXF2vfA1OV/9hfNWPVq8qrytP7P76vRa8t1Q9vrmqXd9u4/G0fhwpvxiBLmPLCnC5br1Q0VGj6hjc0fcMbXo+XeVV5euC7+5VXlWf/ftvKdv2nI2tyBJY3dezLuOrsmiTQLOewXO/4eh5n12IVDRV6/5vntPSOy1Q89S8qXblNbz06Q//35T1avSvXpzy5u9ZzHMNchXWWL9vPcvfW6NY3Vyh3b43LsrH97F9fr9Yb695xWcdmrotczZ2u8uAorypPU//7sD68b67TNUhn8ma944mnurVwvOfRUlKiguef0Bs/vmDtrx1tJ4cid+tMT8eUrtjqdH60lGHpym129xcsfbBwzW5rP7fMWbZ86RcVDRV6/acP9OLCDaaMe87Y1nVeVZ7+b8k9enblPzzO2ZZx5+3XPtOeiy71aQ52XJN5Wqv6so5YvStXE95+Rat35bbLnyNL296wtdRuTHW3rnDWfwMxZx2oqNPCtxbr8WlP6ZU73tbarzfok798qcI1u9utWX1t576sFy1hnJ3Dn/WzJb7CNbvtrlFqc/LdrkstY9aMVa/6lH53PN3DC+S6MlDjp7P6sM2zr/OvY3yW9z+uLOxQetmIcKOltFS1zz6nltJSu9cd0Zybq6bly9WcmxuQY8pqGzVzWYFmLivweiPCl/DeKKtt1PRvdiivdL+mf7PDujD/5rtNGvbJe6rZtMWvMqtsqNCsnA9UadM5nH0WCJVF1dq7qVSVRdWqq6zX6lkbVFlUrdWzNqiusj5g57G0o+bcXL/K5nBUWVSt6o07ZXz4vg689vpRlXeYq6W0VAdee/2QaledOX4Fkrsx3HYeKd5To/Vzt2rrgu3aMHer6irrrWNnIMdM27G53Xc/l2dhbYHLcnVMk6s01lXWa/3crda8+MpZvIEqj85o32bOe53JXf3mfLRCTe++pb2f/kcf7vpEhbUFmr9hvrZ9nq8Nc7e2y7ttXP62j0OFN2OQJUz1rh1dtl6pbKjQ3B1zNHfHHK/Hy8LaAm0q36jC2gK79yX5G9v1n46syRFY3tSxL+Oqs2uSQLOcw3K94+t5nF2LVTZUaNn6T5Q1e7lapr+nspw92lmxU7l1Odq6r8inPLm71nMcw1yFdZYv28/ySvdrTUGl8kr3uywb288+XLlZn+z8j8s6NnNd5GrudJUHR4W1BSrJ36eqnFqna5DO5M16xxNPdWvheM+jpbRUe2a9pU/2fmntrx1tJ4cid+tMT8fUbM53Oj9ayrAsZ4/d/QVLH9y3rdzazy1zll38PvSLyoYKzd76pT5YuqdTNyIsdV1YW6Dcyhx9s3uxxznbMu5sXLJaxsoVPs3BjmsyT2tVX9YRW/cVKX9nlrbuK2qXP0fWtr2z0m5MdbeucNZ/AzFn1VXWa813G1RQV6CgwlDt2rBXezeVat+28nZrVl/buS/rRUsYZ+fwZ/1siW/ftnL7a5Qdu9yuSy1j1oe7PvEp/e54uocXyHVloMZPZ/Vhm2df51/H+Czvt+RVdCi9bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwTWhXJ+Bw0FrVtc+FPNTVNR50/sX+wDwXcn/TflU3Vltfd5bmumbT4jYCVDYADm1dNX4FhA/jVOP+JhMT4l59s+cfP2vc36T66gbT02k5j+X14cbMea8z2daD5b0jV+2ms9pKV7Idl5x9Z4v1CrqaL+Oqy2uSAKqt79xxsjPy5Ki2vlmVB5qsr/09ztWYc9iti7qYN+sdT7yt29aqarWUl7u9D9LRdnKksZSV7ftAcDdX24axsK0PM3VlXZu5NqtrlCoPNJmWP2f9tyvGd1/4sl40m+M1imO/s/3cItDpP1LWxIfC3MtGhBfKJ0zs6iQc0p7+fIvTz6OeejQg8T/0w4MBicdXS19ZaVrc1Q/8xbS4ARw6umr8CgRfxvDPp35tYkrce3n9NI9hOit9XVkOgWDmvNeZnNVDnMP7l9dPU5wSvTr2SOPLuMR6BV3Nlz7p6pokkO54d5Xp57DVGXly1NE8Oh4XGtX238N5LXQo8Wa944m3dWt3/yM9yq+4jnRm3Svyvt/0kHR01IeZa7Tp8w5q+rzFpsXvrP92xfjui0Np7Ha8RnHb734eswKd/iNlTXwo1CuPZgIAAAAAAAAAAKZhIwIAAAAAAAAAAJiGjQgAAAAAAAAAAGAafiPCC0mzZkrityJcuW/cUKfPt6u//6GA/E7Eoyc9pr7xWZKk/OqdnfZMs1NuOd6052XHP/H4EfOMOQCuddX4FQi+jOHjHjlbUtc8X//Wkbd5fG7yuEfOVlLfRJXnV5qaRst5JJl+LjOYOe91Jtt6kNrq4rs/vWsX5taRt2nGopkujz0c689btuOSI8dxivUKupov46qra5JA+tc1oyV13vPYOyNPjv51zWgNSIuVJG0vrvU6r47HTfnoC0mux5zDbV3U1bxZ73jibd0mzZqpsGFD1bx5iwrvvd6vuI50lrKyaN68JSD3jdzN1Rb51Tv156+el2RfH2bqyro283rjhvND9fsRp5qWP2f9tyvGd1/4sl40m+M1imO/s7AdswKd/iNlTfzoSY9J6trfimAjwgvBCfFdnYRDWnSEi2YUExOQ+GPCYxQfEW993VnCosNMizsoQGUD4NDWVeNXQPgwTkXEhJuYEPeiwqI9homICVdUfKTp6bScx/L6cGPmvNeZbOvB8t6Rq3bTWW2lK9mOS86+s8V6BV3Nl3HV5TVJAMVGde442Rl5chQbFabEbuHW1/4e52rMOezWRV3Mm/WOJ97WbXBCvEKSktTi5j5IR9vJkcZSVhbuyswX7uZq2zAWtvVhpq6sazPXZtERUmK3cNPy56z/dsX47gtf1otmc7xGcex3Frb9L9DpP1LWxIfC3MujmQAAAAAAAAAAgGnYiAAAAAAAAAAAAKZhIwIAAAAAAAAAAJjm0H4oWRcLSUlR7D1TFJKSIkl2r30VNmiQwk88UWGDBgXkmOTYCE3MzrS+9sTX8N5Ijo3QDWf0V7+UGN1wRn9rvGecOlybW6/WscOHKtKPMkuM7K4Jg69QYmR3t58FQmJ6vHoOT1FieryiE6J03IQRSkyP13ETRig6MSpg57G0qbBBg/xqT4ejxPR4xR+TpaCRVyk6PuqoyjvMFZKSom433Wh9fSjozPErkJJjI1yO4bbzSFqvOI0cP0RNDQcVFhlqHScDPWbajs3tvvu5PDNiM12Wa3RilF2aHN/bhhs5foiMn1/7ylm8rs7lq85o35a0mjHvdSZ39Tv4st8oPP869Yxp1R/6pCsjNlPnjThPvVr7KjI0sl3eHePyp30cKrwZgyxh4rv1V1gXrVcSI7trfP+Lra+9kRGbqeFJxygjNtPufWraMe36T0fW5Agsb+rYl3HV1TVJIFnOYYnb1/M4uxZLjOyu7JEXauclP2hA4kAlD+6lrJ1Zqouu0JAe6brhjGCv8+TuWs9xjgsKC3Ea1jGPjp8FB0mjMhPVL8X++dKujvvD8cMUlXy5yzo2c13kau7slxLjNA+OMmIzldq3hxJKY52uQTqTN+sdTzzVrYXj/Y+QlBT1mnCdLuwZraDobkqM7K7WkI61k0ORu3Wmp2PihmU4vddhvd4f3Es9hzda7y9Y+mCPgUnKymnr55Y5yy5+H/pFYmR3XTJkjOp79DJl3HPGtq7DWzI1KHGwekX3Unxkgts0W8ao+N7NCjqw3qc52HHs97RW9WUdMaRHuvpmLdKQHme1y58j6/iRlagUmzHV3brCWf+19CF/5qzoxCiNOnWEDtbXy8g4qD4jeqq1tK19Oa5ZfW3nvqwXLWGcncOf6ytLfD0GJtlfo/SPl+FmXWoZs/7Qp7tP6XfH0z28QK4rvZ2jPHFWH4559mU+cYzP8j61X3eNOtDkc3qDDMMwPAWqqalRfHy8qqurFRcX59MJAAAAAAAAAADAkcWXfQMezQQAAAAAAAAAAEzDRgQAAAAAAAAAADANGxEAAAAAAAAAAMA0bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAAAAAAAMA0bEQAAAAAAAAAAwDRsRAAAAAAAAAAAANOwEQEAAAAAAAAAAEzDRgQAAAAAAAAAADANGxEAAAAAAAAAAMA0bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAAAAAAAMA0bEQAAwKqioUIfbJmhioYKu9eu5FXl6YHv7ldeVV7A01JW26gX5m/VC/O3qqy2MeDx48hEuwGOPoVrdmvGH2cr99s8rZq5Tgcq6ro6SXCwL69cn/zlS+3LK+/qpMANy9ovryrP4xoQ5ghEX2nauEn7Lr1MTRs3BSw923J22LWN7WXFen3xdpdrrbLaRuv3FQ0Vmr7hDf1rxZt66vO1HVqjtZSUqOrvj6jq74+opaTE73xJ9mXdmWOUGXmBuRyvi725ToZzbEQAAACryoYKzcr5QJUNFXavXSmsLdCm8o0qrC0IeFrKahs1c1mBZi4r4IYyvEa7AY4++7aVa/++OhVvLtXqWRtUV1nf1UmCg8qiau3dVKrKouquTgrcsKz9CmsLPK4BYY5A9JXm3Fw1LV+u5tzcgKWnaNcuu7aRX16u6d/scLsRYfm+sqFCc3fM0Rfbv9WcFSUdWqO1lJbqwGuv68Brr6ultNTvfEn2Zd2ZY5QZeYG5HK+LvblOhnNsRAAAAAAAAAAAANOwEQEAAAAAAAAAAEwT2tUJAAAAh579Tfu7OgkAAPjkYGNLVycBOCLUN/M7K3DOsW3U1jer8kBTu3C19c2dlSSg0+xv2q/qxmqulf3ARgQAAGjnoR8e7OokAADgk22LdnZ1EoAjwsvrp3V1EnCIcmwbd7y7qotSAnQ+rpH9x6OZAAAAAAAAAACAadiIAAAAAAAAAAAApmEjAgAAAAAAAAAAmIbfiAAAAO08etJjkngOJgDg8DHwrCx+JwIIgFtH3sbvRMApx7bxr2tGa0BabLtw24tr+f0IHHEePekx9Y3PUn71Tq6TO4iNCAAA0E5MeExXJwEAAJ+ERoR0dRKAI0JUWHRXJwGHKMe2ERsVpsRu4e3CxUaFdVaSgE4TEx6j+Ih4rpX9wKOZAAAAAAAAAACAadiIAAAAAAAAAAAApmEjAgAAAAAAAAAAmIaNCAAAAAAAAAAAYBp+rBoAAFglRnbXhMFXKDGyuyTZvXYmIzZTw5OOUUZsZsDTkhwboYnZmdbXgDdoN8DRp8fAJMX0iFbasBRFx0cpOjGqq5MEB4np8eo5PEWJ6fFdnRS4YVkHZsRmelwDwhyB6CthgwYp/MQTFTZoUMDSk96njya0/tI2+iYl6YYzIlyutZJjI3TDGf2VHBuh4LDuGt//YtXVB6suPlWRIZE+r9FCUlLU7aYbra8DwbGsO2uMMiMvMJfjNbLje3gvyDAMw1OgmpoaxcfHq7q6WnFxcZ2RLgAAAAAAAAAAcIjyZd+ARzMBAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAAAAAAAMA0bEQAAAAAAAAAAwDRsRAAAAAAAAAAAANOwEQEAAAAAAAAAAEzDRgQAAAAAAAAAADANGxEAAAAAAAAAAMA0bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAAAAAAAMA0bEQAAAAAAAAAAwDRsRAAAAAAAAAAAANOwEQEAAAAAAAAAAEzDRgQAAAAAAAAAADANGxEAAAAAAAAAAMA0bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANKHeBDIMQ5JUU1NjamIAAAAAAAAAAMChz7JfYNk/cMerjYja2lpJUnp6uh/JAgAAAAAAAAAAR5La2lrFx8e7DRNkeLFd0draqj179ig2NlZBQUEBSyAQaDU1NUpPT1dRUZHi4uK6OjnAYYl+BPiHPgT4j34E+I9+BPiPfgT4j350ZDMMQ7W1terVq5eCg93/CoRXfxERHBysPn36BCRxQGeIi4tjcAP8RD8C/EMfAvxHPwL8Rz8C/Ec/AvxHPzpyefpLCAt+rBoAAAAAAAAAAJiGjQgAAAAAAAAAAGAaNiJwRImIiNDDDz+siIiIrk4KcNiiHwH+oQ8B/qMfAf6jHwH+ox8B/qMfwcKrH6sGAAAAAAAAAADoCP4iAgAAAAAAAAAAmIaNCAAAAAAAAAAAYBo2IgAAAAAAAAAAgGnYiAAAAAAAAAAAAKZhIwKHvCeeeELHH3+8YmNjlZKSoosuukg5OTl2YRoaGjR58mQlJSUpJiZGl156qUpKSuzCFBYWaty4cYqOjlZKSoruvfdeHTx4sDOzAhwSnnzySQUFBenuu++2fkYfAjzbvXu3rrrqKiUlJSkqKkojRozQqlWrrN8bhqGpU6eqZ8+eioqK0jnnnKNt27bZxVFRUaErr7xScXFxSkhI0A033KD9+/d3dlaALtHS0qKHHnpIWVlZioqKUv/+/fXoo4/KMAxrGPoRYO/bb7/VBRdcoF69eikoKEgff/yx3feB6jPr16/XqaeeqsjISKWnp+vpp582O2tAp3HXj5qbm3X//fdrxIgR6tatm3r16qVrrrlGe/bssYuDfoSjnaf5yNYtt9yioKAgPf/883af04/ARgQOeUuWLNHkyZO1fPlyLVy4UM3NzRozZowOHDhgDTNlyhR9+umn+uijj7RkyRLt2bNHl1xyifX7lpYWjRs3Tk1NTfrhhx/0zjvv6O2339bUqVO7IktAl1m5cqVeffVVjRw50u5z+hDgXmVlpU4++WSFhYVp3rx52rx5s/75z38qMTHRGubpp5/Wiy++qFdeeUU//vijunXrprFjx6qhocEa5sorr9SmTZu0cOFCffbZZ/r222910003dUWWgE731FNP6eWXX9ZLL72kLVu26KmnntLTTz+tf/3rX9Yw9CPA3oEDB3Tsscfq3//+t9PvA9FnampqNGbMGGVmZmr16tV65pln9Le//U2vvfaa6fkDOoO7flRXV6effvpJDz30kH766SfNnj1bOTk5uvDCC+3C0Y9wtPM0H1nMmTNHy5cvV69evdp9Rz+CDOAwU1paakgylixZYhiGYVRVVRlhYWHGRx99ZA2zZcsWQ5KxbNkywzAM44svvjCCg4ON4uJia5iXX37ZiIuLMxobGzs3A0AXqa2tNQYOHGgsXLjQOP3004277rrLMAz6EOCN+++/3zjllFNcft/a2mqkpaUZzzzzjPWzqqoqIyIiwpg5c6ZhGIaxefNmQ5KxcuVKa5h58+YZQUFBxu7du81LPHCIGDdunHH99dfbfXbJJZcYV155pWEY9CPAE0nGnDlzrO8D1WemTZtmJCYm2q3p7r//fmPw4MEm5wjofI79yJkVK1YYkoyCggLDMOhHgCNX/WjXrl1G7969jY0bNxqZmZnGc889Z/2OfgTDMAz+IgKHnerqaklS9+7dJUmrV69Wc3OzzjnnHGuYIUOGKCMjQ8uWLZMkLVu2TCNGjFBqaqo1zNixY1VTU6NNmzZ1YuqBrjN58mSNGzfOrq9I9CHAG5988olGjx6tyy67TCkpKRo1apRef/116/c7d+5UcXGxXT+Kj4/XCSecYNePEhISNHr0aGuYc845R8HBwfrxxx87LzNAFznppJP09ddfKzc3V5K0bt06LV26VOeff74k+hHgq0D1mWXLlum0005TeHi4NczYsWOVk5OjysrKTsoNcOiorq5WUFCQEhISJNGPAG+0trbq6quv1r333qvhw4e3+55+BEkK7eoEAL5obW3V3XffrZNPPlnHHHOMJKm4uFjh4eHWRYJFamqqiouLrWFsb6Bavrd8BxzpZs2apZ9++kkrV65s9x19CPAsLy9PL7/8su655x795S9/0cqVK3XnnXcqPDxckyZNsvYDZ/3Eth+lpKTYfR8aGqru3bvTj3BU+POf/6yamhoNGTJEISEhamlp0WOPPaYrr7xSkuhHgI8C1WeKi4uVlZXVLg7Ld7aPIQSOdA0NDbr//vs1ceJExcXFSaIfAd546qmnFBoaqjvvvNPp9/QjSGxE4DAzefJkbdy4UUuXLu3qpACHjaKiIt11111auHChIiMjuzo5wGGptbVVo0eP1uOPPy5JGjVqlDZu3KhXXnlFkyZN6uLUAYeH//znP5oxY4Y++OADDR8+XGvXrtXdd9+tXr160Y8AAF2uublZl19+uQzD0Msvv9zVyQEOG6tXr9YLL7ygn376SUFBQV2dHBzCeDQTDhu33367PvvsMy1evFh9+vSxfp6WlqampiZVVVXZhS8pKVFaWpo1TElJSbvvLd8BR7LVq1ertLRUv/71rxUaGqrQ0FAtWbJEL774okJDQ5WamkofAjzo2bOnhg0bZvfZ0KFDVVhYKOmXfuCsn9j2o9LSUrvvDx48qIqKCvoRjgr33nuv/vznP2vChAkaMWKErr76ak2ZMkVPPPGEJPoR4KtA9RnWecAvmxAFBQVauHCh9a8hJPoR4Ml3332n0tJSZWRkWO85FBQU6E9/+pP69u0riX6ENmxE4JBnGIZuv/12zZkzR4sWLWr3Z1rHHXecwsLC9PXXX1s/y8nJUWFhobKzsyVJ2dnZ2rBhg92gZ1lcON5YAo40Z599tjZs2KC1a9da/40ePVpXXnml9TV9CHDv5JNPVk5Ojt1nubm5yszMlCRlZWUpLS3Nrh/V1NToxx9/tOtHVVVVWr16tTXMokWL1NraqhNOOKETcgF0rbq6OgUH219+hISEqLW1VRL9CPBVoPpMdna2vv32WzU3N1vDLFy4UIMHD+YxGDgqWDYhtm3bpq+++kpJSUl239OPAPeuvvpqrV+/3u6eQ69evXTvvfdqwYIFkuhH+FlX/1o24Mmtt95qxMfHG998842xd+9e67+6ujprmFtuucXIyMgwFi1aZKxatcrIzs42srOzrd8fPHjQOOaYY4wxY8YYa9euNebPn2/06NHDeOCBB7oiS0CXO/3004277rrL+p4+BLi3YsUKIzQ01HjssceMbdu2GTNmzDCio6ON999/3xrmySefNBISEoy5c+ca69evN8aPH29kZWUZ9fX11jDnnXeeMWrUKOPHH380li5dagwcONCYOHFiV2QJ6HSTJk0yevfubXz22WfGzp07jdmzZxvJycnGfffdZw1DPwLs1dbWGmvWrDHWrFljSDKeffZZY82aNUZBQYFhGIHpM1VVVUZqaqpx9dVXGxs3bjRmzZplREdHG6+++mqn5xcwg7t+1NTUZFx44YVGnz59jLVr19rdc2hsbLTGQT/C0c7TfOQoMzPTeO655+w+ox+BjQgc8iQ5/ffWW29Zw9TX1xu33XabkZiYaERHRxsXX3yxsXfvXrt48vPzjfPPP9+IiooykpOTjT/96U9Gc3NzJ+cGODQ4bkTQhwDPPv30U+OYY44xIiIijCFDhhivvfaa3fetra3GQw89ZKSmphoRERHG2WefbeTk5NiFKS8vNyZOnGjExMQYcXFxxnXXXWfU1tZ2ZjaALlNTU2PcddddRkZGhhEZGWn069fPePDBB+1u9NCPAHuLFy92ei00adIkwzAC12fWrVtnnHLKKUZERITRu3dv48knn+ysLAKmc9ePdu7c6fKew+LFi61x0I9wtPM0HzlythFBP0KQYRhGZ/zlBQAAAAAAAAAAOPrwGxEAAAAAAAAAAMA0bEQAAAAAAAAAAADTsBEBAAAAAAAAAABMw0YEAAAAAAAAAAAwDRsRAAAAAAAAAADANGxEAAAAAAAAAAAA07ARAQAAAAAAAAAATMNGBAAAAAA71157rS666KKuTgYAAACAI0RoVycAAAAAQOcJCgpy+/3DDz+sF154QYZhdFKKAAAAABzp2IgAAAAAjiJ79+61vv7www81depU5eTkWD+LiYlRTExMVyQNAAAAwBGKRzMBAAAAR5G0tDTrv/j4eAUFBdl9FhMT0+7RTGeccYbuuOMO3X333UpMTFRqaqpef/11HThwQNddd51iY2M1YMAAzZs3z+5cGzdu1Pnnn6+YmBilpqbq6quvVllZWSfnGAAAAEBXYyMCAAAAgEfvvPOOkpOTtWLFCt1xxx269dZbddlll+mkk07STz/9pDFjxujqq69WXV2dJKmqqkpnnXWWRo0apVWrVmn+/PkqKSnR5Zdf3sU5AQAAANDZ2IgAAAAA4NGxxx6rv/71rxo4cKAeeOABRUZGKjk5WTfeeKMGDhyoqVOnqry8XOvXr5ckvfTSSxo1apQef/xxDRkyRKNGjdKbb76pxYsXKzc3t4tzAwAAAKAz8RsRAAAAADwaOXKk9XVISIiSkpI0YsQI62epqamSpNLSUknSunXrtHjxYqe/N7Fjxw4NGjTI5BQDAAAAOFSwEQEAAADAo7CwMLv3QUFBdp8FBQVJklpbWyVJ+/fv1wUXXKCnnnqqXVw9e/Y0MaUAAAAADjVsRAAAAAAIuF//+tf63//+p759+yo0lMsOAAAA4GjGb0QAAAAACLjJkyeroqJCEydO1MqVK7Vjxw4tWLBA1113nVpaWro6eQAAAAA6ERsRAAAAAAKuV69e+v7779XS0qIxY8ZoxIgRuvvuu5WQkKDgYC5DAAAAgKNJkGEYRlcnAgAAAAAAAAAAHJn4X5EAAAAAAAAAAIBp2IgAAAAAAAAAAACmYSMCAAAAAAAAAACYho0IAAAAAAAAAABgGjYiAAAAAAAAAACAadiIAAAAAAAAAAAApmEjAgAAAAAAAAAAmIaNCAAAAAAAAAAAYBo2IgAAAAAAAAAAgGnYiAAAAAAAAAAAAKZhIwIAAAAAAAAAAJiGjQgAAAAAAAAAAGCa/w+7zcdojesQxgAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "first_training_file['annotation']" ] @@ -96,9 +170,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + ", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from pyannote.audio.pipelines.overlapped_speech_detection import OracleOverlappedSpeechDetection\n", "oracle_osd = OracleOverlappedSpeechDetection()\n", @@ -111,7 +197,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Training" + "## Finetuning\n", + "\n", + "In this part, we propose to finetune the [hf.co/pyannote/segmentation-3.0](https://hf.co/pyannote/segmentation-3.0) on an OSD *task*" ] }, { @@ -119,7 +207,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We initialize an OSD *task* that describes how the model will be trained:\n", + "Firstly, we initialize an OSD *task* that describes how the model will be trained:\n", "\n", "* `protocol` indicates that we will use files available in `protocol.train()`.\n", "* `duration=2.` and `batch_size=16` indicates that the model will ingest batches of 16 two seconds long audio chunks." @@ -136,11 +224,12 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "We initialize the *model*: it needs to know about the task (`task=osd`) for which it is being trained for:" + "The next step is to load the segmentation model. 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", + "For instance, to load the speaker segmentation model used in this tutorial, you have to visit [hf.co/pyannote/segmentation-3.0](https://hf.co/pyannote/segmentation-3.0), accept the terms, and log in using `notebook_login` below:" ] }, { @@ -149,8 +238,8 @@ "metadata": {}, "outputs": [], "source": [ - "from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel\n", - "model = SimpleSegmentationModel(task=osd)" + "from huggingface_hub import notebook_login\n", + "notebook_login()" ] }, { @@ -158,18 +247,129 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now that everything is ready, let's train with `pytorch-ligthning`!" + "We can then initialize the *pretrained model*: it needs to know about the task (`task=osd`) for which it is being trained for:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [], + "source": [ + "from pyannote.audio.core.model import Model\n", + "\n", + "pretrained_model = Model.from_pretrained(\"pyannote/segmentation-3.0\", use_auth_token=True)\n", + "# we assign the OSD task to the model\n", + "pretrained_model.task = osd" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that everything is ready, let's train with `pytorch-ligthning`!" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, 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" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params | In sizes | Out sizes \n", + "---------------------------------------------------------------------------------------------------------------------\n", + "0 | sincnet | SincNet | 42.6 K | [1, 1, 32000] | [1, 60, 115] \n", + "1 | lstm | LSTM | 1.4 M | [1, 115, 60] | [[1, 115, 256], [[8, 1, 128], [8, 1, 128]]]\n", + "2 | linear | ModuleList | 49.4 K | ? | ? \n", + "3 | classifier | Linear | 129 | [1, 115, 128] | [1, 115, 1] \n", + "4 | activation | Sigmoid | 0 | [1, 115, 1] | [1, 115, 1] \n", + "5 | validation_metric | MetricCollection | 0 | ? | ? \n", + "---------------------------------------------------------------------------------------------------------------------\n", + "1.5 M Trainable params\n", + "0 Non-trainable params\n", + "1.5 M Total params\n", + "5.890 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2433ca383e8f4470adae1e34ffa53b2f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "oracle_osd(test_file).get_timeline()" ] }, { @@ -203,20 +431,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "from pyannote.audio import Inference\n", - "inference = Inference(model)\n", + "inference = Inference(pretrained_model)\n", "osd_probability = inference(test_file)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "osd_probability" ] @@ -226,7 +466,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Pipeline" + "## Pipeline" ] }, { @@ -244,12 +484,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "from pyannote.audio.pipelines import OverlappedSpeechDetection as OverlappedSpeechDetectionPipeline\n", - "pipeline = OverlappedSpeechDetectionPipeline(scores=inference).instantiate(\n", + "pipeline = OverlappedSpeechDetectionPipeline(pretrained_model).instantiate(\n", " {\"onset\": 0.5, \"offset\": 0.5, \"min_duration_on\": 0.1, \"min_duration_off\": 0.1})" ] }, @@ -263,9 +503,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + ", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "pipeline(test_file).get_timeline()" ] @@ -288,25 +540,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# to make things faster, we run the inference once and for all... \n", - "validation_files = list(protocol.development())\n", - "for file in validation_files:\n", - " file['osd'] = inference(file)\n", - "# ... and tell the pipeline to load OSD scores directly from files\n", - "pipeline = OverlappedSpeechDetectionPipeline(scores=\"osd\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'loss': 0.7273619100616171,\n", + " 'params': {'onset': 0.4321866835452871,\n", + " 'offset': 0.33656592926710593,\n", + " 'min_duration_on': 0.11171631479481339,\n", + " 'min_duration_off': 0.07311754878841395}}" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from pyannote.pipeline import Optimizer\n", + "validation_files = list(protocol.development())\n", "optimizer = Optimizer(pipeline)\n", "optimizer.tune(validation_files, n_iterations=200, show_progress=False)" ] @@ -321,11 +575,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "optimized_pipeline = OverlappedSpeechDetectionPipeline(scores=inference).instantiate(optimizer.best_params)\n", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + ", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "optimized_pipeline = OverlappedSpeechDetectionPipeline(pretrained_model).instantiate(optimizer.best_params)\n", "optimized_pipeline(test_file).get_timeline()" ] } @@ -346,7 +612,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/tutorials/training_a_model.ipynb b/tutorials/training_a_model.ipynb index f3e019f8b..582d729a5 100644 --- a/tutorials/training_a_model.ipynb +++ b/tutorials/training_a_model.ipynb @@ -1,886 +1 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# preparing notebook for visualization purposes\n", - "# (only show outputs between t=180s and t=240s)\n", - "from pyannote.core import notebook, Segment\n", - "notebook.crop = Segment(210, 240)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Training, fine-tuning, and transfer learning with `pyannote.audio`\n", - "\n", - "In this tutorial, you will learn how to use `pyannote.audio` to \n", - "\n", - "* train a voice activity detection model from scratch, \n", - "* fine-tune a pretrained speaker segmentation model,\n", - "* perform transfer learning (from speaker segmentation to overlapped speech detection)\n", - "\n", - "## Data preparation\n", - "\n", - "This tutorial assumes that \n", - "* the [AMI corpus](https://groups.inf.ed.ac.uk/ami/corpus/) has already been [setup for use with `pyannote`](https://github.com/pyannote/AMI-diarization-setup/tree/main/pyannote)\n", - "* the `PYANNOTE_DATABASE_CONFIG` environment variable is set accordingly. \n", - "\n", - "See [`pyannote.database` documentation](https://github.com/pyannote/pyannote-database#pyannote-database) to learn how to prepare your own dataset for training with `pyannote.audio`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.database import get_protocol\n", - "ami = get_protocol('AMI.SpeakerDiarization.only_words')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training a voice activity detection model from scratch" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Voice activity detection (VAD) is the task of detecting speech regions in a given audio stream or recording.\n", - "\n", - "We initialize a VAD *task* that describes how the model will be trained:\n", - "\n", - "* `ami` indicates that we will use files available in `ami.train()`.\n", - "* `duration=2.` and `batch_size=128` indicates that the model will ingest batches of 128 two seconds long audio chunks." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.tasks import VoiceActivityDetection\n", - "vad_task = VoiceActivityDetection(ami, duration=2.0, batch_size=128)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We initialize one *model* with the `PyanNet` architecture used [in that paper](https://arxiv.org/abs/2104.04045). \n", - "In particular, we increase the default stride of the initial `sincnet` feature extraction layer to `10`.\n", - "\n", - "The model is also provided with the task (`task=vad_task`) for which it is being trained:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.models.segmentation import PyanNet\n", - "vad_model = PyanNet(task=vad_task, sincnet={'stride': 10})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that everything is ready, let's train with `pytorch-ligthning`!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\n", - " | Name | Type | Params | In sizes | Out sizes \n", - "-----------------------------------------------------------------------------------------------------------------------\n", - "0 | sincnet | SincNet | 42.6 K | [128, 1, 32000] | [128, 60, 115] \n", - "1 | lstm | LSTM | 589 K | [128, 115, 60] | [[128, 115, 256], [[4, 128, 128], [4, 128, 128]]]\n", - "2 | linear | ModuleList | 49.4 K | ? | ? \n", - "3 | classifier | Linear | 129 | [128, 115, 128] | [128, 115, 1] \n", - "4 | activation | Sigmoid | 0 | [128, 115, 1] | [128, 115, 1] \n", - "5 | validation_metric | AUROC | 0 | ? | ? \n", - "-----------------------------------------------------------------------------------------------------------------------\n", - "681 K Trainable params\n", - "0 Non-trainable params\n", - "681 K Total params\n", - "2.728 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validation sanity check'), FloatProgress(value=1.0, bar_style='info', layout=Layout…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0a76f04fd4ab4cad9dac09344b932e49", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Training'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "import pytorch_lightning as pl\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\", max_epochs=1)\n", - "trainer.fit(vad_model)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For the purpose of this tutorial, the model is trained for only 1 epoch. One can obviously expect better performance by training longer and on more data.\n", - "\n", - "See [`pytorch-lightning`](https://www.pytorchlightning.ai/) documentation to learn more about the [`Trainer` API](https://pytorch-lightning.readthedocs.io/en/latest/common/trainer.html), in particular." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Once trained, the model can be applied to a test file:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "test_file = next(ami.test())\n", - "# here we use a test file provided by the protocol, but it could be any audio file\n", - "# e.g. test_file = \"/path/to/test.wav\"." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Because the model was trained on 2s audio chunks and that test files are likely to be much longer than that, we wrap the `model` with an `Inference` instance: it will take care of sliding a 2s window over the whole file and aggregate the output of the model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.audio import Inference\n", - "vad = Inference(vad_model)\n", - "\n", - "vad_probability = vad(test_file)\n", - "vad_probability" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Perfect voice activity detection output should look like that:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - ", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "expected_output = test_file[\"annotation\"].get_timeline().support()\n", - "expected_output" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Fine-tuning a pretrained speaker segmentation model\n", - "\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. \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": 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\", use_auth_token=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's visualize how it performs on our test file:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "spk_probability = Inference(pretrained, step=2.5)(test_file)\n", - "spk_probability" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A perfect output would look like that:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_file[\"annotation\"].discretize(notebook.crop, resolution=0.010)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We are going to fine-tune this pretrained model on the AMI dataset:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.tasks import SpeakerDiarization\n", - "seg_task = SpeakerDiarization(ami, duration=5.0, max_num_speakers=4)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To check that fine-tuning was actually helpful, we need to evaluate the performance of the pretrained model, and compute the average local diarization error rate on a 5s window sliding over the whole test set. To do so, we need to create a helper function:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def test(model, protocol, subset=\"test\"):\n", - " from pyannote.audio.utils.signal import binarize\n", - " from pyannote.audio.utils.metric import DiscreteDiarizationErrorRate\n", - " from pyannote.audio.pipelines.utils import get_devices\n", - "\n", - " (device,) = get_devices(needs=1)\n", - " metric = DiscreteDiarizationErrorRate()\n", - " files = list(getattr(protocol, subset)())\n", - "\n", - " inference = Inference(model, device=device)\n", - "\n", - " for file in files:\n", - " reference = file[\"annotation\"]\n", - " hypothesis = binarize(inference(file))\n", - " uem = file[\"annotated\"]\n", - " _ = metric(reference, hypothesis, uem=uem)\n", - " \n", - " return abs(metric)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can then evaluate the model and see its local DER:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Local DER (pretrained) = 18.3%\n" - ] - } - ], - "source": [ - "der_pretrained = test(model=pretrained, protocol=ami, subset=\"test\")\n", - "print(f\"Local DER (pretrained) = {der_pretrained * 100:.1f}%\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we prepare the model for fine-tuning, simply by overriding its `task` attribute..." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from copy import deepcopy\n", - "finetuned = deepcopy(pretrained)\n", - "finetuned.task = seg_task" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... and we train it (for just one epoch)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\n", - " | Name | Type | Params | In sizes | Out sizes \n", - "-------------------------------------------------------------------------------------------------------------------\n", - "0 | sincnet | SincNet | 42.6 K | [32, 1, 80000] | [32, 60, 293] \n", - "1 | lstm | LSTM | 1.4 M | [32, 293, 60] | [[32, 293, 256], [[8, 32, 128], [8, 32, 128]]]\n", - "2 | linear | ModuleList | 49.4 K | ? | ? \n", - "3 | classifier | Linear | 516 | [32, 293, 128] | [32, 293, 4] \n", - "4 | activation | Sigmoid | 0 | [32, 293, 4] | [32, 293, 4] \n", - "5 | validation_metric | AUROC | 0 | ? | ? \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)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validation sanity check'), FloatProgress(value=1.0, bar_style='info', layout=Layout…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "634877439d6744d88223cfd1313e5fc1", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Training'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\", max_epochs=1)\n", - "trainer.fit(finetuned)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now evaluate the performance of the fine-tuned model..." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Local DER (finetuned) = 17.5%\n" - ] - } - ], - "source": [ - "der_finetuned = test(model=finetuned, protocol=ami, subset=\"test\")\n", - "print(f\"Local DER (finetuned) = {der_finetuned * 100:.1f}%\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... to confirm that it actually improved its performance on the AMI test set.\n", - "\n", - "\n", - "## Transfer learning\n", - "\n", - "What if you are only interested in detecting overlapped speech regions? \n", - "\n", - "Looking at the output of the `pyannote/segmentation` model, it seems that it would be a good starting point for training such a dedicated model:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABHwAAAEiCAYAAACLNMUPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAB7t0lEQVR4nO3dd4Acdf3/8ednZuvdXr9LcumVAIHQAqFLB0EQAQUVCyoIKsJXv4rtq/4sIHbEAiqKClKkKCJK74qQ0AIkoaT3XK7fbZ/P74/Z29yFS3It2du71yMsMzs75b17n52dec/n8xljrUVEREREREREREYOp9ABiIiIiIiIiIjI0FLCR0RERERERERkhFHCR0RERERERERkhFHCR0RERERERERkhFHCR0RERERERERkhFHCR0RERERERERkhAkMdgW1tbV26tSpQxCKiIiIiIiIiIgALFy4sMFaWzfQ5Qed8Jk6dSoLFiwY7GpERERERERERCTHGLNyMMurSZeIiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAgTKHQAMjiJTIIVrStoTjbjWQ8s2K5/1h9uy2C2jhvT+/Ru4z1H+7ds93n6HcN2pneXtVk86+Uf1lo8vO1vq5f3NdTvaWfvx2AIOAECToCgE9zh0DXudre3I9ZaGuINJDIJ0jZNL8Xg7cv0Zabcurddpvuy3V/f3mvbK5fGmPww4kaYXD65TzHJyJb20jQnmmlMNNKZ6Xzb971r3BiDYxxc4+IYJ//o+h65xiXoBIkEIkTcSH7oOm6h32Kv1revZ0tiC/FMnHQ27X8/jMHByb9Xxzj570zXdIPxPyNyn5H1sNi3fWZYto4XyPb27bvS5PLJTCmfstu3KyIi0lepbIoNHRvY0LGBtJfe7nx9OX7f9th8oPp6rtBXBpM/jsGQH3eMk3+9MlzJ9Mrp+WnSf0r4FKH17etpTDby97f+zj1v3UNbqq3QIcku0pUc6m8iqDXZSlu6uMvFHlV7cOcZdxY6DNlFrLUks0naUm20plppTDSyJb6FLYktbIlvYUPHBta2r2Vt+1o2dW4a8oOM7rqSQOWhcsaWjGVMyRjGlY5jYmwiE8omML50POXhcipCFQTd4C6Lo0sqm+IrT32F+1fcv8u3NRpdst8lfGr/TxU6DBEREQA60508tvoxnlj7BKtbV7O+Yz2b45sLHdawMbNyJr8+8dfUldQVOpSipIRPEfrkQ59kectyAk6AE6ecyPGTj6c6Up1PAnSvadL1r0uP2hY7qJWxs3n6Mr3Hera3bF/W02O05/p7u5oPW2vT7Ox9DfV76uvnlbVZ0tk0aZsmnU2T8TKkvZ0P054//85OfqOBKNMrphMLxQiYQN+z4n282N5b7afeajbl5+ullti25dL61dPyNRFioVjfgpEhkcgkeL3p9R7lzVpLebgcz3rEM3ESmQQpL0VFqIKaaA1jS8biGIfGRCPrO9azvn096zvW055uJ5lJksgmSGQS+aROa6qVRCaRn769K1aOcRhTMoYJsQnMr5/P+Nh4aiO1VEWqiAVjOFmP4KI3cZcux0kkcdY3QEccsllswCWz7yxSx80nW1NB1maxWLJeFg+PdDad334ikyCe9d9XPBOnOdnMps5NvLrlVR5e9XCv8eVrBgUi1EXr2Kt6L/ap3YdTp59K2A33+fO21tKaamVd+zrWdaxjQ8cGMl4GgGfWP8NTa5/iE/t+gv3r9icSiBByQz1q63SvqdNVc6d7zc78PhEnf9Wse82g/FW1Xn4ndpddmcTbkTElYwqyXRERke6WNS/jly/9ksdXP04im6AmUsPMqpkcOeFI6mP1jC8dz7jScTs9vuhLa4Ch+p0fqvVs2yKl+zEOkB9f3baaHzz3A6569ip+fMyPh2Tbo40ZbBWvefPm2QULFgxRONIXD696mM50J4ePP5yaaE2hwxGREWBZ8zLe/bd3D8m6ooEoETdCOBAm4kYoD5dTHvIf0UCUsBsmEohQFiqjLFhGWaiMmmgNNZEaqqPVVIYrt5uk7Hz+BdZ94Quk1671JxhDsL4et7ISHAevvZ3UihUQCFB5ztmM+d8v4MZK+/0ePOuxuXMza9rXsL5jvZ+0SrbSlmojkfUTRBs6NrB4y2La0m2cMPkEfnzMj9920OVZj8WNi1m4YSFr29eyrn0dazvWsr7dT4z1JuJG+MwBn+Ejcz7S77hFRERk+Fvdtpr3/f19GGM4ddqpvHPaOzlgzAFqutSLb/z7Gzy08iGePO/JUfn5GGMWWmvnDXR51fApQsdPPr7QIYjICDOudBy/PP6XPZoOArSl2nAdN5/ECTgBWpItNCQa2NThN7WqDFcyPuZfhRpXMm6XNXuKL1rEqo9/nMCYOib87BpKDzsMp7QU4/T88U+tWkXjjX+g6ZZb6Pj3f5h0/XWEp03r17Yc4zC2dCxjS8fucD7Petyw6AZ+9sLPeGb9Mxw2/jAAMl6Gf634FzcsuoE3m98EIBaMMT42ngmlEzh47MGMj43PP+pL6wm7YTzrEXbDhNxQv+IVERGR4nHt89cCcPu7bmdi2cQCRzO87V+3P3e9cRcrWlcwvWJ6ocMpOkr4iIgIJcESjpp4VKHD2K5MYyOrL76EQHU1U2++mUBt7XbnDU2ezLiv/x/lp53Kmks/y+pPXMi0O+/wawENMcc4fGTOR7ht6W38/IWfc+DYA/nbm3/jd6/8jrXta5lZOZP/d/j/4+iJR1Mb3X7MIiIiMjq0p9p5ZPUjvGfme5Ts6YN9a/cF4NWGV5XwGQAlfEREZNhrvvNOslu2MPnuu3aY7Omu5KCDmHTdr1hx3vvZ/LNrGff1/9slsYXcEBfueyHf+e93mHeTX+N239p9+eLBX+SYSceMyurHIiIi0rvnNjxHMpvk5KknFzqUotCVFFvfsb7AkRQnJXxERGRYs9bScuddRA86iMhee/Vr2ejcuVSddx5Nt95K5bnvIzJ79i6J8b2z30skEGF5y3IOHX8o88fN71MniiIiIjK6vNb4Go5xmFM7p9ChFIVIIEJ1pFoJnwHSZUcRERnW4gsXklqxgsqzzx7Q8nWfvRQnFqPh578Y4si2cozDu2e+m8sPupxD6w9VskdERER69dqW15heMZ1oIFroUIrGuNJxSvgMkBI+IiIyrDXfcSdOaSnlpwys6rNbWUnVB95P20MPkVy+fIijExEREem7pY1L2bN6z0KHUVTqS+vZ0L6h0GEUJSV8RERk2Mq2t9N6//2Un3oqTknJgNdTff75mGCQxt/fOHTBiYiIiPRDIpNgY+dGppRPKXQoRaW+tJ51Heuw1hY6lKKjhI+IiAxbrf+4DxuPU3nOwJpzdQnU1lLxnvfQ8te/ktm8eYiiExEREem7te1rAZhcNrnAkRSXupI64pk48Uy80KEUHSV8RERkWPI6Omj83e8Iz5pJZO7cQa+v5oKPYtNpGm+6eQiiExEREemfVa2rAJhUNqnAkRSXmkgNAFviWwocSfFRwkdERIYday0bvnslqVWrGPvVrw1JJ8ihqVMpO/FEmm65hWx7xxBEKSIiItJ3q9tWAzC5XDV8+qM6Ug3AloQSPv2lhI+IiAwryTfeYN0VV9By113UXPxJSg+dP2Trrvn4x/BaW2n+y1+GbJ0iIiIifbGqbRVloTIqwhWFDqWo1ERzNXyU8Om3QKEDEBGR0cdLpdj0ve+RWr2G2JFH4JSVE6ippvmOO2l78EFMMEjNRRdRd+mlQ7rd6H77UTJ/PltuuIGq970Xp7R0SNcvIiIisj1r2tao/54B6Krh05hoLHAkxUcJHxER2e0afvUrmv58CyYYpOPJJ/PTTSRC7Wc+Q9UH3k+gunqXbLvu8stY+f4P0PinP1F78cW7ZBsiIiIi21rVtop9avYpdBhFR334DJwSPiIigtfRQfOdd1F++rsIVFXtkm0k33qLlrvvJrOlkZa//pWKd59B/fe+R7apCa+1lUxDA+FZs3Ardm0155IDDiB2/PFs+e0NVJ577i57vyIiIiJd0l6a9e3rOWXqKYUOpegE3SBloTLV8BkA9eEjIiKk161j45VX0nzrrflp1lq8zs5Br9taS+PNN7P8rLPZ8rvf03LPPVSccTrjvvUtjDEEqqsJTZ1Kybx5uzzZ02XM5ZfhdXbS+Lvf75btiYiIyOi2sWMjGZvRHboGqCZSoxo+A6AaPiIiQnjWLEqPOorGP/6JkoMPJvHqqzTe/GfSq1YR3X9/Jv7yFwNqYuUlEqz/6tdo/cc/KD3qKMZf+V3cmhqMU9jrDeFZs4gdeyzNd99N3WcvxQSDBY1HRERERraGeAMAdSV1BY6kOFVHqlXDZwCU8BEREQDGfvELrPjg+aw8/0MARA88kPJ3vpPGP/yB1Rd9kil/uHGHnRxv/N7VxF98kfJ3nkJ80SukN6wntWIl2YYG6i6/nJpPXjQkt1cfKpVnn037ww/T/sQTlB1/fKHDERERkRGsK1nR1QGx9E9NtIY3m98sdBhFRwkfEREB/Fov0+/9O53PPUd4+nQie+0FQHT//VjzmUtZ89nLmPSrX2JCobct2/700zTeeCNOWRkbr/oebnU14ZkzKT3kYCrf+15KDztsd7+dnYodfRRuXS3Nd9yphI+IiIjsUkr4DI5q+AyMEj4iIpIXHDOGitNO6zGt7Nhjqf/Wt1j/1a+y7itfZfz3r+7RJMtay+af/Yzg+PFM/8e9pDdsIDRx4rBvJmUCASrf/W62/P5GMg0NBGprCx2SiIiIjFBd/c903XFK+qcmWkNLsoW0lyboDO9jzOFEnTaLiMhOVZ59FnWf+xyt997Lpquvxlqbfy3xyiskXnqZ6o9/DCcaJTxt2rBP9nSpOPNMyGZpuffeQociIiIiI1hjopGyUBlBtziOkYabrkRZU6KpwJEUFyV8RESkT2ou/ARVH/4QjX/4I4033JCf3njjHzDRKBVnnFHA6AYmPHMmkblzabnr7h5JLBEREZGh1JhoVO2eQehqCqc7dfWPmnSJiEifGGMY+6Uvkd3SyKYf/ggTCuNWVtD6j39Qc9FFuGVlhQ5xQCrPOosN3/wmrffd97bmbCIiIiJDoTHRqP57BqEm6ifLtiSU8OkPJXxERKTPjOMw/qoryba2svHKKwGIzJ1L7ScvKnBkA1d5ztm0/PWvbPjGN4nstRfh6dMLHZKIiIiMMFviW5heqWOMgepKlqlJV/+oSZeIiPSLCYWYdN2vmHDtz5jw058y5U9/3OHt2oc7Ewgw/oc/xIRCrPzg+aTXry90SCIiIjLCqIbP4HR9drpTV/8o4SMiIv1mXJfyE0+k/JSTccLhQoczaKGJE5hy05/wkknWffEKbDZb6JBERERkhMh4GZqTzUr4DEIsGCPoBNWkq5+U8BEREQHC06cz7v/+j87nnqPhuusKHY6IiIiMEM3JZixWnTYPgjGG6kg1jXHV8OkP9eEjIiKSU3Hmu+n4979puPbnONESaj52QaFDEhERkSLXdWep6qhq+AxGdaSapqT68OkPJXxERERyjDGM/+53sOk0m77/faL770/JgQcUOiwREREpYl39zqhJ1+BUR1XDp7/UpEtERKQbEwox/srv4tbUsPknP8F6XqFDEhERkSKmhM/QqA5Xq9PmflLCR0REZBtOSQl1l32Wzueeo+lPfyp0OCIiIlLEupp01UTVh89gVEf8hI+1ttChFA0lfERERHpR+d73EjvuODb98Eckli4tdDgiIiJSpBoTjQScAGXBskKHUtSqo9UksgnimXihQykaSviIiIj0whhD/Xe+jVNZwdr/+RzZtrb8a2rmJSIiIn3VmGikOlKNMabQoRS1riZxujV73ynhIyIish2B6mom/PBHpFauZMX7zqXl3n+w/v/+jyX7zmXFee+n87nnCh2iiIiIDHNbElt0S/Yh0JXwUT8+faeEj4iIyA6Uzj+Eyb/7HdnWVtb97//SfPdfKTvpRJKvv87KD32Y1gcfLHSIIiIiMow1xht1S/Yh0JU0a0ro1ux9pduyi4iI7ETp/EOY+dCDpFavxi0rI1hfT7alhZUf+jAN1/6c8hNPLHSIIiIiMkw1JhqZXjm90GEUPdXw6T/V8BEREekDJxolssceBOvrAXArKqg8+yySr79OauXKAkcnIiIiw5G1li2JLbol+xCoilQBSvj0hxI+IiIiA1R2wgkAtD3yaIEjERERkeGoLd1GMpukNlpb6FCKXiQQoSxYxsaOjYUOpWgo4SMiIjJAwQkTCM2cQceTTxQ6FBERERmGVretBmBi2cQCRzIyjIuNY0PHhkKHUTSU8BERERmE2NHvoPO5BXgdHYUORURERIaZ1a1+wmdy2eQCRzIyjC8dz/qO9YUOo2go4SMiIjIIsaOPwqbTdPz3v4UORURERIaZVW2rANXwGSr1pfWs61hX6DCKhhI+IiIig1By4IE4JSW0P6p+fERERKSnla0rGRMdQzQQLXQoI0J9rJ62VBvtqfZCh1IUlPAREREZBBMKETvuOFofeBCbShU6HBERERlGFjcuZlbVrEKHMWJMiE0AtvaNJDumhI+MWp0LF7Lx+z+g5d5/YDOZQocjIkWs4ozT8VpaaLrjjkKHIiIiIsNEe6qdN5veZL+6/QodyoixZ/WegJ9Ik50LFDoAkd3Bi8cx4TA2kaD1/gdovvMO4gsW5l/f9IMfUHLIIdRecjHh6dMLGKmIFKPSo46i9PDD2XjV93DCESrPPqvQIYmIiEiBPbfhOSxWCZ8hNKlsEmXBMl5teJWzZul4a2eU8JERo/OFF9jy2xtIvPIKgdpaQjOm40SiJJYuIfHyIkwggAVIpwlNncqYK66g6tz30f7007Te+w/aH3uMtgceoO6yy6g852zc8vJCvyURKRLGGCb89Cesvfxy1n/1q8RffJHqCz6qBLKIiMgolfbSXP/y9YwrHce8cfMKHc6I4RiHvWv3ZuHGhVhrMcYUOqRhzVhrB7WCefPm2QULFgxROCID03jzzWy88ioC1dWUHHoo2cZGksuWYRMJQlOnUjL/EMhmsZ5H2bHHEj3ooLftHNKbNrHh/75O++OPQyBA7MgjqTjjdCJz5hCor8cJhQr07kSkWNh0mo0/+AFNt9wK6TQlhx5K1fvfT+yYd+CEw4UOT0RERHaDlza/xDXPX8NzG57jB0f/gFOmnVLokEaU25fezref+TZ/PvXP7Fu3b6HD2aWMMQuttQPOGCrhI0Wv9f4HWHvZZcSOPZbx378at6xswOuy1hJ/8UXaHnqI1r/fS2bTJv8FxyE4aSLhGTMJz5hBeNZMQlOmEKivJ1Bbi3HUHRb4n59NpbCJBF4iiU0m8BIJbDKJCQZxq6oJVFVilDwbfpJtsOwxwIAxPYeBEMTGQXk9RCpz02VHMg0NNN95F0233Upm3XoIBAjPmEFk772JzJnjD/ecjVNSUuhQRUREZAj9+uVfc+0L11IVruIzB3yG981+X6FDGnHaUm288653MrZkLL84/heMKx1X6JB2GSV8RqHUmrXgZcFxMQEXHAcTCPhJh22Hrjvsq7n1Wga3ndbbPJ5Hx7PPsubTnyEycyqTr7wMJwB4Gf/zsV5umPWHAE4A3KA/zI/nnruBHuPWGuKvvUFq7QbSazeQXLGK5LLlpFaugu6dPAcCBMeNIzBuLG5FJW5FRe5RjlNWhnED/t/JOP6JsmP8v4njALnnrv+6cR3/79rb0HXzf1McJ7+MTaexqaSfaEkm8VIpMuvWEX/pZb8z6q5tOrnlHMfftuvkpnV7Lbc9m8ngdXRgk0lsJpN7pLHJlL+dVArrZcEC2SxeRwfZtja89nbwvJ3+zZ2yMtzqKgKVVbjV1biVleA6/t/Zs2QaGnArK5nwg+/3sRTJYKU3LCZ43aE7nc8Gon7iJzYOW1YPpbV+2U62Yjq3QGcjZOL+dy5UigmXQbgcwmUQqfCHGEh3QqrDf9huZcY4W78rXeOdDbDlLUi2+2XXOP53NRACNwRuODce3jrNCfrfb7drnsDW8a7vPgbScT+WrmE2Bdm0P/Ry3/NAeOu6Te677Lhbx6NVUDUFqqZC5RQIlebfg/UsHf/5L50vvERi8WISr71Gdktj7r0aghMmEKip8b8H1VUEqqsJ5Mbd3Hg+KWT8ZYwx/nhXUi6/i889d1yM62LcgP9b4Lpv33/093fB2tx+uP9D6+X2xZ4Htuu55++bs1n/N8DL5r7/HtbmXvc8rM3iZfxpNuvh5ebzslms9fCynv+3S7Rj21rw2prw2lqx7W3Yjna8znZsRxwbj+N1xEk3dBI75XjGfOGH/Xv/MmC3L72dPy/+M+NKxzGmZEz+URYqI+JGiAT8h2McTO6fYxz/5xG/rBr8cr/t8655DSb3c7p1HT2WM/5Fme7zG7N1nY5x8vN1baP7fLL7dB0TWmzvz3PDrYOt07e3bH7dO1nn2+a3drvzWCzpbJpkNkkym2Rd+zoOG38YkUBk4G9e+uXG+68iFe9gUvlkysIVlIZKCQUiuG4g9wgScIMEAkFcJ4jrBgi4/jDohnEDARwnd/zt5I7Lu34fna7jkLfvA7rKRX6IJZlO0Ni+mU1t63ly5WPc+cotnDLmaD69x8cJZ7utP7dup6QENxbzzxMC2/Sw0n172xkv1H7J5n6n/d/nbuOe9Y/lrO35GXYf91fQY2i3rrj3YRdjev49co9/r/s3lz/2P6Rsmv3r9mdaxTTGlowlFooRC8YoCZYQdIIEnSABJ+CPu93Gne2Mu0ECJlCQz9lai2c9OjOd3LfsPla0ruBL87+khM9os/iQvaG1H383Y7udEOzEQItDr8vtni9JoDTLtBM3E4jsPNEwFKwHqbYAqXaXTKdLOvfIdLpkU07uYbDZwtb6cUs8TND6f5vcAA/A9Dgny79uzda/owETsDiuhdz5Ncbmzm/9Ydef1xgwQYsT9LfnuP6yxu16gHEteJBNOnhJg5d0yCZyw6TBSxmwhq4A3IglUxdl9j0v78ZPbHR7a10Dl157W+7PajFYP7+AJUyasaaJsaaRcaYpN97EGJqoNa0AtBGl2ZbRaGPECWMxRElSZuLEiFNmOokRp9QkAUjZAB1EiBMmi5uLwt+uk3sYLC4erZSw3I6nhVJcPBwsAbKESBMiQ8ik8+NB0gTJEiRDkAyBbuNBMgTM2/cTSRskQYg4YdIESeOSIUAmF1eINOHcNpzc9v2h/yglgdPHnae1kEk4JBqDJJqCpNoCZBMOmaRLNumQSTi578IulvtdGOot2fz/2D3vo69cC0FDtsyh+fCjOPLq6wod0ahx94WnsOeTK/PP89/AXPHorbjY7q8NwXyD0stXe1eV7F32jRncof4O7bLPYhfGvKuEf/x59j7xE4UOY9R45B1zqN+464/9Pfz9iTXgma3jxoLrgeMNt9ted/vy9PULuqP5huNvei8sW/9G5Ma7ptnu07pNh7fP3/Uuu++DusZ39prp7aPvvuxO1rPtMg7QWAFHPrtkUAkfddpchFpPPBTTsgXjWUwum2o8u3XYNd0jX2Oi1xoyQM9vuH37pF7n2/p0QF/9XhbaUb7IWLAmd/ppup+GQrYsQnLGGBaVTaEpVE/WBPGM6z+6ThuNg5e7uufYLI7N4tqMPySL0zVuM7npGf9ELj/dX8bJzevaTG7rYHJZk/zzXCbFYCGTxUllMFkv93fycl9su3U5zx83XVfP838vtk7r+jta6y/f9fe0uemuwboOJjck4OBFAtjY0PQXYnv5g/U2rccfrfu8fSlPvazTxMYyuw/xydCorazgg2e+C8+zZD1L1oLnWTxr8Xcr/tWsTg9WGFixk/X5RdRfFmvzxRWb9l83gfx8PZbrZT09X9/JAr2uo9sU6+F4/vfcYEk7ETzjbjP/jre57esBL0lFagNVyfVUptYR9BL5/YAhtz/O7yf877ud1n0NZusWrMUkMzidSdx4ChNP4aSybE2Hdu13/DjyBw1d7zy37/B/A7b+FhjrbZ2W/73Y5kDZdIujW+ov/zx/Qr3zabZbs0Brug3pes7WWo6514zpOW67XWHtuqpnTdfVwq4aYAbPDZF1w6QjZWRKysmUVJCKVZMprSJTWoGNRjBOoKuyI3PGVyC7j5l2GC1tyfxziyWFR8Z4eEAWi7dt7Q1yB952m+/fts97TO9aqmvh3HSzzZXkbuvvPt59rh6JJLazzYHayYHT9n9fe5t3e6sbaLyFOaHb7lZ7P/TcyvZ8pS/Rm53N2Id1dt/vOhgcayh3A8yavF8fIpChEjvuSFob19JOhhRZUmTxsLnjFf+4hVwtnK5jGKBnDZ3cvP5vM/kHFpyu53T9rprcMDePAesYrOP/RoWMQ8hxqSJMyA1A0MGGXP/YnK7jevwf77SHSWUxqax/XN+b7X2N+1pZY0ezbW8d+QONbtMMW2sXdf1+m67f+twM3efp2iHbbd6zoZeVv/2p7W0+22292zw32zz3sGStJYOX/32x+XLg78/9v3/uODX3eVibm9d0Jflsfn9s6f5bkptmuv0ymG6hmV4+eoNfEzX/tkyP17ZO3rrfMRgqbZCq0lp4dsm2a+wX1fARERERERERERlmBtuHz/CqgSYiIiIiIiIiIoOmhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAijhI+IiIiIiIiIyAhjrLWDW4Exm4EOoGFIIhIZnmpRGZeRT+VcRgOVcxkNVM5lNFA5l5GuFii11tYNdAWDTvgAGGMWWGvnDXpFIsOUyriMBirnMhqonMtooHIuo4HKuYx0Q1HG1aRLRERERERERGSEUcJHRERERERERGSEGaqEz6+HaD0iw5XKuIwGKucyGqicy2igci6jgcq5jHSDLuND0oePiIiIiIiIiIgMH2rSJSIiIiIiIiIywijhIyIiIiIiIiIywijhIyIiIiIiIiIywijhIyIiIiIiIiIywijhIyIiIiIiIiIywijhIyIiIiIiIiIywijhIyIiIiIiIiIywijhIyIiIiIiIiIywijhIyIiIiIiIiIywgQGu4La2lo7derUIQhFREREREREREQAFi5c2GCtrRvo8oNO+EydOpUFCxYMdjUiIiIiIiIiIpJjjFk5mOXVpEtEREREREREZIRRwkdEREREREREZIRRwkdEREREREREZIRRwkdEREREREREZIRRwkdEREREREREZIRRwkdEREREREREZIRRwkdEREREREREZIQJDHYFixsXc8jNhwxFLNJH+9ftz69P+nWhwxg1VrSs4Lx/nJd/bjA9hrknPV8zZofzd73uGAfHOLjGffvQ6fk8P+70Mm9uGHSCBN0gWxJbWNu2li2JLWD9bdqukW3GAazt+Xx7ur+vHtPp3/TeJm93Hf3YpsEQCUSIBqJEA1FKg6VUR6qpidZQG63lwDEHsl/dfriO23tcRebptU9z5xt3srFjI03JJjzrkbVZPOthrfWHWAwGYwz5f6aX5xjeOe2dfPbAzxb6bUlOe6qdv775V57d8CyvbXmNZDaZ/5taa/PD3mz7vdne96WXiX2ab6Dr3973eSDLDfQ9DfX6d/aeuvZLpcFSYsEY0yqmceSEIzl8/OEYY/Csh2McMk1NJF55leTrS8lsbiDb0oLX3o5Np7GZDDaTgUwGEwpholGcaBQnGsFEoriVFZSffDLhmTN3GIuIiMhA3fjKjTy+5nGak82kvTQBE8B1tp6jOMbJH1f2OIdxXEJuiIgbIeSGiGfitKfa6Uh30JnpzM/TfX3dn5cESjhl6ikcP+X4Qn8ERWnQCZ/qSDXnzj53KGLZrfp6gjscjY+NL3QIo0osFOOsWWcBvZebruRJ12s9Eiu9TOv+WtfJ+bZDz3pkva3Tuh5d09M23etyaS9NKpuiKlLFrKpZHBY9DNf0ntzoywlbb++zt/fRH9v7LIZimxZLPBPPPzrSHSxuXMyW+Bba0+0AzKiYwfeO/h57Vu/Zr7iHm9uX3s63n/k2ddE6ZlTOYELZBIJOEIPJ/+g6xq/E2T0x0DXelTgA//P08JhYNrFg70d6emrtU1zxxBW0plqZXDaZeePmURYswxjT44Cqt+/tQBO6ff1u9mX92/vu7mz9vcbQj33Gzpbta6wDfU+9LefhEU/H6ch00Jxs5o7X7+CmxTdxxPgjqCup4+HX/s6VT09i7IIVkMkAYKJR3IoK3LIYBIKYQMB/uC5eRwfeli148Tg2HsdLJPDa29ly/a+Z+KtfEjviiJ3GOVBeKkV6zVq81hbCe++NEwrtsm2JiMjw0pnpxLMek8smE3bDZGyGjJcha7P5Y8muY8yu85OUlyKbyZLMJklmk6S9NBE3QmmolFgoRl1J3dbzHS9LxmbIellS2RRxL07GZmjobOBfK/7FDSfdwCH1qmjSX2awiY958+bZBQsWDFE4IiK7RkuyhSfXPslPFv6EeDrOn079EzMqZxQ6rAGx1nL6X0+nMlzJ70/+PUE3WOiQZACaEk280fQG0yunUxutzU9f2riUD973QaZVTOObh3+TOTVzChilDLV0Ns2tS2/l5y/8nGQ2ydw30nz5Lx6V730v5aedRmSvPXErKvq1zszmzaz62MfJNDQw7a93Exw79m3zZJubiS96hczGDWRbWnFiMdyKcsJ77EF4+vT8fPEXX6T5zjsBg4lGsMkU6dWrSK1cRXr9evA8AMJ77smUP/4Bt7x8UJ+HiIjIjiQyCY669SjO2eMcrjjkikKHs9sZYxZaa+cNeHklfERkNFnfvp733fs+ZlXN4oaTbuhTE5Ph5q3mtzjzb2fyjcO+wTl7nFPocGSAHljxAJ9//PMAzK6azWnTT+OAMQfwtae/Rme6k9tPv71HIkhGls60f6X0nmsv54DfPM3U+/9JdMrUAa8v+dZbLD/nvQTq6qj+6EdwoiVkW5pJr11H54IFJJcsge0c84VnzaLu8suI7Lsvy894N15HB05lBTaewLguwSlTCE2e7D+mTMbr7GTD//sWY7/8Jao/8pEBxywiItIXFz1wEZvjm7n73XcXOpTdbrAJn0E36RIRKSb1sXo+tf+nuPK/V/LEmid4x6R3FDqkftsc3wzA1PKphQ1EBmV+/Xx+feKveb3pdR5Y8QA/XvhjAMJumOtPvF7JnhGuJFgCwMR0GQBHPfAuzt3/I1x+0OUEnf7X2gvPmMHkG37L+q9/nY3f+nZ+ugmHiR5wALWXfoaSAw8iOHEibmUFXns72eZmOhcupPnWW1nz6c/484dCTL3jL0Rmz97h9ppuvY3Wf92vhI+IiOxy+43Zj+tfup60lx7Qb+RopoSPiIw65+xxDjcvvplfvPgLjp54dNHV8mlNtgJQHlZTimJWEa7gsPGHcdj4w/jInI+wqnUVL25+kf3r9mdy+eRChye7yeRMBa0hhyNmHM8fX/sjzclmvnPEdwa0Xyo58ECm//3vpNesAcCtqMCJxTDO22/K6sZiBMeNI7LnnlS997003XEHmXXrKD/jDCJ77LHTbcWOOYYtv/0tXjKJEw73O1YREZG+qi+tx2LZ1LmJCbEJhQ6nqCjhIyKjTtAJ8qG9PsR3/vsdXml4hX3r9i10SP3SmsolfEJK+Iwkk8snK9EzCgVbOympq+ea467hupeu4xcv/oLKcCWfO+hzA7qjoDGG0KRJ/VsmFKL6Ax/o1zKRvfaEbJbkm28SnaN+pkREZNcZVzoO8LtmUMKnf95+yUdEZBQ4ZdopAPx73b8LHEn/KeEjMnJktzTi1tQA8Mm5n+S82efxx9f+yPvufR9PrX0Kz3oFjrB34VyTr+SSpQWORERERrr60noA1nesL3AkxUc1fERkVKoIVzC9YjqLGhYVOpR+a022EjABooFooUMRkUHKNDYSHOdfuTTG8JX5X2HeuHn8ZOFPuOShS5hUNokp5VPY0LGBC/a5gNOnnz4smqGGJk/GRCIk33ij0KGIiMgI11XDZ0PHhgJHUnxUw0dERq25dXOLM+GTaqU8XD4sTvpEZHCyjY24VVX558YYTp56MveceQ9XHXUVY0vGsqZtDa5x+epTX+WmxTcVMNqtjOsSHDeO9AYdfIuIyK4VDUSpDFeqhs8AqIaPiIxak8om0ZhoJJ1NE3SLp8f/1lSrmnOJjBBeRwdOrPRt00NuiHdNfxfvmv4ufz7rcclDl/Crl37F2bPOzt/lq5ACY8eS2bix0GGIiMgoUButZUt8S6HDKDqq4SMio1YsGAOgLd1W4Ej6pzWphI/ISGCtxevsxCl9e8JnW45xuGS/S2hLtXHf8vt2Q3Q7Fxg7RgkfERHZLWqiNTQkGgodRtFRwkdERq2yUBkAbakiS/ikWikLlxU6DBEZJJtIgOfhlPStts5+dfuxZ/We3PjqjaS99C6ObueCY8eS3rwZ6w3PjqVFRGTkUA2fgVHCR0RGra6ET3uqvcCR9E9HuiNfO0lEipfX2QnQ54SPMYZP7fcpVrau5G9v/m1XhtYngTFjIZ0m29RU6FBERGSEq4nU0JhoxFpb6FCKihI+IjJqFWuTrrSXJuSECh2GiAxSPuHThyZdXY6ZdAz71e3Hr178FYlMYleF1ieBcWMBSK9TJ5oiIrJr1UZriWfidGY6Cx1KUVHCR0RGrWJt0lVsnUyLSO+8jg6g7zV8wK/lc/mBl7Mpvonblt62q0Lrk/C0aQCklr1V0DhERGTkq4nWAKhZVz8p4SMio1axNulKeSmCjhI+IsVua5OuvtfwAZg3bh4HjjmQO16/o6BV20NTpkAwSPLNNwsWg4iIjA61kVoAGuLquLk/lPARkVErFvKbdLWmWgscSf+kvbQSPiIjQL6GT2n/b7F+5swzWdG6gpc2vzTUYfWZCQYJT51K8vU3ChaDiIiMDvkaPgnV8OkPJXxEZNQqDfhX1dvTRVbDJ5si5KoPH5Fi53UMrIYPwElTTyIaiPK3twrbeXN41izV8BERkV2uK+GjGj79o4SPiIxaruMSC8aKqkmXtdbvtFkJH5GiN5BOm7uUBks5YfIJ/HP5P+lMF64Dy/CsmaTXrs3XVhIREdkVqsJVOMZRHz79pISPiIxqsVCsqJp0ZbwMgJp0iYwAg2nSBXDWrLPoSHfw0KqHhjKsfgnPmgVA8i113CwiIruO67hUhatUw6eflPARkVEtGogW/NbG/ZH20gC6LbvICLC10+aBJXwOGnsQ9aX1PLjywaEMq1/yCZ/XX3/baxs7NvL02qd1NVZERIZETbRGffj0kxI+IjKqRQNR4pl4ocPos1Q2BaDbsouMAF5nJwQCmNDAErjGGI6ZdAzPrHumYPux4MSJuBUVdD63oMf0bGsrP/zP97j4oYu55617ChKbiIiMLLXRWl1E6CclfERkVIu4keJK+Hi5hI+adIkUPa+jA6ekBGPMgNdxzKRjSGQTPLPumSGMrO+M61J61FG0P/kkNpMh09DAuiu+xOuHzOfcLz1MRQecPPXkgsQmIiIjS220Vk26+kkJHxEZ1aLB4qrhk2/SpU6bRYqe19k5oA6buzt47MHEgjEeWf3IEEXVf+Wnnkq2sZHlZ53NWyedTMs//kFo5gxK29McH9yH8bHxBYtNRERGjppoDVviW7DWFjqUoqGEj4iMaiWBkqLqwyffpEs1fESKXlcNn8EIukGOnXQsD658sGB36yo77ljqPvc53MpKyk4+mel/v4f6b30LgFjaLUhMIiIy8tRGakl5KdrSbYUOpWgo4SMio1qx9eGjGj4iI4fX2TnohA/AOXucQ0e6o6C1fGovupApf/wD46+6kvC0aTilMQBiKR1qiojI0KiJ1gCoWVc/6FdYREa1okv4ZP2Ej2r4iBS/oWjSBbBf3X5E3AivbXltCKIaGm7Mf1+lyYH3TyQiItJdbbQWQB0394MSPiIyqkXcCIls8TTp0m3ZRUaOoWjSBeA6LrOqZrG0cekQRDU0nLIyAKJJ9bMgIiJDoyvhoxo+faeEj4iMal2dNnvWK3QofaLbsouMHEPVpAtgdvVsljQuGTYdWZrc+1LCR0REhooSPv2nhI+IjGrRQBSgaDpu7qrhoyZdIsXP6+gYkiZdAPvW7ktrqpU3mt8YkvUNVsZ4JIIQUcJHRESGSHmonIATUMKnH5TwEZFRrSvhUyz9+HTV8FGnzSLFbyhr+Bw+/nAA7n7j7mFRyyeeidMZhlAiW+hQRERkhDDGUButVcKnH5TwEZFRLeJGAIqmHx/V8BEZGWw2i43Hh6yGz7jScRw87mBuWnwTVz17FVmvsImWfMInniloHCIiMrLURmrVaXM/KOEjIqNaNJir4ZMukho+nmr4iIwEXtzf5wxVDR+A6064jg/v/WFuWXILn3/887SmWods3f0Vz8SJhyCYSBcsBhERGXlUw6d/lPARkVGtJOCfbBVLky7dll1kZPA6OoGhTfiE3BBfOPgLXHHwFTy6+lHO/OuZPLHmiQGta7DNwvwaPoZAZ2pQ6xEREemuJlqjhE8/KOEjIqNaVx8+nZnOAkfSN/nbsquGj0hR8zraAYasSVd35+99Pn8+7c9URar49MOf5iP//AivN73ep2VT2RT/+/j/csztxwzqNu/xTJw1tRB8YxXpdesGvB4REZHuaqO1NCWbCt50uVgo4SMio1pVuAqApmRTgSPpm/xt2VXDR6SoZTb7VycDtTW7ZP1zaubw59P+zBUHX8HK1pWcd+95/OC5H9CcaN7hcr948Rfcv+J+GhONXP7o5bS8fj/cfTGJ2z/C7c/9lO888x2+88x3WN22eofrSWQS3DvfAWNovvvuIXxnIiIymtVGa/GsR2OisdChFIVAoQMQESmk6mg1AI3x4vjRUKfNIiNDZtNGAAJjx+6ybYTdMOfvfT6nTDuFa56/hpsW38Rdb9zFBftcwPl7nU9J8O3NyR5e9TBHTzyaj+/zcT5+/wWc8vTnmJS1rHQdOl97nqAJkLFZnljzBLe96zaqIlU9ln+r+S3ufONOHln1CFvKDYHf/YjaeSfusvcoIiKjy5iSMQBs7NxIXUldgaMZ/lTDR0RGtYpQBY5xiuYqQWemE4MhEogUOhQRGYTMpk0ABMbsuoRPl9poLd8+4tvcefqdHDzuYK594VpOu/s0bnrtJt5oeiPfX097qp2VrSuZWzqRA5++jj9sauWd2RA1k4/gtGmn8LvmNAvbQtxy6p/Z3LmZa56/psd27lt2H+f8/RxuWXILMypn8NX5X2XmvBMwxuzy9ygiIqPD+Nh4ANa1q7lwX6iGj4iMaq7jUhmuLJqET3uqndJgKY5Rvl6kmKU3bsQpieJGw7ttmzOrZvKz437Gi5te5CcLf8LVz10NwPSK6ZyzxzmEHL9vsL1fuRc2rWDu9GOYe9J3oHqav4KaQ+HOjzNn05uct+d53Lz4Zs6edTb71u3Lqw2v8tWnvsp+Y/bjR+/4ETXRXdNUTURERreuhM/6jvUFjqQ4KOEjIqNedaS6eBI+aT/hIyLFLbNmBQG3Fa49ED77Ajjubtv2/mP258ZTbmRl60oWbFzA3W/ezfef+z4AteFK9lu5CN75Qzj4Ez0XnPMeeOx78MQP+NiH7uL2pbfzgfs+wKnTTuW5Dc9RHa3mmmOvoSJcsdvei4iIjC7loXJiwRhr29cWOpSioISPiIx6NZGa4kn4pNopC5UVOgwRGaTM2tUEoh40r4Rlj8HM43fr9o0xTK2YytSKqZyzxzksbVzK0qalHN6whvIlL8P0Y9++kOPC0V+Auy+ibvWz3PKuW7h96e3cu+xegk6QXxz/CyV7RERkl6uP1bO+XTV8+kJtAkRk1KuOVLMlvqXQYfRJW7qNWDBW6DBEZBCstSTXrCdUlvEnvHTr1hczSdi8FDa+BunEbotpdvVszphxBrUbXoNoFVRP733Gfc6Gmllw10Xs8eKdfO3Qr/Gf9/+Hx973GHPr5u62eEVEZPSaXDaZlW0rCx1GUVANHxEZ9aZUTOH+lffTke4Y9s2lOlIdVER0BV2kmGU2b8brSBKudmD/8+HFm2DLGxCIwLoXIJNL9DgBGLMX1O/v16ypmrLrg1uzACYeDNvraNkNwIf/Brd/GB7/Huz7XkztTFyz+5qkiYjI6DazciaPrX6MZDZJ2N19feEVI9XwEZFR74C6A/Csx0ubXyp0KDvVnm6nLKgmXSLFLPXmmwCEJ42Bfc7yJybbwHow72Nw1m/g7Bvg8M9CbCy8cif85lh45S7I3VFrl0i0wuYlfsJnRyomwHk3g3HgxZt3XTwiIiK9mFk1k6zNsrxleaFDGfZUw0dERr25dXNxjMOLm17k8PGHFzqcHWpLtRELqUmXSDFLLF4CQHj6VL/vnkuf95tQbVurZt9z/GHDG3DnJ+COC2DRX+C0H0N5/dAHtnYhYGHivJ3PWzYOZp7gN0c77mu7tdNpEREZ3fao3AOAJY1L2LN6zwJHM7ypho+IjHqxUIxZlbN4YdMLhQ5lpzrSHerDR6TIdf73GUJlGQLT9vUn1MzYfhMqgNpZ8ImH4cRvw1uPwC8OgT+cDtcdBX84A576CXjZwQe26A4Ilu68hk+X/T8Ibetg2aOD37aIiEgfTa2YSk2khqfWPlXoUIY9JXxERPBvU/zy5pfJeJlCh7JdaS9NIptQwkekiNlUis6FCykZk4S6flyVdANwxGfhkn/DrJMg1eHXsok3wkPfhPu/OrjAmlbCK3fA3PdBuI/NRme/0+/gecHvB7dtERGRfnCMwzGTjuHJNU/SkmwpdDjDmpp0iYgA88bO47alt/HCphc4eFwfr27vZm2pNgA16RIpYi333IPX0UnZxATUze7/CmpmwDk39Jz2ry/DM7+Eyklw2Kf7v850Au6+2O+T5+j/7ftygTAcfCE88X14+md+Qmpb2TRg/ISViIgUreY77yT51jKic/clOncugfp6zI5qp3aTXreOtocepvVf/yK5ZAkWCI4bR3j2HkRm7+kP99yTwLhxfV7neXuex91v3s23n/k2Vx11FUEnOIh3N3Lp11dEBHjHpHdQFizjliW3DNuET1eTs2kV0wociYgMRHrdOjb96MdEJpZROqUdavcYmhWf9B1oXgX3fwWe/LFf86e0FkrroKwe6veD8Qe8vZ8ga/1Omh/8Bqz6t99RdMXE/m37mC9Bw+vw4P/Bkn/4CalQqb9uL+03QTv2a7DfuUPzXmWn/v7W37lt6W3UReuoK6kjFowRC8WIBWPURGuojdZSE6mhJlpDNBAtdLgiUiQSi5fQfNttNKbTAJiSEtxYjGB9PYHx9QTrxxOsr8etrCDb1kZy6eukli0j+eabZJuaAAjvtRcV73kPJhAgtWYNiUWv0PbPf+W34ZSXE545E7eqivC0qUTmziU6Z46fCHJdrLX5hNCe1Xvy2QM+y0+f/ylNiSYuPeBS9qvbr88Jo9FiSBI+Npv1f9hdVx+wiBSlaCDKB/f+INe9dB1XP3s1p884nRmVM4bNrR496/HXN/5Keah80Akpm8ngdXZik0m8ZAqvrZWOZ/5LaMpkyo47bogiFhmdrLX+dysex+voxOvoILNhPZ0Ln6f5zjuxiU7GH7EB9jufNe0ea5q2EHQNdbEItWUhHGOwFiwWz+bWl1t3wDG4jiHgODiGrcdcjgvn/B6e/wNseBk6GqBjMzStgNb1kE3684XLoaQGgiX+XcESzZBsBTcE7/w+7HsOzyzbwo8feJ23NrcTcA1B1yHkOgRdh5Kwy4y6GLPHljG9rhSAseURZp95PcGJ8/w+gJY/4a/bGDCun9QqH7+7/wyjmmMcIoEIS5uW8uyGZ2lPt+NZr9d5S4Ol1ERqqI5UUxGuoCJcQXmoPD9eEfKHpcFSIoEIYTdMNBAl7Ibzzx2jHiJERoNxF57JmPcfS3JjnPiSN0mvXU+2vYP0hk0kX3uN9ocfwaZS+fmdigqCY8ZQduKJhGfOpPSIwwlPmQTpDkh1gpcBN0g2nia5bCXJt1aQeP1NUstXkF61ivYnnoBccgnHwQQCWM+j9JBDqDjz3ZSdfDIf3/fjVEWq+NGCH/Ghf36IKeVTmDd2HntV78WUiilMjE1kbOnYUV37x9hB3t5zTmmJ/cvkKZjcaizgH4UAroMNOBDIDYOOPy3o+AcCjn+gYv2jFn+Z3NA6Btg6D/3OI+3OxJMF2/Npz5e3mWC3Gdnusjb/uXZ/PVs/jgN+/ZeBhSr9tumFZ9l02SU9J3Yvr11l1Nk6zRreVqZ7XFXt/txss95tp/WXxd/+dl4bzHqL3k72dxZ4y+1gk5PMTwvhELIODuBiMLkPt8efrcf49v94ttuH2Fsk9m3/93lA3GRJGY/J2SiTOoKYtOfvS23ufdnc/sKz+YfxLGS9ns/THibT+4F/Zv4c9v3DHduNX4bW63/4Gfa31/n7DsfB5vYn1ji5acafZoCs9QtC1/6Frb+b1uR+L7vGc/uR/LK5ee0OLshs+0p+HzKI772F3G/YDsr9Dte//RctvcScm930Jej8z+/b5zVe7jfd8zDW5h94uaHNfZc863+XMhayFpOxufHtbNNYonVpxh3YzJraqXzS+zJvdQ6udoXrmPzPSSToUlMaorIkRNA1GGNwDATJMimzkhnp15mcXkbMayNskyTcUjqcMtaHpvBs8BBWZypY3xxnU1uSCZVRjt6jDmstqaxHOmtJZzxaE2ne2NTO5rZkjzhCAYdx5RGqSoKEAg7GGFzjJ6cAPjh/Mu/cdxfcVUx69eo3P4+576Gtx9O5/UbWgayBjGPJGEg7kDGWtNPtYSwZY8nmvmBd+wIL/vroOX3bcQP5fY3pPrHr17H7eLeZbH4bQ3/8vqvOCIb6sKivcQ7Fdne4jm1OPobqffZ9PX3f/pT3fYyTz/7cACOS/lp+/fuZtv6+7b5uLWSTDulUABtwcEvAOi6ecXCsR9BL4G73R3IrD4esCZD2giSaQySbAqTjAaxnsFlLag1k243fG3F5EC/o4gUcWtwsrU6GDscjY/x9U9e+C8AxBoP/2+jQ7Ripa9Dj/Cy3H8sfU+X2U93m27o/7PntzT/r7WCFt33Fei7TY5o/9b23L1xore3D7TN7N+gaPo7rUbpXyv/Ac3tra/03Yj2DzYDNGsiCzYJNG2wC/8CV3AFa16fXbfmte36Gfo+6rX6uv8ffrve/zs6n9XZev93lbI/XU5mOPkQpQ6Uz3kHEbes5sausekCGHmXY2p7zvG1ab8P8eG7n0ZcyuZ0jgz6d7AxgvSPGTt7fHGAvIGUMGQNZvNyBr+mxW+rSa+Jmu3+bgYVnLLhYwhaiXjsmAE7YYpPkz/vp9jCuhWBuugM4FhyDcSy4YIJgghbjAK6BgMWtsSyfPqYPEcpQiRPEuCE/iZCxOJ6/UzE2k0swdEuYOJA/Numx/7Bv25+YXvczfia492OP3ZDN3WHh3wU7ncGssuu75HQb755c63rugo0aCBhswMVzc+Oug5e74OWFHGzQJRsJ0F5bRVO4hteDs3ktdgTzqmJ8dGIF02tLSWc9NrUl2dKewmLzB6T+5kz++DPrWTKe7Tb0crWBIJ7KsqUjRXNniqxn8axfQyhhHZaaaSwJTsUL+DWG/HxVrgZRxlLiuJRHAsyYVcv+kyp570GTiIa2f5v1xo4Uyxs6cB3DqsZOXlnbwsbWBE2dadIZj6y1ZDyPZMYvW2lvJFwxKB4dxKmqSvQ4DslfFOh6ePjJyW2PVbrGu2YxBg//ukGP1W37m2h72ZPs7Aez2/PuJ0BDkG+WnKI6pOulDOxM84aGXRKK9O6+2gtY1bg/tV4jLlkcm8XFw8HDtRkcPBzXwy3xcMh0ey2LZw1xEyFhwsSJECdMBpcAWYJk8o8AGYI27T93MgSqMwSrMwTI5pJFBru/pWJjK7ENbYTaUgQzKcjAmDTUAVj/9Cxl/GHGkP+t9DD5ceh5zNQ13uu03HTTy7TtJXZyq+h9+m78cg66hs+8efPsggULhigcERERERERERExxgyqho8a3YqIiIiIiIiIjDBK+IiIiIiIiIiIjDBK+IiIiIiIiIiIjDBK+IiIiIiIiIiIjDBK+IiIiIiIiIiIjDBK+IiIiIiIiIiIjDBK+IiIiIiIiIiIjDBK+IiIiIiIiIiIjDDGWju4FRjTBiwdmnBEhq1aoKHQQYjsYirnMhqonMtooHIuo4HKuYwGs621ZQNdODAEASy11s4bgvWIDFvGmAUq5zLSqZzLaKByLqOByrmMBirnMhoYYxYMZnk16RIRERERERERGWGU8BERERERERERGWGGIuHz6yFYh8hwp3Iuo4HKuYwGKucyGqicy2igci6jwaDK+aA7bRYRERERERERkeFFTbpEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREaYwGBXUFtba6dOnToEoYiIiIiIiIiICMDChQsbrLV1A11+0AmfqVOnsmDBgsGuRkREREREREREcowxKwezvJp0iYiIiIiIiIiMMEr4iIiIiIiIiIiMMEr4iIiIiIiIiIiMMEr4iIiIiIiIiIiMMEr4iIiIiIiIiIiMMEr4iIiIiIiIiIiMMEr4iIiIiIiIiIiMMIHBrqAx0ch3nvkOnvXI2iye9YYiLpFhpSRQwpfnf7nQYYwaqWyKG1+9EWstHh5Y8PCw1mKxGAzGGBwcMODg+M+Nn8N2jIPBEHAClARKKAmWUBIooTRYyrSKadREawr8Dncday3xTJxUNkXGZkhn02RtNv9ZZm0Wz/OHWZsl62Xz4wCRQISoGyUaiPrjgShhN4wxZre+j3Q2zYaODazvWE9DvIHGRCNtqTYyNkPW839rMjaDtTZfFhzH8Yem56M0WEosGKM0WEp1pJoxJWOojdZSEizZre9JREREpDdZL8tbLW+xoWMDHekO4pl4/niu67i261jX4A+zNkvGy+TPwV3jEnSCVIQrqC+tZ0JsAmNKxuA6bqHfnhTQoBM+HekO7l9xP65xcY2LMWa3nxiI7GrlofJChzCqpLIprn3h2rdN7/qx60r8DFR9aT2nTDuFi+deXPQn/avbVvPiphdZ0riE15te5/Wm12lMNA7pNgwmn/wZUzKGw8YfxpHjj+SgsQf1OIjY3LmZhRsXYrH5iwD5hJKXJZlNkvJSJDIJktlkfpjMJunMdBJPx+lId7A5vplNnZt6/Rs7xsn/3nQldLq2t+1jZ2UkFoxRG63NJ4DGlY5jz+o92bN6T6aUT8knEEV2Fy8eJ/7SyyReWURi8RLSGzaQbWoCazGhULdHkEB1DcEJEwhOnEDpYYcRmjSp0OGLiEg/tKfaeXT1ozy19ikWblzIxs6NQ76NgAkwtnQsE2IT2K9uPz66z0d1XjPKGGsHftIEMG/ePLtgwYIhCkdExK+lkvEyfgI5dxWjt0SytTZ/Yt+VBOr+PO2liWfidKY76cx00pps5Y3mN3h+4/M8svoRppRP4Xcn/44xJWMK8C4H77eLfss1z18DQMgJMbNqJntU7cHU8qlEAhECJkDQDeaTJF01YVzHzSdN8uOOi7WWRCZBIpvIX1mKZ+IkMon8cHnrcl7Y9AIZL8PMypl8Zv/PMKFsAo+seoQbFt1Aykv1KfaIGyEcCBN2woQD4R41sWqiNUyITaC+tJ7xsfHUldRRE6mhLFTWrySMtZaszdKZ6aQj1UFbuo3GRCObO/2EUkO8gU2dm9gc38zmzs1s6NxAxssAfq2+2dWz2at6Lw4edzBHTzyakBvq/x9Jik7aS7Nw40IWbFhAR7qDVDblJyuzKX9/kukkkUmQ9tJkbAbP84iFYlRHqvOPmmiNP4zUMLt6NhXhiu1uz1pLNpmg8Re/ovHmm7GdnQAExtcTmjgJt7ISXAebSmNTKWw6jU0myTQ0kF6/HjIZnJISptz0JyJ7772bPiURERmM25bcxg8X/JBENkF1pJoDxxzIOya9g+kV04mFYkRdv6Z12A33uLAF5Me7jt8CTsCv8eNlSWVTtKRaWNu+lnXt61jXvo617WtZ07aGV7a8wuSyyfz+lN9TG60t8CcgfWWMWWitnTfg5ZXwEZHR6L/r/8ulj1zK/HHzufb4t9cmGu4aE42c8JcTOGLCEVx6wKVMr5hOwBl0pc0+6Uh38Njqx/jVS79iZevK/PRTpp7CR/f5KFE3ijGGgAn0SCiF3BBhN0zICQ3LmqDpbJq3Wt5i8ZbFLG5czJLGJSxpXEI8E6ciXMFp007j3TPfzV7Vew3L+GXnktkkj69+nFVtq/LNPruaQcYzcdZ3rOfpdU/TlmrDMQ4lgRJCbihfdqOBKCWBEiKBCEEnmC/bralWGhONNMYbaUo29WjebjAcPO5gvnvkdxlXOu5tMV3xxBVM/Mu/OeHBBspPPZXyM04nut9+BKqqdvp+bCZDauVKVp7/ISJz92Xy9dcP+jNKLFlCavVqguPqCU2ehPU8Gn/3O1r+dg+4LhWnn07dpZ/BBIOD3paIyGj0rxX/4guPf4EjJxzJJ+d+krl1c3dLreKFGxdy0QMXccKUE7j66Kt3+fZkaCjhIyIyQN/6z7e4f8X9PHXeU0V3Av/Emif49MOf5vcn/5554wb8GzAoaS/NE2ueIJ1Ns1fNXkwpn7J7trt+PYnFi/HicUoOPJBgff0u21bWy/LM+mf465t/5ZFVj5DyUuxZvSeXHXgZR044cpdtV3aNW5bcwpX/vbLX18JumIpwBYfWH8pxk4/jsPrDBtTk07MerUk/AbShcwMvbHqBG1+5kX1q9+GGk2/ocVC/pm0N77zrnfz6mgzjD3kHU667bkDvq+FXv2LzNT9j2t/+SmT27J3Ob60Fz8O4Pft12HLjjWz63jYnAa4Lnkfs+OPAQvvDD1Nx9lmM/+53BxSriMho1pJs4Yy/nsGE2AT+cMofCLq7N3n+04U/5YZXbuCBsx+gPrbrjp9k6Aw24bN7LgeLiAxD0yum56/MF1tHzq83vQ7AHtV7FCyGoBPk+MnH77btZdvb2XjVVbTcdTd0u1gRmTOH4ORJBKqqcCsrcWtriey5F5HZe+CUlg5qm67jcsSEIzhiwhG0JFv41/J/cdPim7jkoUu49IBLuWjuRYN9W7IbnTrtVKaUT+GAMQcA5GviRNzIkHVq6RiHykgllZFKpldO5/DxhzO+dDxf//fX+dNrf+Ijcz6Sn/fR1Y/iZi2VnZCaPfCEadUHPsCW3/yWLb/+DRN+9MP8dJtK0Xz3X2l/9FGy7W0Y45DtaCe9ajVeMkl0n32Izp1LYEwdNuux+ac/JXbC8dR+8pNkNm4ktXIV2aZGKt79bsKzZgGw8erv03jjjdR89KP5aSIi0je/fPGXNCebue6E63Z7sgfg7Flnc8MrN3D/ivv56D4f3e3bl91PCR8RGbWmVUwDYHnL8qJL+CxtXMqE2IRR0/Ge19HByve/n+Rby6i+4ALKTz4JEwrR/uRTdDz5JMnFS+hsaiLb2ppPBplQiPLTTqPu0s8QHD9+0DFUhCs4d89zOWvWWXz1qa/yixd/wQmTT2B65fRBr1t2j4pwBYePP3y3b/fMmWfy2OrHuOb5azh8/OHMqvITJU+tfYqSpD9PSygz4PW7FRVUnneen4j55EXgebQ/9hhNt91OZv16QlOnEqirw3oewboxRPfZF6e0lPjzz9N0223YRAKA6LyDGP+97+HGYrDvvr1uq+bCT9B444203v8AdUr4iIj0WTKb5O437+Zd09/FXjV7FSSGSeWT2KdmH/654p9K+IwSSviIyKiVT/i0Li9Ys6iBWtu+lsllkwsdxm7TcN11JN98i0m//jWxo7Y2pYrstRe1F12Yf26zWTKbN5N47TXan3ySlr/+jbZHHmHyb35NdO7cIYkl6Ab50vwv8ejqR7nx1Rv51hHfGpL1yshljOEbh3+D9/ztPXz1qa9y86k3c+OrN/Lvdf/m/XXHAg/RGEgMahs1F3yUljvvZPkZ785PKznkEOq/9S1Kjzxiu81WrbV4bW1kW1sJTpiw0+atgepqonPn0v7449R95tODillEZDT5z7r/EM/EOW3aaQWN45Rpp/DDBT9kecvy/LGwjFy656yIjFp10ToAGuNDexvz3aE93U5ZqKzQYewWXjxO0+1/oezkk3ske3pjXJfguHGUHXcc9d/4BtP/9lfc8nJWffQCOp59dshiqo5U845J7+DZDUO3ThnZqiPVfP3Qr7O4cTHH3H4MP3vhZwCcP/FMADa5nYNaf6CujonX/YqaCz/B+B/+kJmPPMyUP/6B2FFH7jCJY4zBLS8nNHFin/syix3zDhKLFpFpaBhUzCIio8mCDQsIOSEOHndwQeM4ddqpRNwI175QfDctkf5TwkdERq2gGyTiRmhPtxc6lH7rSHdQGhxc/zTFovW++/BaWqj6wPv7vWxo8mSm3HQTgfH1rL7wItqfeGLI4tqrei/Wtq+lNdU6ZOuUke34KcdzwZwLaE21Uhmu5I7T76A6HQZgnWkZ9PpLDjiAMZ//PBXvOm1ImjFuT+wd7wCg/cmndtk2RERGmqVNS5lROaMgffd0V1dSx4VzL+TBlQ9y+9LbCxqL7HpK+IjIqBYLxWhLtRU6jH4bLQkfay2NN99MeNYsSg4e2BWx4NgxTPnTnwjPmMHqT3+G+KJFQxLbntV7An5/SiJ99bl5n+OO0+/gjtPvYHb1bLw2P2G42jYVOLK+C++1F05FBfGXXix0KCIiRcFay+tNr+ePHQrt4/t8nKMmHMVVz17F8xufL3Q4sgsp4SMio1osWHwJH896dKQ7iIVihQ5ll4u/+CLJ1xZT9cEP9rm5SW8CVVVM/t0NBGprWfv5/yXbPvhaXbOr/dtfL2lcMuh1yegyu3o2Y0vHAvgdjQMrvE2FDKlfjDEEx48ns2FjoUMRESkKWxJbaEw0skdV4e6u2p3ruHzv6O8xITaBzz32OTZ0bCh0SLKLKOEjIqNaWais6Jp0dab9vj5iwZGf8Gm6+c84sRgVp79r0OtyKyuZ8MMfkF67ljUXX4LXObg+U2qjtdRF65TwkUHJtvoJ53VOS/67XQyCY8eS3qiEj4hIX6xpWwPA5PLhc8ON8lA51xx7DfFMnMsevYyGuPplG4mU8BGRUS0WjNGeKq6ET0e6A4CSYEmBI9m1UqtX03r//VS85z04pUPTfK3koIMY//2r6Xz+eVZ/6tNk2wZXu2t29WwlfGRQvNYWbNAlFYDlLcsLHU6fBcaOJaOEj4hIn6xuWw3AxLKJBY6kpxmVM7j66Kt5s+lNTr7jZK55/hoSmcHdNVKGFyV8RGRUi4VitKWLq0lXV8JnpNfw2XjlVTjBIDWf+PiQrrfitNMY/72r6Hz2Wd48/gTWf/0bJJcN7ER7z+o9Wda8jHQ2PaQxyuhgraXzxRdxa2rBGP697t+FDqnPguPGkm1sxEsmCx2KiMiwt6Z9DQbDhNiEQofyNsdMOoa73n0XJ009id8u+i0XP3QxqWyq0GHJEFHCR0RGtbJQWdHV8OlqgjaSO21u/ec/aX/0UWo//WmCY8cO+forzjiDqbffTuyYd9Byzz2seP/7B5T0mVo+lYzNsK5j3ZDHKCNfYtEi4gsWUveJC5lTM4cn1z5Z6JD6LDB2HACZTcXT95CISKGsaVvDmJIxhN1woUPp1ZTyKVx11FVceeSVLNy4kP/3n/+HtbbQYckQUMJHREa1WDBWdH34dMU7Umv4JN96i/Vf/RqR/eZS/eEP7bLtRPeZw4Tvf5/p9/wN47qsvvhiMk39u1NSV1v8Va2rdkWIMsIl31oGQOzIIzhq4lG8tPklWpKDvz377hCoqwMgs3lzgSMRERn+1rWvG5a1e7Z1+ozTuWS/S7jnrXu4afFNhQ5HhoASPiIyqsVCMeKZOGmveJrkdHXsOhJr+GTb21nzmUsx0SgTr7kGEwzu8m2GJk9m0i9/QWbjRtZ8+jP9aqIyqWwSAKvalPCR/kutWgmuS3D8eI6acBSe9Xhq7VOFDqtP3KoqALLNzYUNRESkCGzq3MTYkqGvsbwrXLLfJRwz6Rh+uvCnvNn0ZqHDkUFSwkdERrWyYBkAHamOAkfSdyO1SZe1lvVf/gqpVauY8OMfExw3brdtO7r//oy/+mrizz/Pxiuv6vNyNZEaooFo/u4bIv2RXrmKYH09JhRiTs0cxpaM5e/L/l7osPokUFUJQLafteJEREYbay2bOjdRV1JX6FD6xBjDNw/7JrFQjK889RX1U1jklPARkVGtLOQnfIqp4+Z4Jg5AJBApcCRDx0ul2PCtb9H24IOM+d//pXT+Ibs9hvJTTqb64x+j+bbb6HzuuT4tY4xhctlk1fCRAUmtXk1ost8s0HVczpp1Fk+vfZr/efR/hv1V1XwNHyV8RER2qDXVSiKbYEzJmEKH0mc10Rq+fujXWdy4mBteuaHQ4cggKOEjIqNaLOT3g1NMHTd33Tkh4hZ/wsd6Hq3/up/l7zmL5ltupfqCC6j+6EcKFk/dZz5DYHw9G77zXWwm06dlJpdPVh8+MiCZTZsIdOuU/GP7fIxP7PsJnt3wLB+47wPD+jbtJhrFhMP97vdKRGS02dTpd25fLE26uhw/5XhOnnoyv3n5NyzavIiM17fjIhlelPARkVGtq0lXW6p4avgks34fM+HA8LzTQ2/SGzey4btXsvrTn6Hj3/6tp73OTlZf9EnWXn45ABN/9UvGXvFFjDEFi9OJRhl7xZdILl3Kph/+qE/LTCybyNr2tWS97C6OTkYar70dp2xr5+uRQITLDryMO06/g7Ab5otPfHHY3hrXGINbVUW2qbnQoYiIDGtdCZ9iquHT5Svzv0JdSR0fuO8DvOdv78GzXqFDkn4KFDoAEZFC6qrhU0xNupLZJI5xCJjhvQtPvvUWDddfT7ZhC50LFmA9D7eiglWPPsrYL32J1n/+k/hLLzH2/75G1XnnYVy30CEDUH7ySXSefz6NN95IaOpUqs47d4fzTy6bTNpLs7FzI+Nj43dTlFLsbDaL19GBGyt722v1sXq+e+R3+fTDn+YrT32Fk6acxKyqWUyrmFaASLfPT/ioho+IyI4Uc8KnOlLNz4/7OV988oscOOZA4pn4iOtDcqQb3mcLIiK7WFcNn2Jr0hV2wwWtCbMzHc/8l7WXXYbNZglNnUrFe95DzYWfwK2sYuUHP8jGK6/ERKNM+MlPKD/5pEKH+zZjv3QFqdWr2PDtbxOcNJHYEUdsd96uO3WtbluthI/0mdfhdxTvlL094QNw9MSjuWjuRfz65V9z/4r7CZgAlx14GR+Z85Fh8913Kyt0ly4RkZ3Y2LkRKM6ED8DMqpncdcZdhQ5DBkgJHxEZ1fJ9+KSLJ+GTyCQIuaFCh9Gr+Msv0/inm2i97z5CU6Yw6frrCE2a1GOeqbfeQvuTTxKdO3e33omrP0wgwIQf/ZiVH/gAay+7nKm33kJ45sxe551c5ne6u6ptFfPr5+/OMKWIee3+Psft1qRrW5cecCnnzj6XzfHN3LDoBn608Ec8sPIBvnroV5lTM2d3hbpdgaoqEq8tLnQYIiLD2qbOTVSFq4btsZuMbOrDR0RGtXyTriLqwyflpQg7w6//ns4FC1jx/g/Q/sQTVJ17LlNvv/1tyR7w+8kpP+mkYZvs6eLGSpl03a8wkQjLzzqbDd/6Fp0LFtD64IO0PfIoNuv32TO2dCwhJ8Tq1tUFjliKSbbNT/g4se0nfMC/IjynZg4/esePuOLgK9jQsYFP3P+JYdGhs1upJl0iIjuzqXNT0dbukeKnGj4iMqoFnSARN1JUTbqS2eSwvErUdMutuLEYMx56EHc7zVSKTXD8eCb/9jc0/OIXNN16G01/viX/Ws0lFzPmsstwjMOEsgmsblPCR/rOa/eTzE4vffj0xhjD+Xufz3GTj+O8e8/jK09+hZtOvQnXKVzfV25VFdnWVmwmgwnokFJEpDdK+EghqYaPiIx6sVCsqJp0dfXhM5zYTIa2Rx6h7JRTRkyyp0tkzz2ZeO21zHjgASb+6pdMveMOovvvT8tdd+dr+Uwum8yqNt2aXfou2+YnfHbUpKs342Pj+fL8L/PKllf485I/74rQ+sytqgJryba2FjQOEZHhbGPnRiV8pGCU8BGRUS8WjBVVk65kNjnsbsmeWr0aG48T3X//Qoeyy4QmTqDs2GOJ7jOHqg+dT2bjRuIvvQT4HTevbluNtbbAUUqx8Np33Gnzjpwy9RSOnng0175wLWvb1w51aH3mVlUCqFmXiMh2pLIpGhONjC0dW+hQZJRSwkdERr3yUHlR1fBJZpPDroZP6q23AAjPnFHgSHaP2FFHgevS/tjjgJ/wiWfibElsKXBkUiy2NunqXw0f8Jt3fW3+1zAYvv2fbxcs0RioqgKU8BER2Z7N8c0AjC1RwkcKQwkfERn1YqFYUfXhk8qmhl0fPsm3lgEQmja9wJHsHm55OSUHHkj7k08CMLk8d6euVjXrkr7JN+kaQMIHoD5Wz2cP/CxPr3uafyz/x1CG1mduLuGTUcJHRKRXmzo3AcV7S3Ypfkr4iMioFwvGaE0VTx8UiUxi2NXwSb71JoH6etxYaaFD2W1KDp1PcskSss3NTCrz70amjpulr7LNzZhQCBONDngd580+j7m1c/n+s9+nKbH7ky6uaviIiOzQxs6NgBI+UjhK+IjIqFcWKiuqJl3DsdPm1FvLCE8fHbV7upTOnw/W0rlwIeNj43GNy7KWZYUOS4pEtqGBQG0txpgBr8N1XL5x+DdoSjZxz1v3DGF0fdx+V8Jni5oyioj0ZmOHn/BRky4pFCV8RGTUiwWLq0nXcLstu/U8ksuWjZr+e7pE5s7FhMN0PvssQSfIQWMP4l/L/0XWyxY6NCkCmYYtuLW1g17PHlV7MDE2kRc2vTAEUfWPEw7j1tSQXrdut29bRKQYbOrcRNgNUx4qL3QoMkop4SMio14sFCORTZD20oUOpU+GWw2f9Lr12Hic0PTRlfBxQiGiBxxAx3+fBeDc2eeyrmMd9y2/r8CRSTHI5Gr4DIUDxhzAC5teKEjnzcGJE0itWbPbtysiUgxWtq5kQmzCoGpzigyGEj4iMuqVhfzbIhdLLZ+klyTkDJ8aPolXXwUgPGtWgSPZ/UrnH0Jy6VKyzc2cMOUE5tTM4afP/5TOdGehQ5NhbigTPkdMOILGRCOPr3l8SNbXH6EJE0mvVQ0fEZFtWWt5afNLzK2bW+hQZBRTwkdERr1Y0L9LTrEkfFLZFJFApNBh5HU89SROWRnRffcpdCi7Xckhh/j9+CxYgGMcrjjkCjZ1buLq567eaW2LrJfFs95uilSGE5vJkG1sHLKEz0lTT2JibCK/eulXu72WT3DCBNLr12OzasooItLd8tblNCeb2a9uv0KHIqOYEj4iMurFQn7Cpy3dVuBIds5aO+z68Gl/+mlKDzsMEwwWOpTdLrLvvphIJN+s64AxB3Dhvhdy1xt38d3/fne7NX0a4g188qFP8rtXfrc7w5VhItPYCNbi1tYMyfqCTpAL517Ia1te45/L/zkk6+zztidPgnSa9Nq1u3W7IiLD2br2dXztqa8RdsMcPv7wQocjo1ig0AGIiBRaWbB4mnRlvAye9YZNk67Mli1k1q0n+qEPFzqUgnBCIUoOPIDOZ5/NT7v0gEuJZ+LctPgmHlr5EMdOPpYDxxzI9MrppLNpnljzBH9e8mcyXoZ3TX9XAaOXQsmsXw9AcFz94FbU2QipDqicxBkzzuDON+7km//5JvWxeg4Yc8AQRLp9nvVwjENkr70BSLz2GqHJk3fpNkVEioG1lq89/TWWNC7hW0d8i/Gx8YUOSUYx1fARkVGvqw+fYqjh05nxa4yUBEsKHIkv8dprAET23rvAkRROySF+Pz6ZpiYAjDFcccgV3HjKjRw49kDuW3YfX3nqK5x373l86J8f4oZXbuCQcYdw5xl3cubMMwsbvBREarXfyXFo0sSBr+Qf/wvfnwbX7AeNywg4AX56zE8ZUzKGSx66hBc3vTg0wW6jPdXOx+7/GMfdfhwvbnqR8B6zMMEgiVde2SXbExEpNm80v8FzG57jfw76H13YkYJTDR8RGfUqw5UANCYaCxtIH7Sl/KRUV79DhRZ/+WUAInvvVeBICqfkkPkAdD7zDOXvfGd++kFjD+KgsQeRyqZY3baaZS3LcI3L/mP2pzpSXahwZRhIr1kNQHDiABM+L/4ZnvsN7PkuWHIvLP0XHPYp6krquOGkG/jY/R/j4/d/nC8c/AXOnX3ukN4d5k+L/8RzG54D4LeLfsvPj/854dmzib+8aMi2ISJSzBZt9veHR088usCRiKiGj4gItSW1GAybOjcVOpSd6kh3AFtrJe1u8VdepenWW1l21lls+tGPabr1VqIHHIBbVph4hoPo3H1xKypof+yxXl8PuSFmVM7gxCknctzk45TsEVJr1uDW1uJEo/1b0Fp45jr466dg2jvg7Bugdja8+VB+lrGlY/nTqX9ifv18vvvf73LVs1fl9xv9lfWy3LfsPk6961RuX3o77al2/vTanzh20rGcO/tcnt3wLOlsmpJ584i/+CJeMjmg7YiIjCSvbnmVsmAZk8omFToUEdXwEREJOkFqo7Vs7NhY6FB2qquGT2mwdLduN9vewaarr6b5L38BwIRCbHltMQCVl1++W2MZbkwgQOyYd9D22ON4qRROaHj0ryTDV3rVakL9rd2TTcOdH4fX/gZ7nALn/B6CEZh0CCy9z08G5WryVEeq+fnxP+cHz/2AmxbfxOOrH+emU2+irqSuz5t7cs2T/P7V3+dr81z97NX8c/k/aUu18cn9PsmGjg3ctvQ2FjUsYtah82m88UbiL7xA6aGH9u99iYiMMK80vMLetXvjGNWtkMJTKRQRAcaWjGVj5/BP+OzuGj7WWtoefpjlZ55J8x13UP2xjzHtnr8x+6UXmXLLn5l0/XVUnHXWbollOCs//Qy8lhbaH3640KFIEUguW0Zo+vS+zdyxBZ78MfzsAD/Zc8L/g/ffCqFcP15j50DnFmjvWUPRMU6+L6mmZBMf/ddHuW/ZfTu9bXtnupOvPfU1PvXwp3ir+S0uP/By/n7m36mJ1vD8pue57MDLmFMzJ3+b4UUNiyg9+GCc0lKa77iz35+FiMhIkswmeaP5Dfap2afQoYgAquEjIgL4zSBWtKwodBg71dWx9O7ow8fr6GDNpZfS8e//EJoyhSk3/YmSgw7Kv15ywK69C1AxKT3sUIKTJtHw699QdtJJGNctdEgyTGWamsg2NBCeMWPnMy/5B9z1SUi1wbSj4bQfwR4n95xn7Bx/uOlVKBv7tlUcNPYgrj/xer7+9Ne54skruOb5a9i3bl9OmXoK+4/Zn9pobX7eDR0buPCBC1nZupKL5l7ExXMvJugGAfjHWf8gkUnkk8210VrGlY7j1YZXceZ8hMr3vY/GP/6R6o98hOi+OtERkdHp9cbXyXgZ5tTOKXQoIoASPiIigF/D55n1z2CtHdIOToda163jY6Fdm/DpfP551n3py6TXrGHs/32NqnPPxQT0k7E9xnUZ8z+Xs/Zzn2fzz65lzP9cXuiQZJhKvfUWAOFZM3c846pn4C8X+Amdd/8Cxm7nTnhjc8mVdS/CjON6neWAMQfwtzP/xn3L7+ORVY/w7PpnuX/F/QBMLZ/Kh/b+EDMqZ/D5xz5PMpvktyf9lkPGHQwrn/ZrDoVKCU48mGBJdY+mY3Nr57Jw40I861F7ycW03ncf6778JabdeSdOONzvz0ZEpNi9ssW/Y6Fq+MhwoaN3ERFgWsU0OtIdrO9Yz/jY+EKHs13t6VzCZwhr+NhMhuSbb5JasYLOZ58juWwZnf/9L8Hx45n8+99TOv+QIdvWSFb2zndS+Z9n2HL99TglJdR84uM7rOmTfPNNTDBIaMqU3RilFFrnCy8AEN5jD3j6Z4CF8gn+3bbWvQBV06Butn8nroqJcP6dULKDjr5LqqF6BqxduMPtOsbhXdPfxbumv4u0l+blzS/zSsMr3L/ifr79zLcBGF86nutPvJ7ZWQN/OB1WPLl1BcaFsnHQtsGP9z3XccykY3hg5QMsaljEfnX7Uf+db7P6wotY/5WvMv4H38c46jlAREaXFza+wJiSMYwrHVfoUESAIUz4ePE4LX/7G8nX36D0yCMoO673q0wiIsPRPrX+lZhXGl4Z3gmfVDsBEyDs9v/qubUWr6MDJxLJ19Zp+cc/2PyTn5Jes8afyRic8nJqP/Upqi+4ADe2ezuHLmbGGMb939fItrWx+Sc/oeXv91B+6qmEZ84kUFcHmQyZzZtJvvkmnS+8QOd/n6Xs5JOY+JOfFDp0GSLWWrLNzTihENZabCKBzXpkm5sI1NSQbWmh6aabiR50EMGV98CD/7d14WiV32yr4Q1Y9hhMPRLec92Okz1dJs7zl+lW+2ZHgk6Qg8YexEFjD+LDe3+YZzc8y6KGRZw68VjGP/YDePk2CJXBqT+EKUdAvAmWPQoNr0PFJL+p2R0XcMwnHyfshrnrjbvYr24/YkcdRd3//A+bf/ITgpMmMmaUd+guIqOLtZaFmxZy4JgDh3VtcRldhiTh0/L3e9n882tJr1yFCYVo+vOfqf3UJdReeqkKu4gUhT2q9iDgBFjUsIiTpp5U6HC2qz3dTiwU2+G+1UsmSa9ZQ3rDBryWFv/EM5Vmy/XXk1qxAoJBQpMnYxyH5BtvEN57L+q/+13cqipiRx0Jrqsr8wNkQiEm/OTHtJ5wAo1/+iMNP7v27TM5DuFZs6j5+Mep/tgFuz/IUczr6KDjmWeIHXfcoI5PvGSSbFMTqRUrSL7xJsk33vAfb76J19a2w2VNNMr4Oa3wzy/4d9s6Lpf0qZnp33UL/Dty5frO6ZMZx/tJmlfuhH3P6dd7McYwv34+8+vn+/0FvXwbHPZpOOIyiI3ZOuPUI7aO73MW/OY4yp78Ce+Z+R7ueOMOzt/rfGZVzaLmogtJr1nNluuuBwt1l1+mY0ERGRVeb3qdTZ2bOHjcwYUORSTP7OxuDTuz37hx9tbKKtyqKib86IeUHHII67/5TVruuJPyU99J9Uc/SnTu3CEKV0Rk17n4oYtZ2riU+8++n5A7PG+tfcUTV/Dy5pe576z7SLz6Gu2PPEJm8ybSmzaRXrMWr7OTzIYN/pX+bYSmT6fiPWfitbaRXL4MMlmi+82l5qKLhq6TYWth02JY/gQ0LoNUB1RPgymH+32NRMqHZjtFItveTmrFSrJNjZhAALeqitC0aerfpEAar72Sjb/4E8HacqJzZhOcOhW3oganogaMIduwAa+tBZtMYJMJvGQKr72NbHMz2dZ2su0dZNuT2FSmx3rdiCFckSFcniRYVwbhKiipxERLMYEwTiRAtrkFY1LEom8QZDMc9zU47DPgDsG1Ny8LvznOrx1UMx2S7WA9iFRAtBIilVBS4z93g+AEIRD2p5XUQGkttK6Fv3wUjvwfOOGbO9/mP6+A/17HlmO/zFkb/klpsJRfn/hrJpZNxGYybPh//4/mv9xB+WmnMe4bX8ctH13ffRldGuINlIfKh+2xg+we333mu9z5xp088t5HqIxUFjocGSGMMQuttfMGvPxgEz77T51qH/ziF6m96KJ8EwHreTT88lds+c1vsMkk0YMOovK951B+4ok4pWoeIIXlJZNkNjeQ2bSJzMYNZFtacCsqcCsqcMrKcSvKMZEITjiMiUQwoZCuTu5mmYbNrLv8EjJbmglPmUB4z70I7zWX4NSZhCZNxCkp6fc6vUTCP2lrasoPE4sXE1/4HMEJE6n73OdZyEoufOBC3jHxHVw490L2rtmboNOPq+y7mGc9TrnzFI7aUsv5D6ZJvPIKOA6Bmho/kTBlCk5JlOCkyYSmTCZYX49bUeEvm0gQ2XvvXXf3qNb18Pwf4MWboXmVPy1cDqEYtK3bOl9srN9HSdlYv8lIshU6G/1mKMEoBCI9h8Gof3KaSUAmCcbZOt0N+Set+WHYH4bLtp7khkrBCWw9yXWD4AyTO2gl2yDV2eudlWTXsIvuouXaL9O+LEm8MUgm7oLdZv9uLI5rMY7FuOAEPdyQhxv2cEPWH48Y3FiUUIVDqDZEYPwkTO0sv8y3rIamldCyxv8bpzv8chsug3AF1Mzwkz0TB3zs1ruWtfDA1yAdh3DM32a8GRLN/rBzCyRawEtvfx3VM+DCh/3mZV2fmbW0JjJsbkuyuS1JPJ2hpjTMnmPChO+5BF69m5fmfZBLWl8gkU1y7KRjOWriURw05iAif/4HDT+7Fre6mqoPvJ+yE04gPHOmahDuYsP95gMj0ecf+zzPb3qes2adxf51+zOzcia1JbXD6hhCdq3lLcs5+56zOW36aXz7iG8XOpwhYT0Pr62NbEsLicVLSK1YQe0nLyp0WKNOwRM+c+fsZf/y2x/2+pqNJ+DJZ7EPPw2btvgH9HU1MH4MVJRBSRRTEoWAC4EABAPguv58PR70Mq2vr3d7bUf68jnsdJYhWEef/h47mWeQf9M+r2O4fB7ZLLR1QGs7Nh6HdCb3SG8dT6WguQ1aWqEjvvN1bquinL3++9/+LycDkmptYO3J83HDHqnWAOnOnlfAjYv/3SZXhHoUE5Ob0PWdt/5Tr7ctWaI1aRLNQQg4BOZN58Vah8e95SQdD881xAKlVARKqQjEiDoRQiZAwAQIOAGMMdiufYsxgMEa659oQe41Px7TFYfFv/LuAXhY6/lNrqzFWg88i8VunY4/DWtpzrTRvGkNH3jcw40FiR42DnfuZLzyKv8dd30Y1ssNbX5o8LZ+WDYfCMbzMF4ax0vhZJM4XgqTTeWep7pNT/d4DeOQDlWQDpYTSm4hktiMxbCpdj7Lxp3CyvKD2RIchzFQmm2hvuUlqjtXUBFfSVnnGqKpLQSynWQCpSRDlRjAzSYJeAncbBI3m8D1kriZBI5Nk3XCeG4YrIebTeLYHZy07oTFYJ0AnhPEmgDW8R+eCebHrQlgjcHmC5vF2Kz/WdosWA9j/UKVitQQj9YTL5lAMjrGXy+O//e3FifrvycnG8fNJgik2yhtX0n1loU07XEutef9YsDvRfrnvkXr+fbfX2U8DUwyG6i2zVRlWqlMtWCA5mgNncEYWSeIZwJknBCeEyIeKCfhVpAIlmHdCK4bwHUNQcfgOg5B1+A6hqDrEHBM7jUH1zGEHA/HCWAcQybrkc5aMp4/jKeydKayJDNZoOeuzPMsqYxHMuPlhtn8eMazOAYcx+AYQ01piH0mVDC+Mko44JArev633FqsBS83tABeBieTJJRqIpJuJpJqAi/DstgBLG8zNLSnaO5MsaU9xeb2JKnM23egkaDDwZMruCx5PfMa/so6N8gNtfU8EHVoNv78JQSYvznG6Y/GmfhWBwCZSIB4TSnpWIRMeZRsSRgbDmJDwa1DxwHHAcc/frO5cWty0w2Aye93c/9tfZ7PJ219fXts91l7jmC79ts9FrDbTLLbrMhicscutsfLtmcY3Y5vehyLb++4x9rcPr5bbL0sE+hIUvPYi1R891vscfgpva9Lhtx/LjmPzjeW8kZlks4wJEKQCBqcUIiIGyEUDOO6QQK5h+MGMI6DcQM4rovBwTUOjvGHXeWwK3Fn8uW8+/St4375d/JlrOdy3Uue2Wa0ly9H17Lb/d70MZnYbQXbX6IPr+SPWcD/BTdbj6d6fBvt1uOgbgPT47vSbST3vTHbrCb//bUelm7HZIDFy+1Le05vzrTzcmI5WetxQdUJlNkgpNLYTBY8D7IeeB7Gdfz9U9ffzHq5UPI7bP+YL+vljuW6PkeT3x+CAc/z153N+vOmc9vpmt/k5gd/v7m9v3XX4XIqDZ0JbEccOhPQGYeOTogne+6TohFm//vfONFoL38x2VUKnvCZM7HMvvqJHV+psRbim0N0bAyTbA2Qag2QSTp4KQfr6QqEDB3/iqz/cHJD44DjWgLRLIGoRyCS9ccjHoGSLG7YI5srj9m0IZtysFmDzRo8z2CzkDBhJv1lWaHf3qjRHk/ykW/9Aouh1CSYmNrE1I6N1Hc2UN7RQTiVImA8TFciBXLjW3/YjfFf83DwrCEdDJAJB0iHAiTCITqCUZqiMdYExzCpYyPzX3oVd0P27Vf7h6FgTZrM0SGCQY9y00E5cbp+tbt/KjY/vu1zf9zLfWIpAiRtkBRBkgRJESBlc0O2DpO263mQAFkqTDsVdNBoy1lhx3Kvdxir7K6ordI9gedzyRIiTYgMIdKETW5ImhhxKkwHFXQQNUkCZAmQJUiWABmCJpMb75qe8Yema1oGF4uLh8HDxfPLEQ5ZnNxUJ/f5wRjTzAQaGGcaCZrsDt9J0gboIMIaW8cz3t5kZp/Opz70/l3wmUlvFqxo5LbnVudyqJastXi5ZIjnWX9oyY9nPEvW84eZrEfWs6Sz/rS05z/PZC3p/Gu5YW65rNf7MZbrGAKOoSTkUhIKEA44+SLeVdIdYwgHHUKuQzjgEgo4hAIO4YCfVMrHbS3rmhMs2dBKIt1rZrvPjIFx5RHGlIWpKg1RXRKirjxMXSxMXZk/jIZcNrYmeGZZI8+taGTZ5nbmZl7lMPdVZpk1jDGNtIfaWRlJsSZseTMYZHkoiNtm2Gs1zFpnqW2Big5LZQeUJiGc6pajkUFbVwUN5x/PuZ/+eaFDGTUWffhwyldsINkeIJMx2IzB0TmO7GpOrjaq4x/35ln/OK9bnqx3Xb87Tq72asjihHK1Wrs/D3qEyjM4VRD5dsOufEfSi4InfPads5e9+fofDHwFmYz/6KqJkc1dmfa2Xpmm64DJ2rc9TI/Xva3Z0d4eO63e2ocd805nGYJ19KEart3ZSoaiKm9f1rE7Po+dzeA42LISKCuD0K6pOuu4QfY9bPh25DvSeJ5lVWNn/uTL5obZfO0Xfz7/gsjWq9ZdV7C32uY6bG8XebpNN+k4gbWv4yQ6MOkEpFOYTCq/r/FPELNkvBSpbIp8taFu+yHTtR/C23qJHbpdiTa5K9TGvypnHIzj+lesHBfHcXBwwPi1A3BcjDE4xvVrjESiJGYcjA1vvS276b6JHlO2Ttv2ql9vy5leluvt+dYrjD1fc40hEnQJBxzCuaG1kLX+iW/X37HrJLVrV9/13ObH6THvtn8n2Hp1u7cL492vfG/7E7fTdeTn29okoquiaG/vvcfn4Hm4iUYcMvlaVQaDDUSxwQjWjWByzclM7mpbeSTAmPIIMjJ5np9UymT9fVfA8ZM1jjP0J4JZz9KezJBMZ/0Uaa42gH+h13Sr8GzyFaAds/V1gIBjCLj9S71Ya2nqTNMaT5PpSpTlkmKZTBKTaCGbSkI2RTrTRjzdSsam8bwMWTJkbRbPy2JTKWw8gUklMZ4FL+sPbbdxr1vtxa6HH0X+uNF25Ye7v5az9Xyoa2ex9Tu+zZvaWsth69JbX+5RYeLtOwOz7RrzO5Ht71hNt+fWdJu2bSpsJ9u2wQDhyXty4D7HUl1Zte07k13kzddeoKN5s1/7EwDr1zRPpTBe1u9nK1fLI//Ien6TmWzK/520Wf/7gJervGLztfS6/WLla+3ljoD8qfl57NblYGstEej+VehaU26k93NB08v07Z037vBsst/L2K3XebapnWTpdj5nus6H/B2a7fryd6/NYrrV78l/v7at5dT9iT/B69ovGv+YzK9F5eCQO27LvwYYlzK3lJDTrW++UBCCIbxArvWK64Jxtu7DstavuYiTr4mDk0vQuI7/cBz/Ep3N7ftyf3M8m5vH7XahYNu/Zc/h2/Z928xvtjM9/8l0zecY5h52MrJ7FTzhM2/ePLtgwYJBrUNERERERERERLYabMJHNWhFREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYJXxEREREREREREYYY60d3AqM2Qx0AA1DEpHI8FSLyriMfCrnMhqonMtooHIuo4HKuYx0tUCptbZuoCsYdMIHwBizwFo7b9ArEhmmVMZlNFA5l9FA5VxGA5VzGQ1UzmWkG4oyriZdIiIiIiIiIiIjjBI+IiIiIiIiIiIjzFAlfH49ROsRGa5UxmU0UDmX0UDlXEYDlXMZDVTOZaQbdBkfkj58RERERERERERk+FCTLhERERERERGREWanCR9jzCRjzKPGmNeMMa8aYy7LTX9v7rlnjJm3zTJfNsa8aYxZaow5eVcFLzJU+lvOjTFTjTFxY8yLucd1hYtepG92UM5/YIxZYox52RhztzGmstsy2p9L0ehvGde+XIrRDsr5t3Nl/EVjzAPGmPG56cYY87PcvvxlY8yBhX0HIjs3gHJ+jDGmpdv+/OuFfQciO7e9ct7t9c8bY6wxpjb3vN/785026TLG1AP11trnjTFlwELgTMACHnA98L/W2gW5+fcGbgEOAcYDDwF7WGuz/Xv7IrvPAMr5VOBea+0+hYlYpP92UM4nAo9YazPGmKsBrLVXaH8uxWYAZXwq2pdLkdlBOV9jrW3NzfNZYG9r7cXGmFOBS4FTgfnANdba+YWJXqRvBlDOj8E/Vn9XgUIW6bftlXNr7WvGmEnAb4E9gYOstQ0D2Z/vtIaPtXa9tfb53HgbsBiYYK1dbK1d2ssi7wZutdYmrbXLgTfxTxZEhq0BlHORorODcv6AtTaTm+0Z/JNj0P5ciswAyrhI0dlBOW/tNlsp/kUr8Pflf7S+Z4DK3EmGyLA1gHIuUnS2V85zL/8E+CI9y3i/9+f96sMndyXsAOC/O5htArC62/M13YIWGfb6WM4BphljXjDGPG6MOWrXRyYydHZQzj8G/DM3rv25FK0+lnHQvlyK2Lbl3BjzXWPMauCDQFeTFu3Lpaj1sZwDHGaMeckY809jzJzdH6nIwHUv58aYdwNrrbUvbTNbv/fnfU74GGNiwJ3A5dtkVkVGjH6U8/XAZGvtAcDngD8bY8p3R4wig7W9cm6M+SqQAW4uVGwiQ6EfZVz7cilavZVza+1XrbWT8Mv4ZwoZn8hQ6Ec5fx6YYq3dD7gW+GsBwhUZkO7lHP845Sv0TGYOWJ8SPsaYYC6Am621d+1k9rXApG7PJ+amiQxr/SnnuSYuW3LjC4G3gD12fZQig7O9cm6M+SjwLuCDdmvnbtqfS9HpTxnXvlyKVR+OWW4Gzs6Na18uRak/5dxa22qtbc+N3wcEuzq6FRnOeinnM4BpwEvGmBX4++znjTHjGMD+vC936TLADcBia+2P+xDzPcB5xpiwMWYaMAt4tg/LiRRMf8u5MabOGOPmxqfjl/NluzZKkcHZXjk3xpyC30b4DGttZ7dFtD+XotLfMq59uRSjHZTzWd1mezewJDd+D/Dh3N1dDgVarLXrd1vAIgPQ33JujBmXWwZjzCH457lbdl/EIv3XWzm31i6y1o6x1k611k7Fb7Z1oLV2AwPYnwf6EMcRwIeARcaYF3PTvgKE8avL1QH/MMa8aK092Vr7qjHmduA1/OpIn9YdXaQI9KucA0cD3zLGpPHv4nWxtbZx94ct0i/bK+c/wy/rD+aOlZ6x1l6s/bkUoX6VcbQvl+K0vXL+cWPMbPyyvBK4OPfaffh3dHkT6AQu2K3RigxMf8v5OcAlxpgMEAfO61ZjWWS46rWc52qp9abf+/Od3pZdRERERERERESKS7/u0iUiIiIiIiIiIsOfEj4iIiIiIiIiIiOMEj4iIiIiIiIiIiOMEj4iIiIiIiIiIiOMEj4iIiIiIiIiIiOMEj4iIiJStIwxNcaYF3OPDcaYtbnxdmPMLwsdn4iIiEih6LbsIiIiMiIYY74JtFtrf1joWEREREQKTTV8REREZMQxxhxjjLk3N/5NY8wfjDFPGmNWGmPOMsZ83xizyBjzL2NMMDffQcaYx40xC40x9xtj6gv7LkREREQGTgkfERERGQ1mAMcBZwA3AY9aa/cF4sBpuaTPtcA51tqDgN8B3y1UsCIiIiKDFSh0ACIiIiK7wT+ttWljzCLABf6Vm74ImArMBvYBHjTGkJtnfQHiFBERERkSSviIiIjIaJAEsNZ6xpi03dqJoYd/PGSAV621hxUqQBEREZGhpCZdIiIiIrAUqDPGHAZgjAkaY+YUOCYRERGRAVPCR0REREY9a20KOAe42hjzEvAicHhBgxIREREZBN2WXURERERERERkhFENHxERERERERGREUYJHxERERERERGREUYJHxERERERERGREUYJHxERERERERGREUYJHxERERERERGREUYJHxERERERERGREUYJHxERERERERGREUYJHxERERERERGREeb/A0KZQ28YdpupAAAAAElFTkSuQmCC", - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "Inference('pyannote/segmentation', use_auth_token=True, step=2.5)(test_file)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_file[\"annotation\"]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's update the model so that it specifically addresses overlapped speech detection. \n", - "This is achieved very simply by updating the `task` attribute..." - ] - }, - { - "cell_type": "code", - "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\", use_auth_token=True)\n", - "osd_model.task = osd_task" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... optionally freeezing a bunch of layers..." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['sincnet',\n", - " 'sincnet.wav_norm1d',\n", - " 'sincnet.conv1d',\n", - " 'sincnet.conv1d.0',\n", - " 'sincnet.conv1d.0.filterbank',\n", - " 'sincnet.conv1d.1',\n", - " 'sincnet.conv1d.2',\n", - " 'sincnet.pool1d',\n", - " 'sincnet.pool1d.0',\n", - " 'sincnet.pool1d.1',\n", - " 'sincnet.pool1d.2',\n", - " 'sincnet.norm1d',\n", - " 'sincnet.norm1d.0',\n", - " 'sincnet.norm1d.1',\n", - " 'sincnet.norm1d.2',\n", - " 'lstm']" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "osd_model.freeze_up_to('lstm')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... and training it:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\n", - " | Name | Type | Params | In sizes | Out sizes \n", - "-------------------------------------------------------------------------------------------------------------------\n", - "0 | sincnet | SincNet | 42.6 K | [32, 1, 32000] | [32, 60, 115] \n", - "1 | lstm | LSTM | 1.4 M | [32, 115, 60] | [[32, 115, 256], [[8, 32, 128], [8, 32, 128]]]\n", - "2 | linear | ModuleList | 49.4 K | ? | ? \n", - "3 | classifier | Linear | 129 | [32, 115, 128] | [32, 115, 1] \n", - "4 | activation | Sigmoid | 0 | [32, 115, 1] | [32, 115, 1] \n", - "5 | validation_metric | AUROC | 0 | ? | ? \n", - "-------------------------------------------------------------------------------------------------------------------\n", - "49.5 K Trainable params\n", - "1.4 M Non-trainable params\n", - "1.5 M Total params\n", - "5.890 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validation sanity check'), FloatProgress(value=1.0, bar_style='info', layout=Layout…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "17ca908b800f4d34841bc2c7d5ccdff3", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Training'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\", max_epochs=1)\n", - "trainer.fit(osd_model)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Et voilà! A brand new overlapped speech detection model!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.audio.utils.signal import binarize\n", - "binarize(Inference(osd_model)(test_file))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_file[\"annotation\"]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Going further\n", - "\n", - "This tutorial only scratched the surface of the training API.\n", - "\n", - "Every task supports an `augmentation` parameter for training with data augmentation via [`torch-audiomentations`](https://github.com/asteroid-team/torch-audiomentations) library:\n", - "\n", - "```python\n", - "from torch_audiomentations import AddBackgroundNoise\n", - "augmentation = AddBackgroundNoise(\"/path/to/background/noise/directory\")\n", - "vad_task = VoiceActivityDetection(ami, augmentation=augmentation)\n", - "```\n", - "\n", - "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(devices=4, accelerator=\"gpu\", strategy='ddp')\n", - "trainer.fit(model)\n", - "```\n", - "\n", - "Default optimizer (`Adam` with default parameters) is automatically set up for you. \n", - "Customizing optimizer (and scheduler) requires overriding [`model.configure_optimizers`](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.core.lightning.html#pytorch_lightning.core.lightning.LightningModule.configure_optimizers) method:\n", - "\n", - "```python\n", - "from types import MethodType\n", - "from torch.optim import SGD\n", - "from torch.optim.lr_scheduler import ExponentialLR\n", - "def configure_optimizers(self):\n", - " return {\"optimizer\": SGD(self.parameters()),\n", - " \"lr_scheduler\": ExponentialLR(optimizer, 0.9)}\n", - "model.configure_optimizers = MethodType(configure_optimizers, model)\n", - "trainer.fit(model)\n", - "```" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{"cells":[{"cell_type":"markdown","metadata":{},"source":["\"Open"]},{"cell_type":"markdown","metadata":{},"source":["\n","# Training, fine-tuning, and transfer learning with pyannote.audio\n","\n","In this tutorial, you will learn how to use pyannote.audio to\n","\n","- train a voice activity detection model from scratch,\n","- fine-tune a pretrained speaker segmentation model,\n","- perform transfer learning (from speaker segmentation to overlapped speech detection)\n"]},{"cell_type":"markdown","metadata":{},"source":["## Tutorial setup"]},{"cell_type":"markdown","metadata":{"id":"72ECjKLknm8D"},"source":["### `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"mBBNyENbofJ4"},"source":["If you are running this tutorial on `Colab`, execute the following commands in order to setup `Colab` environment. These commands will install `pyannote.audio` and download a mini version of the `AMI` corpus."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":68165,"status":"ok","timestamp":1704810976973,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"Luhkk8D4oiir","outputId":"7f43b6e3-8dba-40c1-a9e9-5b3ae4ddc891"},"outputs":[],"source":["!pip install -qq pyannote.audio==3.1.1\n","!pip install -qq ipython==7.34.0\n","!git clone https://github.com/pyannote/AMI-diarization-setup.git\n","%cd ./AMI-diarization-setup/pyannote/\n","!bash ./download_ami_mini.sh\n","%cd /content"]},{"cell_type":"markdown","metadata":{"id":"VWo84u4ypEMc"},"source":["⚠ Restart the runtime (Runtime > Restart session)."]},{"cell_type":"markdown","metadata":{"id":"zmnD8CUUnt1N"},"source":["### Non `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"HS7SxeZkoth1"},"source":["If you are not using `Colab`, this tutorial assumes that\n","* `pyannote.audio` has been installed\n","* the [AMI corpus](https://groups.inf.ed.ac.uk/ami/corpus/) has already been [setup for use with `pyannote`](https://github.com/pyannote/AMI-diarization-setup/tree/main/pyannote)\n"]},{"cell_type":"code","execution_count":1,"metadata":{"executionInfo":{"elapsed":810,"status":"ok","timestamp":1704811019354,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"67whHDb3pOIe"},"outputs":[],"source":["# preparing notebook for visualization purposes\n","# (only show outputs between t=180s and t=240s)\n","from pyannote.core import notebook, Segment\n","notebook.crop = Segment(210, 240)"]},{"cell_type":"markdown","metadata":{"id":"z4-LIYSEnj5i"},"source":["## Data preparation\n","\n","See [`pyannote.database` documentation](https://github.com/pyannote/pyannote-database#pyannote-database) to learn how to prepare your own dataset for training with `pyannote.audio`."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"8vw0KmndnX8L"},"outputs":[],"source":["from pyannote.database import registry, FileFinder\n","\n","registry.load_database(\"AMI-diarization-setup/pyannote/database.yml\")\n","ami = registry.get_protocol('AMI.SpeakerDiarization.mini')"]},{"cell_type":"markdown","metadata":{"id":"69qydyg6nX8M"},"source":["## Training a voice activity detection model from scratch"]},{"cell_type":"markdown","metadata":{"id":"l0-I4_ApnX8N"},"source":["Voice activity detection (VAD) is the task of detecting speech regions in a given audio stream or recording.\n","\n","We initialize a VAD *task* that describes how the model will be trained:\n","\n","* `ami` indicates that we will use files available in `ami.train()`.\n","* `duration=2.` and `batch_size=128` indicates that the model will ingest batches of 128 two seconds long audio chunks."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"lFDktlSDnX8O"},"outputs":[],"source":["from pyannote.audio.tasks import VoiceActivityDetection\n","vad_task = VoiceActivityDetection(ami, duration=2.0, batch_size=128)"]},{"cell_type":"markdown","metadata":{"id":"EZ0Kje3RnX8Q"},"source":["We initialize one *model* with the `PyanNet` architecture used [in that paper](https://arxiv.org/abs/2104.04045). \n","In particular, we increase the default stride of the initial `sincnet` feature extraction layer to `10`.\n","\n","The model is also provided with the task (`task=vad_task`) for which it is being trained:"]},{"cell_type":"code","execution_count":4,"metadata":{"executionInfo":{"elapsed":226,"status":"ok","timestamp":1704811118255,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"kSfY8Y3fnX8R"},"outputs":[],"source":["from pyannote.audio.models.segmentation import PyanNet\n","vad_model = PyanNet(task=vad_task, sincnet={'stride': 10})"]},{"cell_type":"markdown","metadata":{"id":"WCNd35YInX8T"},"source":["Now that everything is ready, let's train with `pytorch-ligthning`!"]},{"cell_type":"code","execution_count":5,"metadata":{"id":"ExlUZ6DonX8U"},"outputs":[{"name":"stderr","output_type":"stream","text":["GPU available: False, 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 | sincnet | SincNet | 42.6 K | [1, 1, 32000] | [1, 60, 115] \n","1 | lstm | LSTM | 589 K | [1, 115, 60] | [[1, 115, 256], [[4, 1, 128], [4, 1, 128]]]\n","2 | linear | ModuleList | 49.4 K | ? | ? \n","3 | classifier | Linear | 129 | [1, 115, 128] | [1, 115, 1] \n","4 | activation | Sigmoid | 0 | [1, 115, 1] | [1, 115, 1] \n","5 | validation_metric | MetricCollection | 0 | ? | ? \n","---------------------------------------------------------------------------------------------------------------------\n","681 K Trainable params\n","0 Non-trainable params\n","681 K Total params\n","2.728 Total estimated model params size (MB)\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"766125242dd74f4bbd958c0488de0aeb","version_major":2,"version_minor":0},"text/plain":["Sanity Checking: | | 0/? [00:00"]},"execution_count":7,"metadata":{},"output_type":"execute_result"}],"source":["from pyannote.audio import Inference\n","vad = Inference(vad_model)\n","\n","vad_probability = vad(test_file)\n","vad_probability"]},{"cell_type":"markdown","metadata":{"id":"vYf27Tg9nX8Z"},"source":["Perfect voice activity detection output should look like that:"]},{"cell_type":"code","execution_count":8,"metadata":{"id":"DRX0bew-nX8Z","outputId":"77b43b35-ba67-4189-c588-43396ee49366"},"outputs":[{"data":{"image/png":"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","text/plain":[", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>"]},"execution_count":8,"metadata":{},"output_type":"execute_result"}],"source":["expected_output = test_file[\"annotation\"].get_timeline().support()\n","expected_output"]},{"cell_type":"markdown","metadata":{"id":"dzNs5vrUnX8a"},"source":["## Fine-tuning a pretrained speaker segmentation model\n","\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://huggingface.co/pyannote/segmentation-3.0) is a model that was pretrained to perform speaker diarization, but only locally, on 10s-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-3.0).\n","* login using `notebook_login` below"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145,"referenced_widgets":["0c403a6fbba048a9a5388b71a0d83259","b906b2359fa84291b3b78bcced4f3028","8f7afdee0292401181bd477a89ee3069","05b307b893b84133a376088787ababac","c258b47039a243cabadd48de545542f2","15ab3c58a6014beb9c7ba5e3f5bc0b77","df65aff406cc4288806b278cf83fb7df","31f30fd568f84363b8dea2d40f54885c","f383e9d323c64c64b528266858d6595c","772e6eb169d84fcb808957fd886a59d1","dcf595ee01a248f895635ad054c8ce28","385eecea5fca4494be7a0e2dc34110ca","c742508bbe1e4f0f9ad385896afea5eb","e7aa7e431546419792ff998e10c4bbe9","0e04e5e88aae4f14838356c422ba7ed5","20ba5327eef34c7fa20f9f247b9042b1","cc9cc24a3aea416a99897cf0c617f225","98b09e7bb5d14a9d8c85e52f54c9c6cf","50ed1cf2997e4929853964103bb7552c","4bf2285d01ca4f6c86a117f73972c7e7","d1063e27f20648ff9a43fede902a08a4","3b133fae87364dcc89a34ed147995807","e50f15a31e4543219ed038b88132d905","6b641f7304e943d7b53466fc5aa376a2","8865c7d7d01040329de63b6a13e0fdff","3e816698f9f54bc28712b7e0a1f1dba5","bd36d10136344d4b9965557a8783c5f1","d1f2777676bf4237947a0e42ff7da6de","245a4232482547579a72d10243664849","d072771073ed479b8e16cd9e5b9262c7","bf24ab0141ce423393972b66c6d09f94","bd2757c3b84f4ec283b083d64ea52d7a"]},"executionInfo":{"elapsed":362,"status":"ok","timestamp":1704811300494,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"peG_1xclnX8b","outputId":"3befc3a8-d54c-4a4b-9b40-2ce1229eeaa5"},"outputs":[],"source":["from huggingface_hub import notebook_login\n","notebook_login()"]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":81,"referenced_widgets":["84262babb03c4f7dab14b35637e29c31","35f0b383bafc4425a27f36bc95874430","f3d067b1a56849c19c933fb3380386b6","5fb8f440470f4492a5a7a009760a0926","c8348fafe0de405da831284cb39af5cc","b3a67d2e0c14492788806bb221761174","2f70dbe63df14dd18224e2bcb35b6e38","0f59d4fccfc045b89337b4b4254de7c3","c3204d520d604179923e93e0a9bfd395","1cc4aeb271f4441d83c3227a0fef607e","dd4a788ac0cb44ce93b6c001449d5d45","bcccc0031f7245a394abc3aee4a6e1c2","69c5b722ba3746aa80d87b3ee9fea08e","ef96f5501bbb4a55b3aedac70d1261b5","2d26c7ece1fe40178ab85f3d14408532","693fc1fa7fd746ce8a089f3fd6683b51","fd5fe3ad4e43456c896ca45ff6a6f155","b92e36c0853f40738b51b8ef39f0377d","8336d24b72414718b82c3195897ee896","469ce1b8998a4d998d42fbea5f431781","e7045e323ec947b3b354ffc61365f4cd","b86e1bdb52414bfab9798b661e3e096d"]},"executionInfo":{"elapsed":3764,"status":"ok","timestamp":1704811326591,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"wO1fXdA9nX8c","outputId":"5933da6e-d984-4ab1-9041-62b3d9c5a909"},"outputs":[],"source":["from pyannote.audio import Model\n","pretrained = Model.from_pretrained(\"pyannote/segmentation-3.0\", use_auth_token=True)"]},{"cell_type":"markdown","metadata":{"id":"zm1-d-IsnX8d"},"source":["Let's visualize how it performs on our test file:"]},{"cell_type":"code","execution_count":11,"metadata":{"id":"beFpRrN-nX8d"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":11,"metadata":{},"output_type":"execute_result"}],"source":["spk_probability = Inference(pretrained, step=2.5)(test_file)\n","spk_probability"]},{"cell_type":"markdown","metadata":{"id":"hrJ9pDbTnX8e"},"source":["A perfect output would look like that:"]},{"cell_type":"code","execution_count":12,"metadata":{"id":"bLcE98G4nX8f","outputId":"7bb6ed3d-8076-4ebf-fa89-95a8c5943d27"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":12,"metadata":{},"output_type":"execute_result"}],"source":["test_file[\"annotation\"].discretize(notebook.crop, resolution=0.010)"]},{"cell_type":"markdown","metadata":{"id":"9DY3NIY5nX8f"},"source":["We are going to fine-tune this pretrained model on the AMI dataset:"]},{"cell_type":"code","execution_count":13,"metadata":{"executionInfo":{"elapsed":1183,"status":"ok","timestamp":1704811457994,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"GJ2BWqqknX8g"},"outputs":[],"source":["from pyannote.audio.tasks import SpeakerDiarization\n","seg_task = SpeakerDiarization(ami, duration=10.0, max_speakers_per_chunk=3, max_speakers_per_frame=2)"]},{"cell_type":"markdown","metadata":{"id":"y6e77EJ-nX8g"},"source":["To check that fine-tuning was actually helpful, we need to evaluate the performance of the pretrained model, and compute the average local diarization error rate on a 10s window sliding over the whole test set. To do so, we need to create a helper function:"]},{"cell_type":"code","execution_count":14,"metadata":{"id":"XxJs0DtCnX8h"},"outputs":[],"source":["def test(model, protocol, subset=\"test\"):\n"," from pyannote.audio.utils.signal import binarize\n"," from pyannote.audio.utils.metric import DiscreteDiarizationErrorRate\n"," from pyannote.audio.pipelines.utils import get_devices\n","\n"," (device,) = get_devices(needs=1)\n"," metric = DiscreteDiarizationErrorRate()\n"," files = list(getattr(protocol, subset)())\n","\n"," inference = Inference(model, device=device)\n","\n"," for file in files:\n"," reference = file[\"annotation\"]\n"," hypothesis = binarize(inference(file))\n"," uem = file[\"annotated\"]\n"," _ = metric(reference, hypothesis, uem=uem)\n","\n"," return abs(metric)"]},{"cell_type":"markdown","metadata":{"id":"Nkdm0dR0nX8h"},"source":["We can then evaluate the model and see its local DER:"]},{"cell_type":"code","execution_count":15,"metadata":{"id":"LH0CGdmnnX8i","outputId":"b07ba927-6f23-403a-d70b-74cf8685df06"},"outputs":[{"name":"stdout","output_type":"stream","text":["Local DER (pretrained) = 19.7%\n"]}],"source":["der_pretrained = test(model=pretrained, protocol=ami, subset=\"test\")\n","print(f\"Local DER (pretrained) = {der_pretrained * 100:.1f}%\")"]},{"cell_type":"markdown","metadata":{"id":"qUCdup8QnX8i"},"source":["Next, we prepare the model for fine-tuning, simply by overriding its `task` attribute..."]},{"cell_type":"code","execution_count":16,"metadata":{"id":"5i5Bv-7enX8j"},"outputs":[],"source":["from copy import deepcopy\n","finetuned = deepcopy(pretrained)\n","finetuned.task = seg_task"]},{"cell_type":"markdown","metadata":{"id":"nDPEYDZKnX8j"},"source":["... and we train it (for just one epoch)"]},{"cell_type":"code","execution_count":17,"metadata":{"colab":{"referenced_widgets":["","634877439d6744d88223cfd1313e5fc1"]},"id":"AIUsJ3MqnX8k","outputId":"6078a5dd-5cb2-4780-db4e-e3516d1cce8e"},"outputs":[{"name":"stderr","output_type":"stream","text":["GPU available: False, 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"]},{"name":"stderr","output_type":"stream","text":["\n"," | Name | Type | Params | In sizes | Out sizes \n","----------------------------------------------------------------------------------------------------------------------\n","0 | sincnet | SincNet | 42.6 K | [1, 1, 160000] | [1, 60, 589] \n","1 | lstm | LSTM | 1.4 M | [1, 589, 60] | [[1, 589, 256], [[8, 1, 128], [8, 1, 128]]]\n","2 | linear | ModuleList | 49.4 K | ? | ? \n","3 | classifier | Linear | 903 | [1, 589, 128] | [1, 589, 7] \n","4 | activation | LogSoftmax | 0 | [1, 589, 7] | [1, 589, 7] \n","5 | powerset | Powerset | 0 | ? | ? \n","6 | validation_metric | MetricCollection | 0 | ? | ? \n","----------------------------------------------------------------------------------------------------------------------\n","1.5 M Trainable params\n","0 Non-trainable params\n","1.5 M Total params\n","5.893 Total estimated model params size (MB)\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"fc1c93f0b95649b1ae7a7135c9c04d62","version_major":2,"version_minor":0},"text/plain":["Sanity Checking: | | 0/? [00:00"]},"execution_count":19,"metadata":{},"output_type":"execute_result"}],"source":["Inference('pyannote/segmentation-3.0', use_auth_token=True, step=2.5)(test_file)"]},{"cell_type":"code","execution_count":20,"metadata":{"id":"DvpRY7H1nX82","outputId":"ce284d08-e0f1-4a58-da1e-0b7c62fa2f31"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":20,"metadata":{},"output_type":"execute_result"}],"source":["test_file[\"annotation\"]"]},{"cell_type":"markdown","metadata":{"id":"hjw4nIE7nX83"},"source":["Let's update the model so that it specifically addresses overlapped speech detection. \n","This is achieved very simply by updating the `task` attribute..."]},{"cell_type":"code","execution_count":21,"metadata":{"id":"xhmDk1qJnX83"},"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-3.0\", use_auth_token=True)\n","osd_model.task = osd_task"]},{"cell_type":"markdown","metadata":{"id":"wbb0MeQanX84"},"source":["... optionally freeezing a bunch of layers..."]},{"cell_type":"code","execution_count":22,"metadata":{"id":"tuE1xNjunX84","outputId":"2211d836-8bda-4550-a5e2-7646c764c0af"},"outputs":[{"data":{"text/plain":["['sincnet',\n"," 'sincnet.wav_norm1d',\n"," 'sincnet.conv1d',\n"," 'sincnet.conv1d.0',\n"," 'sincnet.conv1d.0.filterbank',\n"," 'sincnet.conv1d.1',\n"," 'sincnet.conv1d.2',\n"," 'sincnet.pool1d',\n"," 'sincnet.pool1d.0',\n"," 'sincnet.pool1d.1',\n"," 'sincnet.pool1d.2',\n"," 'sincnet.norm1d',\n"," 'sincnet.norm1d.0',\n"," 'sincnet.norm1d.1',\n"," 'sincnet.norm1d.2',\n"," 'lstm']"]},"execution_count":22,"metadata":{},"output_type":"execute_result"}],"source":["osd_model.freeze_up_to('lstm')"]},{"cell_type":"markdown","metadata":{"id":"DrKqQyXonX85"},"source":["... and training it:"]},{"cell_type":"code","execution_count":23,"metadata":{"colab":{"referenced_widgets":["","17ca908b800f4d34841bc2c7d5ccdff3"]},"id":"z9PIQ4oUnX85","outputId":"ed98a898-d9a2-4895-d523-9660abf79f1e"},"outputs":[{"name":"stderr","output_type":"stream","text":["GPU available: False, 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"]},{"name":"stderr","output_type":"stream","text":["\n"," | Name | Type | Params | In sizes | Out sizes \n","---------------------------------------------------------------------------------------------------------------------\n","0 | sincnet | SincNet | 42.6 K | [1, 1, 32000] | [1, 60, 115] \n","1 | lstm | LSTM | 1.4 M | [1, 115, 60] | [[1, 115, 256], [[8, 1, 128], [8, 1, 128]]]\n","2 | linear | ModuleList | 49.4 K | ? | ? \n","3 | classifier | Linear | 129 | [1, 115, 128] | [1, 115, 1] \n","4 | activation | Sigmoid | 0 | [1, 115, 1] | [1, 115, 1] \n","5 | validation_metric | MetricCollection | 0 | ? | ? \n","---------------------------------------------------------------------------------------------------------------------\n","49.5 K Trainable params\n","1.4 M Non-trainable params\n","1.5 M Total params\n","5.890 Total estimated model params size (MB)\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"7a9dfccd597f477bb2990e2746433375","version_major":2,"version_minor":0},"text/plain":["Sanity Checking: | | 0/? [00:00"]},"execution_count":24,"metadata":{},"output_type":"execute_result"}],"source":["from pyannote.audio.utils.signal import binarize\n","binarize(Inference(osd_model)(test_file))"]},{"cell_type":"code","execution_count":25,"metadata":{"id":"P_7CB2wgnX87","outputId":"a5e3a05f-8695-4880-9380-fbde264ca06f"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":25,"metadata":{},"output_type":"execute_result"}],"source":["test_file[\"annotation\"]"]},{"cell_type":"markdown","metadata":{"id":"A4OM7DzwnX88"},"source":["## Going further\n","\n","This tutorial only scratched the surface of the training API.\n","\n","Every task supports an `augmentation` parameter for training with data augmentation via [`torch-audiomentations`](https://github.com/asteroid-team/torch-audiomentations) library:\n","\n","```python\n","from torch_audiomentations import AddBackgroundNoise\n","augmentation = AddBackgroundNoise(\"/path/to/background/noise/directory\")\n","vad_task = VoiceActivityDetection(ami, augmentation=augmentation)\n","```\n","\n","We also benefit from all the nice things [`pytorch-lightning`](https://lightning.ai/docs/pytorch/stable/) has to offer (like multi-gpu training, for instance).\n","\n","```python\n","trainer = Trainer(devices=4, accelerator=\"gpu\", strategy='ddp')\n","trainer.fit(model)\n","```\n","\n","Default optimizer (`Adam` with default parameters) is automatically set up for you. \n","Customizing optimizer (and scheduler) requires overriding [`model.configure_optimizers`](https://lightning.ai/docs/pytorch/stable/common/lightning_module.html#configure-optimizers) method:\n","\n","```python\n","from types import MethodType\n","from torch.optim import SGD\n","from torch.optim.lr_scheduler import ExponentialLR\n","def configure_optimizers(self):\n"," return {\"optimizer\": SGD(self.parameters()),\n"," \"lr_scheduler\": ExponentialLR(optimizer, 0.9)}\n","model.configure_optimizers = MethodType(configure_optimizers, model)\n","trainer.fit(model)\n","```"]}],"metadata":{"accelerator":"GPU","colab":{"gpuType":"T4","provenance":[]},"kernelspec":{"display_name":"Python 3","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.10.13"},"widgets":{"application/vnd.jupyter.widget-state+json":{"05b307b893b84133a376088787ababac":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"CheckboxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"CheckboxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"CheckboxView","description":"Add token as git credential?","description_tooltip":null,"disabled":false,"indent":true,"layout":"IPY_MODEL_385eecea5fca4494be7a0e2dc34110ca","style":"IPY_MODEL_c742508bbe1e4f0f9ad385896afea5eb","value":true}},"0c403a6fbba048a9a5388b71a0d83259":{"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_d1063e27f20648ff9a43fede902a08a4","IPY_MODEL_3b133fae87364dcc89a34ed147995807","IPY_MODEL_e50f15a31e4543219ed038b88132d905","IPY_MODEL_6b641f7304e943d7b53466fc5aa376a2"],"layout":"IPY_MODEL_df65aff406cc4288806b278cf83fb7df"}},"0e04e5e88aae4f14838356c422ba7ed5":{"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":""}},"0f59d4fccfc045b89337b4b4254de7c3":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"15ab3c58a6014beb9c7ba5e3f5bc0b77":{"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_20ba5327eef34c7fa20f9f247b9042b1","placeholder":"​","style":"IPY_MODEL_cc9cc24a3aea416a99897cf0c617f225","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. "}},"1cc4aeb271f4441d83c3227a0fef607e":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"20ba5327eef34c7fa20f9f247b9042b1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"245a4232482547579a72d10243664849":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"2d26c7ece1fe40178ab85f3d14408532":{"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_e7045e323ec947b3b354ffc61365f4cd","placeholder":"​","style":"IPY_MODEL_b86e1bdb52414bfab9798b661e3e096d","value":" 399/399 [00:00<00:00, 22.1kB/s]"}},"2f70dbe63df14dd18224e2bcb35b6e38":{"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":""}},"31f30fd568f84363b8dea2d40f54885c":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"35f0b383bafc4425a27f36bc95874430":{"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_b3a67d2e0c14492788806bb221761174","placeholder":"​","style":"IPY_MODEL_2f70dbe63df14dd18224e2bcb35b6e38","value":"pytorch_model.bin: 100%"}},"385eecea5fca4494be7a0e2dc34110ca":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"3b133fae87364dcc89a34ed147995807":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_bd36d10136344d4b9965557a8783c5f1","placeholder":"​","style":"IPY_MODEL_d1f2777676bf4237947a0e42ff7da6de","value":"Your token has been saved in your configured git credential helpers (store)."}},"3e816698f9f54bc28712b7e0a1f1dba5":{"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":""}},"469ce1b8998a4d998d42fbea5f431781":{"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":""}},"4bf2285d01ca4f6c86a117f73972c7e7":{"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":""}},"50ed1cf2997e4929853964103bb7552c":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"5fb8f440470f4492a5a7a009760a0926":{"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_1cc4aeb271f4441d83c3227a0fef607e","placeholder":"​","style":"IPY_MODEL_dd4a788ac0cb44ce93b6c001449d5d45","value":" 5.91M/5.91M [00:00<00:00, 45.4MB/s]"}},"693fc1fa7fd746ce8a089f3fd6683b51":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"69c5b722ba3746aa80d87b3ee9fea08e":{"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_fd5fe3ad4e43456c896ca45ff6a6f155","placeholder":"​","style":"IPY_MODEL_b92e36c0853f40738b51b8ef39f0377d","value":"config.yaml: 100%"}},"6b641f7304e943d7b53466fc5aa376a2":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_bf24ab0141ce423393972b66c6d09f94","placeholder":"​","style":"IPY_MODEL_bd2757c3b84f4ec283b083d64ea52d7a","value":"Login successful"}},"772e6eb169d84fcb808957fd886a59d1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"8336d24b72414718b82c3195897ee896":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"84262babb03c4f7dab14b35637e29c31":{"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_35f0b383bafc4425a27f36bc95874430","IPY_MODEL_f3d067b1a56849c19c933fb3380386b6","IPY_MODEL_5fb8f440470f4492a5a7a009760a0926"],"layout":"IPY_MODEL_c8348fafe0de405da831284cb39af5cc"}},"8865c7d7d01040329de63b6a13e0fdff":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"8f7afdee0292401181bd477a89ee3069":{"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_772e6eb169d84fcb808957fd886a59d1","placeholder":"​","style":"IPY_MODEL_dcf595ee01a248f895635ad054c8ce28","value":""}},"98b09e7bb5d14a9d8c85e52f54c9c6cf":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_50ed1cf2997e4929853964103bb7552c","placeholder":"​","style":"IPY_MODEL_4bf2285d01ca4f6c86a117f73972c7e7","value":"Connecting..."}},"b3a67d2e0c14492788806bb221761174":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b86e1bdb52414bfab9798b661e3e096d":{"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":""}},"b906b2359fa84291b3b78bcced4f3028":{"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_31f30fd568f84363b8dea2d40f54885c","placeholder":"​","style":"IPY_MODEL_f383e9d323c64c64b528266858d6595c","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.
"}},"b92e36c0853f40738b51b8ef39f0377d":{"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":""}},"bcccc0031f7245a394abc3aee4a6e1c2":{"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_69c5b722ba3746aa80d87b3ee9fea08e","IPY_MODEL_ef96f5501bbb4a55b3aedac70d1261b5","IPY_MODEL_2d26c7ece1fe40178ab85f3d14408532"],"layout":"IPY_MODEL_693fc1fa7fd746ce8a089f3fd6683b51"}},"bd2757c3b84f4ec283b083d64ea52d7a":{"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":""}},"bd36d10136344d4b9965557a8783c5f1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bf24ab0141ce423393972b66c6d09f94":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"c258b47039a243cabadd48de545542f2":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ButtonModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ButtonModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ButtonView","button_style":"","description":"Login","disabled":false,"icon":"","layout":"IPY_MODEL_e7aa7e431546419792ff998e10c4bbe9","style":"IPY_MODEL_0e04e5e88aae4f14838356c422ba7ed5","tooltip":""}},"c3204d520d604179923e93e0a9bfd395":{"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":""}},"c742508bbe1e4f0f9ad385896afea5eb":{"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":""}},"c8348fafe0de405da831284cb39af5cc":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"cc9cc24a3aea416a99897cf0c617f225":{"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":""}},"d072771073ed479b8e16cd9e5b9262c7":{"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":""}},"d1063e27f20648ff9a43fede902a08a4":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_8865c7d7d01040329de63b6a13e0fdff","placeholder":"​","style":"IPY_MODEL_3e816698f9f54bc28712b7e0a1f1dba5","value":"Token is valid (permission: write)."}},"d1f2777676bf4237947a0e42ff7da6de":{"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":""}},"dcf595ee01a248f895635ad054c8ce28":{"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":""}},"dd4a788ac0cb44ce93b6c001449d5d45":{"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":""}},"df65aff406cc4288806b278cf83fb7df":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":"center","align_self":null,"border":null,"bottom":null,"display":"flex","flex":null,"flex_flow":"column","grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":"50%"}},"e50f15a31e4543219ed038b88132d905":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"LabelModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"LabelModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"LabelView","description":"","description_tooltip":null,"layout":"IPY_MODEL_245a4232482547579a72d10243664849","placeholder":"​","style":"IPY_MODEL_d072771073ed479b8e16cd9e5b9262c7","value":"Your token has been saved to /root/.cache/huggingface/token"}},"e7045e323ec947b3b354ffc61365f4cd":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"e7aa7e431546419792ff998e10c4bbe9":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"ef96f5501bbb4a55b3aedac70d1261b5":{"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_8336d24b72414718b82c3195897ee896","max":399,"min":0,"orientation":"horizontal","style":"IPY_MODEL_469ce1b8998a4d998d42fbea5f431781","value":399}},"f383e9d323c64c64b528266858d6595c":{"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":""}},"f3d067b1a56849c19c933fb3380386b6":{"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_0f59d4fccfc045b89337b4b4254de7c3","max":5905440,"min":0,"orientation":"horizontal","style":"IPY_MODEL_c3204d520d604179923e93e0a9bfd395","value":5905440}},"fd5fe3ad4e43456c896ca45ff6a6f155":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}}}}},"nbformat":4,"nbformat_minor":0} diff --git a/tutorials/training_with_cli.md b/tutorials/training_with_cli.md index bc34bd573..984465938 100644 --- a/tutorials/training_with_cli.md +++ b/tutorials/training_with_cli.md @@ -2,7 +2,7 @@ *This tutorial is a very preliminary draft. Expect hiccups and missing details.* -`pyannote.audio` provides a command line tool called `pyannote-audio-train` +`pyannote.audio` provides a command line tool called `pyannote-audio-train` that allows to train models directly from your terminal. It relies on extra dependencies installed using th `[cli]` suffix: @@ -20,6 +20,7 @@ detection on the AMI corpus... pyannote-audio-train \ model=PyanNet \ task=VoiceActivityDetection \ + +registry="AMI-diarization-setup/pyannote/database.yml" \ protocol=AMI.SpeakerDiarization.only_words ``` @@ -28,20 +29,64 @@ pyannote-audio-train \ ```python from pyannote.audio.tasks import VoiceActivityDetection from pyannote.audio.models.segmentation import PyanNet -from pyannote.database import get_protocol +from pyannote.database import registry, FileFinder() from pytorch_lightning import Trainer -protocol = get_protocol("AMI.SpeakerDiarization.only_words") +registry.load_database("AMI-diarization-setup/pyannote/database.yml") +protocol = registry.get_protocol("AMI.SpeakerDiarization.only_words", preprocessors={"audio": FileFinder()}) task = VoiceActivityDetection(protocol) model = PyanNet(task=task) trainer = Trainer() trainer.fit(model) ``` +You can also evaluate a model from it checkpoint on the AMI corpus by calling the following commad... + +```bash +pyannote-audio-eval \ + model=path_to_model_checkpoint.ckpt \ + +registry="AMI-diarization-setup/pyannote/database.yml" \ + protocol="Debug.SpeakerDiarization.Debug" \ + subset=test \ +``` +... which is more or less equivalent to running the following Python script: + +```python +from pyannote.database import FileFinder, ProtocolFile, registry + +from pyannote.audio import Inference, Model +from pyannote.audio.utils.metric import DiscreteDiarizationErrorRate +from pyannote.audio.utils.signal import binarize + +model = Model.from_pretrained("path_to_checkpoint.ckpt") + +# load evaluation files +registry.load_database("AMI-diarization-setup/pyannote/database.yml") +protocol = registry.get_protocol("AMI.SpeakerDiarization.only_words", preprocessors={"audio": FileFinder()}) +files = list(getattr(protocol, "test")()) + +# load evaluation metric +metric = DiscreteDiarizationErrorRate() + +inference = Inference(model) + +def hypothesis(file: ProtocolFile): + return Inference.trim( + binarize(inference(file, hook=progress_hook)), + ) + +for file in files: + reference = file["annotation"] + uem = file["annotated"] + _ = metric(reference, hypothesis(file), uem=uem) + +report = metric.report(display=False) +``` + ## Hydra-based configuration -`pyannote-audio-train` relies on [`Hydra`](https://hydra.cc) to configure the -training process. Adding `--cfg job` option to the previous command will let +`pyannote-audio-train` relies on [`Hydra`](https://hydra.cc) to configure the +training process. Adding `--cfg job` option to the previous command will let you know about the actual configuration used for training: @@ -49,6 +94,7 @@ you know about the actual configuration used for training: pyannote-audio-train --cfg job \ model=PyanNet \ task=VoiceActivityDetection \ + registry="AMI-diarization-setup/pyannote/database.yml" \ protocol=AMI.SpeakerDiarization.only_words ``` @@ -71,6 +117,7 @@ To change the duration of audio chunks used for training to 2 seconds, you would pyannote-audio-train \ model=PyanNet \ task=VoiceActivityDetection task.duration=2.0 \ + registry="AMI-diarization-setup/pyannote/database.yml" \ protocol=AMI.SpeakerDiarization.only_words ``` @@ -104,6 +151,7 @@ pyannote-audio-train \ --config-dir /path/to/custom_config \ model=PyanNet \ task=VoiceActivityDetection task.duration=2.0 \ + registry="AMI-diarization-setup/pyannote/database.yml" \ protocol=AMI.SpeakerDiarization.only_words \ +augmentation=background_noise ``` @@ -123,10 +171,11 @@ Here, we launch a grid of (3 x 2 =) six different jobs: * mono-directional or bidirectional LSTMs ```bash -pyannote-audio-train +pyannote-audio-train --multirun hydra/launcher=submitit_slurm \ model=PyanNet +model.lstm.num_layers=2,3,4 +model.lstm.bidirectional=true,false \ task=VoiceActivityDetection \ + registry="AMI-diarization-setup/pyannote/database.yml" \ protocol=AMI.SpeakerDiarization.only_words ``` diff --git a/tutorials/voice_activity_detection.ipynb b/tutorials/voice_activity_detection.ipynb index df2cadd15..470ee53df 100644 --- a/tutorials/voice_activity_detection.ipynb +++ b/tutorials/voice_activity_detection.ipynb @@ -1,649 +1 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Training a voice activity detection pipeline from scratch with `pyannote.audio`\n", - "\n", - "Voice activity detection (VAD) is the task of detecting speech regions in a given audio stream or recording. \n", - "In this tutorial, you will learn how to train and evaluate a VAD pipeline from scratch." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Data preparation\n", - "\n", - "This tutorial assumes that \n", - "* the [AMI corpus](https://groups.inf.ed.ac.uk/ami/corpus/) has already been [setup for use with `pyannote`](https://github.com/pyannote/AMI-diarization-setup/tree/main/pyannote)\n", - "* the `PYANNOTE_DATABASE_CONFIG` environment variable is set accordingly. \n", - "\n", - "See [`pyannote.database` documentation](https://github.com/pyannote/pyannote-database#pyannote-database) to learn how to prepare your own dataset for training with `pyannote.audio`." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.database import get_protocol, FileFinder\n", - "preprocessors = {\"audio\": FileFinder()}\n", - "ami = get_protocol('AMI.SpeakerDiarization.only_words', \n", - " preprocessors=preprocessors)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`pyannote.database` *protocols* usually define \n", - "* a training set: `for training_file in protocol.train(): ...`, \n", - "* a validation set: `for validation_file in protocol.development(): ...` \n", - "* an evaluation set `for evaluation_file in protocol.test(): ...`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's listen to one minute of the first training file..." - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "first_training_file = next(ami.train())\n", - "reference = first_training_file[\"annotation\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.audio.utils.preview import listen\n", - "from pyannote.core import Segment\n", - "one_minute = Segment(240, 300)\n", - "listen(first_training_file, one_minute)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... and visualize the manual annotation:" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 73, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.core import notebook\n", - "notebook.crop = one_minute\n", - "reference" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We initialize a VAD *task* that describes how the model will be trained:\n", - "\n", - "* `ami` indicates that we will use files available in `ami.train()`.\n", - "* `duration=2.` and `batch_size=128` indicates that the model will ingest batches of 128 two seconds long audio chunks." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.tasks import VoiceActivityDetection\n", - "vad = VoiceActivityDetection(ami, duration=2., batch_size=128)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We initialize one *model* with the `PyanNet` architecture used [in that paper](https://arxiv.org/abs/2104.04045). \n", - "In particular, we increase the default stride of the initial `sincnet` feature extraction layer to `10`.\n", - "\n", - "The model is also provided with the task (`task=vad`) for which it is being trained:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio.models.segmentation import PyanNet\n", - "model = PyanNet(sincnet={'stride': 10}, task=vad)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that everything is ready, let's train with `pytorch-ligthning`!" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\n", - " | Name | Type | Params | In sizes | Out sizes \n", - "-----------------------------------------------------------------------------------------------------------------------\n", - "0 | sincnet | SincNet | 42.6 K | [128, 1, 32000] | [128, 60, 115] \n", - "1 | lstm | LSTM | 589 K | [128, 115, 60] | [[128, 115, 256], [[4, 128, 128], [4, 128, 128]]]\n", - "2 | linear | ModuleList | 49.4 K | ? | ? \n", - "3 | classifier | Linear | 129 | [128, 115, 128] | [128, 115, 1] \n", - "4 | activation | Sigmoid | 0 | [128, 115, 1] | [128, 115, 1] \n", - "5 | validation_metric | AUROC | 0 | ? | ? \n", - "-----------------------------------------------------------------------------------------------------------------------\n", - "681 K Trainable params\n", - "0 Non-trainable params\n", - "681 K Total params\n", - "2.728 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validation sanity check'), FloatProgress(value=1.0, bar_style='info', layout=Layout…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5bee6d4900844312aac04eb9b176f023", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Training'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n" - ] - } - ], - "source": [ - "import pytorch_lightning as pl\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\", max_epochs=2)\n", - "trainer.fit(model)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For the purpose of this tutorial, the model is trained for only 2 epochs. One can obviously expect better performance by training longer and on more data.\n", - "\n", - "See [`pytorch-lightning`](https://www.pytorchlightning.ai/) documentation to learn more about the [`Trainer` API](https://pytorch-lightning.readthedocs.io/en/latest/common/trainer.html), in particular." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Inference\n", - "\n", - "Once trained, the model can be applied to a test file:" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "test_file = next(ami.test())\n", - "# here we use a test file provided by the protocol, but it could be any audio file\n", - "# e.g. test_file = \"/path/to/test.wav\"." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Because the model was trained on 2s audio chunks and that test files are likely to be much longer than that, we wrap the `model` with an `Inference` instance: it will take care of sliding a 2s window over the whole file and aggregate the output of the model." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.audio import Inference\n", - "inference = Inference(model)\n", - "vad_probability = inference(test_file)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "vad_probability" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Perfect voice activity detection output should look like that:" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - ", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "expected_output = test_file[\"annotation\"].get_timeline().support()\n", - "expected_output" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Pipeline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Almost there! To obtain the final speech regions, we need to apply a detection threshold. \n", - "For that, we rely on the voice activity detection pipeline whose hyper-parameters are set manually:\n", - "- `onset=0.6`: mark region as `active` when probability goes above 0.6\n", - "- `offset=0.4`: switch back to `inactive` when probability goes below 0.4\n", - "- `min_duration_on=0.0`: remove `active` regions shorter than that many seconds\n", - "- `min_duration_off=0.0`: fill `inactive` regions shorter than that many seconds\n", - "\n", - "\n", - "More details about those hyper-parameters are provided in Figure 2 of [that paper](https://arxiv.org/abs/2104.04045)." - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from pyannote.audio.pipelines import VoiceActivityDetection as VoiceActivityDetectionPipeline\n", - "pipeline = VoiceActivityDetectionPipeline(segmentation=model)\n", - "initial_params = {\"onset\": 0.6, \"offset\": 0.4, \n", - " \"min_duration_on\": 0.0, \"min_duration_off\": 0.0}\n", - "pipeline.instantiate(initial_params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we go:" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - ", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" - ] - }, - "execution_count": 76, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pipeline(test_file).get_timeline()" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - ", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "expected_output" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Looks decent! Let's perform a proper evaluation by computing the [detection error rate](https://pyannote.github.io/pyannote-metrics/reference.html#detection) over the whole AMI test set:" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Detection error rate = 7.3%\n" - ] - } - ], - "source": [ - "from pyannote.metrics.detection import DetectionErrorRate\n", - "metric = DetectionErrorRate()\n", - "\n", - "for file in ami.test():\n", - " \n", - " # apply the voice activity detection pipeline\n", - " speech = pipeline(file)\n", - "\n", - " # evaluate its output\n", - " _ = metric(\n", - " file['annotation'], # this is the reference annotation\n", - " speech, # this is the hypothesized annotation\n", - " uem=file['annotated']) # this is the part of the file that should be evaluated\n", - " \n", - "# aggregate the performance over the whole test set\n", - "detection_error_rate = abs(metric)\n", - "print(f'Detection error rate = {detection_error_rate * 100:.1f}%')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Optimizing pipeline hyper-parameters" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "While good enough, the hyper-parameters that we chose manually, we can try to optimize `onset` and `offset` on the development (a.k.a. validation) set to get better performance (and freeze the other two hyper-parameters)." - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pipeline.freeze({'min_duration_on': 0.0, 'min_duration_off': 0.0})" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [], - "source": [ - "from pyannote.pipeline import Optimizer\n", - "\n", - "optimizer = Optimizer(pipeline)\n", - "optimizer.tune(list(ami.development()), \n", - " warm_start=initial_params, \n", - " n_iterations=20, \n", - " show_progress=False)\n", - "\n", - "optimized_params = optimizer.best_params" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "There you go: better hyper-parameters that (should) lead to better results!" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'onset': 0.8020095763639215, 'offset': 0.5643079355945013, 'min_duration_on': 0.0, 'min_duration_off': 0.0}\n" - ] - } - ], - "source": [ - "print(optimized_params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's evaluate the voice activity detection pipeline with this new set of hyper-parameters:" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Detection error rate = 6.9%\n" - ] - } - ], - "source": [ - "optimized_pipeline = pipeline.instantiate(optimized_params)\n", - "\n", - "metric = DetectionErrorRate()\n", - "\n", - "for file in ami.test():\n", - " speech = optimized_pipeline(file)\n", - " _ = metric(file['annotation'], speech, uem=file['annotated'])\n", - " \n", - "detection_error_rate = abs(metric)\n", - "print(f'Detection error rate = {detection_error_rate * 100:.1f}%')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "🎉 Yeay! 5% relativement improvement simply by tuning the thresholds." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{"cells":[{"cell_type":"markdown","metadata":{"id":"3M4zoYI4Q-Xi"},"source":["\"Open"]},{"cell_type":"markdown","metadata":{"id":"fEew3B3-Q-Xl"},"source":["# Training a voice activity detection pipeline from scratch with `pyannote.audio`\n","\n","Voice activity detection (VAD) is the task of detecting speech regions in a given audio stream or recording. \n","In this tutorial, you will learn how to train and evaluate a VAD pipeline from scratch."]},{"cell_type":"markdown","metadata":{"id":"1F6PKPftQ-Xm"},"source":["## Tutorial setup"]},{"cell_type":"markdown","metadata":{"id":"ErPKDILdQ-Xn"},"source":["### `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"SYU2JJ9-Q-Xo"},"source":["If you are running this tutorial on `Colab`, execute the following commands in order to setup `Colab` environment. These commands will install `pyannote.audio` and download a mini version of the `AMI` corpus."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":1772401,"status":"ok","timestamp":1704890790335,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"EMspGag4Q-Xp","outputId":"0aaf740d-96c8-4340-a9e7-5c529f12fe9b"},"outputs":[],"source":["!pip install -qq pyannote.audio==3.1.1\n","!pip install -qq ipython==7.34.0\n","!git clone https://github.com/pyannote/AMI-diarization-setup.git\n","%cd ./AMI-diarization-setup/pyannote/\n","!bash ./download_ami_mini.sh\n","%cd /content"]},{"cell_type":"markdown","metadata":{"id":"TFqu_5vyQ-Xq"},"source":["⚠ Restart the runtime (Runtime > Restart session)."]},{"cell_type":"markdown","metadata":{"id":"7_7eodg5Q-Xr"},"source":["### Non `Google Colab` setup"]},{"cell_type":"markdown","metadata":{"id":"WCy8p55QQ-Xr"},"source":["If you are not using `Colab`, this tutorial assumes that\n","* `pyannote.audio` has been installed\n","* the [AMI corpus](https://groups.inf.ed.ac.uk/ami/corpus/) has already been [setup for use with `pyannote`](https://github.com/pyannote/AMI-diarization-setup/tree/main/pyannote)"]},{"cell_type":"markdown","metadata":{"id":"M-oe_8FFQ-Xu"},"source":["## Data preparation\n","\n","See [`pyannote.database` documentation](https://github.com/pyannote/pyannote-database#pyannote-database) to learn how to prepare your own dataset for training with `pyannote.audio`."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"KBstX_2sQ-Xu"},"outputs":[],"source":["from pyannote.database import registry, FileFinder\n","\n","registry.load_database(\"AMI-diarization-setup/pyannote/database.yml\")\n","preprocessors = {\"audio\": FileFinder()}\n","ami = registry.get_protocol('AMI.SpeakerDiarization.mini',\n"," preprocessors=preprocessors)"]},{"cell_type":"markdown","metadata":{"id":"oYIKQ5kwQ-Xv"},"source":["`pyannote.database` *protocols* usually define\n","* a training set: `for training_file in protocol.train(): ...`,\n","* a validation set: `for validation_file in protocol.development(): ...`\n","* an evaluation set `for evaluation_file in protocol.test(): ...`"]},{"cell_type":"markdown","metadata":{"id":"siLd6sE3Q-Xw"},"source":["Let's listen to one minute of the first training file..."]},{"cell_type":"code","execution_count":2,"metadata":{"executionInfo":{"elapsed":212,"status":"ok","timestamp":1704890828290,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"bai4OplyQ-Xw"},"outputs":[],"source":["first_training_file = next(ami.train())\n","reference = first_training_file[\"annotation\"]"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":151,"output_embedded_package_id":"1GxUBhwcdeeXdLogFqdzXqSDl6FNpaR2t"},"executionInfo":{"elapsed":7227,"status":"ok","timestamp":1704890839349,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"5t2l6o3NQ-Xx","outputId":"9755f212-b8ca-45ad-e1a2-60f00665d7be"},"outputs":[],"source":["from pyannote.audio.utils.preview import listen\n","from pyannote.core import Segment\n","\n","one_minute = Segment(240, 300)\n","listen(first_training_file, one_minute)"]},{"cell_type":"markdown","metadata":{"id":"Z3-VQas0Q-Xy"},"source":["... and visualize the manual annotation:"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":239},"executionInfo":{"elapsed":592,"status":"ok","timestamp":1704890847735,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"8fNi_I0pQ-Xz","outputId":"83cfee16-8a4e-4528-8a60-d5b8c0990fc7"},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["from pyannote.core import notebook\n","notebook.crop = one_minute\n","reference"]},{"cell_type":"markdown","metadata":{"id":"fzbxnisZQ-Xz"},"source":["## Training"]},{"cell_type":"markdown","metadata":{"id":"C_QEjNxjQ-Xz"},"source":["We initialize a VAD *task* that describes how the model will be trained:\n","\n","* `ami` indicates that we will use files available in `ami.train()`.\n","* `duration=2.` and `batch_size=128` indicates that the model will ingest batches of 128 two seconds long audio chunks."]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":543,"status":"ok","timestamp":1704890854558,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"oRkU-MboQ-Xz","outputId":"173a3d4b-fdf4-4e13-817d-dc024ac87524"},"outputs":[{"name":"stdout","output_type":"stream","text":["Protocol AMI.SpeakerDiarization.mini 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"]}],"source":["from pyannote.audio.tasks import VoiceActivityDetection\n","\n","vad = VoiceActivityDetection(ami, duration=2., batch_size=128)"]},{"cell_type":"markdown","metadata":{"id":"A7q9pnI4Q-X1"},"source":["We initialize one *model* with the `PyanNet` architecture used [in that paper](https://arxiv.org/abs/2104.04045). \n","In particular, we increase the default stride of the initial `sincnet` feature extraction layer to `10`.\n","\n","The model is also provided with the task (`task=vad`) for which it is being trained:"]},{"cell_type":"code","execution_count":6,"metadata":{"executionInfo":{"elapsed":241,"status":"ok","timestamp":1704890861715,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"dHJMJHB6Q-X1"},"outputs":[],"source":["from pyannote.audio.models.segmentation import PyanNet\n","\n","model = PyanNet(sincnet={'stride': 10}, task=vad)"]},{"cell_type":"markdown","metadata":{"id":"Rwh2ulN2Q-X2"},"source":["Now that everything is ready, let's train with `pytorch-ligthning`!"]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":414,"referenced_widgets":["de7bbc2d644e4ba79f3b4dcc26da3cb7","b62ef7013afe4da4a00ba0a70a63e938","b20cbf0c630a44f8b108d141e0b14ecc","4946ea8187904c7fa9f7c5de92a563e2","929954f82bc6407aaa6b069da848d1e3","53ac5430d2ef45ecaaecc3da0706825b","ffd1d20386d14e2f945f2d84df7a681f","69c34a612abb4d7a83bd796ef97d1c92","2ea0e51154e54129a6b164fc72588edc","910983c75b5247deb203ab218e05b25a","a1861066848a4efda4cc1f09beacb451","321302a76845477cbfd6b644071048b9","0300ea5285a94c7580c789849ea8b7e7","51dc1507c16e4fd88da6e9681b6f8443","84560e1a1a154cf7a4cc998aaa7db862","dce43bbd970643d99f8abbcb299925ec","f3bb471baf44445d9ea50d0adde041c1","14556644c3104b02850a07f172f1411a","50f8b2a4995242ac9d9961f34f2223ae","622cf364efe34719877311f1a46d24b4","ef09269769d845fb84ba39bd43a4ee0c","b827c08a92434a31b82d0382057ee82b","d5dbc90f387a4c9eb43789707505e617","3b55a90beb874204a44df7f231da55eb","8429d57eec2f4c9c8cda3900c0da5df5","d4f4fff579354b10b3cdb32cb11754fe","b886a9d46c7647f0aa5e04260a5b6e1e","5151fae07f114d4e86ee7ec4e487faae","4d2ea6328f684e6e888bc5710dea4340","290e8084737b4ff7a816f4b67fa8d411","bb89bf63ea124306acf411cbeaca2b90","e17799ed71e04167bd46363cf84cc93f","146c185d279d4583860ba4f9defda025"]},"executionInfo":{"elapsed":1454764,"status":"ok","timestamp":1704892319974,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"KkFsUEV_Q-X2","outputId":"3361c2b5-f341-41e1-e027-8fb9b7404d34"},"outputs":[{"name":"stderr","output_type":"stream","text":["INFO:pytorch_lightning.utilities.rank_zero:GPU available: True (cuda), used: True\n","INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n","INFO:pytorch_lightning.utilities.rank_zero:IPU available: False, using: 0 IPUs\n","INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n","WARNING:pytorch_lightning.loggers.tensorboard:Missing logger folder: /content/lightning_logs\n","INFO:pytorch_lightning.accelerators.cuda:LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n","INFO:pytorch_lightning.callbacks.model_summary:\n"," | Name | Type | Params | In sizes | Out sizes \n","---------------------------------------------------------------------------------------------------------------------\n","0 | sincnet | SincNet | 42.6 K | [1, 1, 32000] | [1, 60, 115] \n","1 | lstm | LSTM | 589 K | [1, 115, 60] | [[1, 115, 256], [[4, 1, 128], [4, 1, 128]]]\n","2 | linear | ModuleList | 49.4 K | ? | ? \n","3 | classifier | Linear | 129 | [1, 115, 128] | [1, 115, 1] \n","4 | activation | Sigmoid | 0 | [1, 115, 1] | [1, 115, 1] \n","5 | validation_metric | MetricCollection | 0 | ? | ? \n","---------------------------------------------------------------------------------------------------------------------\n","681 K Trainable params\n","0 Non-trainable params\n","681 K Total params\n","2.728 Total estimated model params size (MB)\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"de7bbc2d644e4ba79f3b4dcc26da3cb7","version_major":2,"version_minor":0},"text/plain":["Sanity Checking: | | 0/? [00:00"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["vad_probability"]},{"cell_type":"markdown","metadata":{"id":"Mscb9fDsQ-X6"},"source":["Perfect voice activity detection output should look like that:"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145},"executionInfo":{"elapsed":689,"status":"ok","timestamp":1704892633130,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"ObtOlbOTQ-X7","outputId":"8dd51edd-e56e-4ae1-e95c-5a592c1a106c"},"outputs":[{"data":{"image/png":"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","text/plain":[", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>"]},"execution_count":11,"metadata":{},"output_type":"execute_result"}],"source":["expected_output = test_file[\"annotation\"].get_timeline().support()\n","expected_output"]},{"cell_type":"markdown","metadata":{"id":"j0f1oMTUQ-X7"},"source":["## Pipeline"]},{"cell_type":"markdown","metadata":{"id":"QcRNQQ_VQ-X7"},"source":["Almost there! To obtain the final speech regions, we need to apply a detection threshold. \n","For that, we rely on the voice activity detection pipeline whose hyper-parameters are set manually:\n","- `onset=0.6`: mark region as `active` when probability goes above 0.6\n","- `offset=0.4`: switch back to `inactive` when probability goes below 0.4\n","- `min_duration_on=0.0`: remove `active` regions shorter than that many seconds\n","- `min_duration_off=0.0`: fill `inactive` regions shorter than that many seconds\n","\n","\n","More details about those hyper-parameters are provided in Figure 2 of [that paper](https://arxiv.org/abs/2104.04045)."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":589,"status":"ok","timestamp":1704892638091,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"TGkXstVpQ-X8","outputId":"d77d4cbe-98e9-4439-9c82-a51d0aeb4e25"},"outputs":[],"source":["from pyannote.audio.pipelines import VoiceActivityDetection as VoiceActivityDetectionPipeline\n","pipeline = VoiceActivityDetectionPipeline(segmentation=model)\n","initial_params = {\"onset\": 0.6, \"offset\": 0.4,\n"," \"min_duration_on\": 0.0, \"min_duration_off\": 0.0}\n","pipeline.instantiate(initial_params)"]},{"cell_type":"markdown","metadata":{"id":"thmmfIyjQ-X8"},"source":["Here we go:"]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145},"executionInfo":{"elapsed":44782,"status":"ok","timestamp":1704892685345,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"lq9gPG2hQ-X9","outputId":"928eea8e-737c-4689-cdb7-262a71dd6b3f"},"outputs":[{"data":{"image/png":"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","text/plain":[", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>"]},"execution_count":13,"metadata":{},"output_type":"execute_result"}],"source":["pipeline(test_file).get_timeline()"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145},"executionInfo":{"elapsed":237,"status":"ok","timestamp":1704892689100,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"EzQZg8VPQ-X9","outputId":"514406de-c097-4904-9b6f-a89cce4cfe89"},"outputs":[{"data":{"image/png":"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","text/plain":[", , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ])>"]},"execution_count":14,"metadata":{},"output_type":"execute_result"}],"source":["expected_output"]},{"cell_type":"markdown","metadata":{"id":"L1FOF3CcQ-X-"},"source":["Looks decent! Let's perform a proper evaluation by computing the [detection error rate](https://pyannote.github.io/pyannote-metrics/reference.html#detection) over the whole AMI test set:"]},{"cell_type":"code","execution_count":15,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":153804,"status":"ok","timestamp":1704892850039,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"6v44K7WxQ-X_","outputId":"ce83364e-147c-4d7d-ee07-69fb49d6ca39"},"outputs":[{"name":"stdout","output_type":"stream","text":["Detection error rate = 12.4%\n"]}],"source":["from pyannote.metrics.detection import DetectionErrorRate\n","metric = DetectionErrorRate()\n","\n","for file in ami.test():\n","\n"," # apply the voice activity detection pipeline\n"," speech = pipeline(file)\n","\n"," # evaluate its output\n"," _ = metric(\n"," file['annotation'], # this is the reference annotation\n"," speech, # this is the hypothesized annotation\n"," uem=file['annotated']) # this is the part of the file that should be evaluated\n","\n","# aggregate the performance over the whole test set\n","detection_error_rate = abs(metric)\n","print(f'Detection error rate = {detection_error_rate * 100:.1f}%')"]},{"cell_type":"markdown","metadata":{"id":"CiADYH02Q-X_"},"source":["## Optimizing pipeline hyper-parameters"]},{"cell_type":"markdown","metadata":{"id":"Zik9XIQ1Q-YA"},"source":["While good enough, the hyper-parameters that we chose manually, we can try to optimize `onset` and `offset` on the development (a.k.a. validation) set to get better performance (and freeze the other two hyper-parameters)."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":219,"status":"ok","timestamp":1704893681462,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"pcQ8eJujQ-YA","outputId":"599cb846-c12f-4d6a-e5b6-c623fd9a583c"},"outputs":[],"source":["pipeline.freeze({'min_duration_on': 0.0, 'min_duration_off': 0.0})"]},{"cell_type":"code","execution_count":17,"metadata":{"executionInfo":{"elapsed":192449,"status":"ok","timestamp":1704893876383,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"xdClXgoMQ-YB"},"outputs":[],"source":["from pyannote.pipeline import Optimizer\n","\n","optimizer = Optimizer(pipeline)\n","optimizer.tune(list(ami.development()),\n"," warm_start=initial_params,\n"," n_iterations=20,\n"," show_progress=False)\n","\n","optimized_params = optimizer.best_params"]},{"cell_type":"markdown","metadata":{"id":"wVT0HjowQ-YB"},"source":["There you go: better hyper-parameters that (should) lead to better results!"]},{"cell_type":"code","execution_count":18,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":219,"status":"ok","timestamp":1704893925876,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"IuUGrd8CQ-YB","outputId":"393d66bc-b04b-4265-bbdf-19c7ff04098e"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'onset': 0.824238792126195, 'offset': 0.5375254799320842, 'min_duration_on': 0.0, 'min_duration_off': 0.0}\n"]}],"source":["print(optimized_params)"]},{"cell_type":"markdown","metadata":{"id":"3nQUzBigQ-YC"},"source":["Let's evaluate the voice activity detection pipeline with this new set of hyper-parameters:"]},{"cell_type":"code","execution_count":19,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":155290,"status":"ok","timestamp":1704894084275,"user":{"displayName":"Clément PAGES","userId":"11757386314069785178"},"user_tz":-60},"id":"7A0sPO_4Q-YD","outputId":"5d28de05-fbbd-4c31-8cc7-62543c82a91d"},"outputs":[{"name":"stdout","output_type":"stream","text":["Detection error rate = 12.0%\n"]}],"source":["optimized_pipeline = pipeline.instantiate(optimized_params)\n","\n","metric = DetectionErrorRate()\n","\n","for file in ami.test():\n"," speech = optimized_pipeline(file)\n"," _ = metric(file['annotation'], speech, uem=file['annotated'])\n","\n","detection_error_rate = abs(metric)\n","print(f'Detection error rate = {detection_error_rate * 100:.1f}%')"]},{"cell_type":"markdown","metadata":{"id":"q6TiP03kQ-YD"},"source":["🎉 Yeay! We can see an improvement simply by adjusting the thresholds."]}],"metadata":{"accelerator":"GPU","colab":{"gpuType":"T4","provenance":[]},"kernelspec":{"display_name":"Python 3","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.10.13"},"widgets":{"application/vnd.jupyter.widget-state+json":{"0300ea5285a94c7580c789849ea8b7e7":{"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_f3bb471baf44445d9ea50d0adde041c1","placeholder":"​","style":"IPY_MODEL_14556644c3104b02850a07f172f1411a","value":"Epoch 0: 100%"}},"14556644c3104b02850a07f172f1411a":{"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":""}},"146c185d279d4583860ba4f9defda025":{"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":""}},"290e8084737b4ff7a816f4b67fa8d411":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":"2","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}},"2ea0e51154e54129a6b164fc72588edc":{"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":""}},"321302a76845477cbfd6b644071048b9":{"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_0300ea5285a94c7580c789849ea8b7e7","IPY_MODEL_51dc1507c16e4fd88da6e9681b6f8443","IPY_MODEL_84560e1a1a154cf7a4cc998aaa7db862"],"layout":"IPY_MODEL_dce43bbd970643d99f8abbcb299925ec"}},"3b55a90beb874204a44df7f231da55eb":{"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_5151fae07f114d4e86ee7ec4e487faae","placeholder":"​","style":"IPY_MODEL_4d2ea6328f684e6e888bc5710dea4340","value":"Validation DataLoader 0: 100%"}},"4946ea8187904c7fa9f7c5de92a563e2":{"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_910983c75b5247deb203ab218e05b25a","placeholder":"​","style":"IPY_MODEL_a1861066848a4efda4cc1f09beacb451","value":" 2/2 [00:08<00:00, 0.24it/s]"}},"4d2ea6328f684e6e888bc5710dea4340":{"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":""}},"50f8b2a4995242ac9d9961f34f2223ae":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":"2","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}},"5151fae07f114d4e86ee7ec4e487faae":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"51dc1507c16e4fd88da6e9681b6f8443":{"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_50f8b2a4995242ac9d9961f34f2223ae","max":136,"min":0,"orientation":"horizontal","style":"IPY_MODEL_622cf364efe34719877311f1a46d24b4","value":136}},"53ac5430d2ef45ecaaecc3da0706825b":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"622cf364efe34719877311f1a46d24b4":{"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":""}},"69c34a612abb4d7a83bd796ef97d1c92":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":"2","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}},"8429d57eec2f4c9c8cda3900c0da5df5":{"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":"","description":"","description_tooltip":null,"layout":"IPY_MODEL_290e8084737b4ff7a816f4b67fa8d411","max":14,"min":0,"orientation":"horizontal","style":"IPY_MODEL_bb89bf63ea124306acf411cbeaca2b90","value":14}},"84560e1a1a154cf7a4cc998aaa7db862":{"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_ef09269769d845fb84ba39bd43a4ee0c","placeholder":"​","style":"IPY_MODEL_b827c08a92434a31b82d0382057ee82b","value":" 136/136 [23:47<00:00, 0.10it/s, v_num=0, BinaryAUROC=0.954]"}},"910983c75b5247deb203ab218e05b25a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"929954f82bc6407aaa6b069da848d1e3":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":"inline-flex","flex":null,"flex_flow":"row wrap","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":"hidden","width":"100%"}},"a1861066848a4efda4cc1f09beacb451":{"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":""}},"b20cbf0c630a44f8b108d141e0b14ecc":{"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":"","description":"","description_tooltip":null,"layout":"IPY_MODEL_69c34a612abb4d7a83bd796ef97d1c92","max":2,"min":0,"orientation":"horizontal","style":"IPY_MODEL_2ea0e51154e54129a6b164fc72588edc","value":2}},"b62ef7013afe4da4a00ba0a70a63e938":{"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_53ac5430d2ef45ecaaecc3da0706825b","placeholder":"​","style":"IPY_MODEL_ffd1d20386d14e2f945f2d84df7a681f","value":"Sanity Checking DataLoader 0: 100%"}},"b827c08a92434a31b82d0382057ee82b":{"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":""}},"b886a9d46c7647f0aa5e04260a5b6e1e":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":"inline-flex","flex":null,"flex_flow":"row wrap","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":"hidden","width":"100%"}},"bb89bf63ea124306acf411cbeaca2b90":{"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":""}},"d4f4fff579354b10b3cdb32cb11754fe":{"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_e17799ed71e04167bd46363cf84cc93f","placeholder":"​","style":"IPY_MODEL_146c185d279d4583860ba4f9defda025","value":" 14/14 [01:58<00:00, 0.12it/s]"}},"d5dbc90f387a4c9eb43789707505e617":{"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_3b55a90beb874204a44df7f231da55eb","IPY_MODEL_8429d57eec2f4c9c8cda3900c0da5df5","IPY_MODEL_d4f4fff579354b10b3cdb32cb11754fe"],"layout":"IPY_MODEL_b886a9d46c7647f0aa5e04260a5b6e1e"}},"dce43bbd970643d99f8abbcb299925ec":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":"inline-flex","flex":null,"flex_flow":"row wrap","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":"100%"}},"de7bbc2d644e4ba79f3b4dcc26da3cb7":{"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_b62ef7013afe4da4a00ba0a70a63e938","IPY_MODEL_b20cbf0c630a44f8b108d141e0b14ecc","IPY_MODEL_4946ea8187904c7fa9f7c5de92a563e2"],"layout":"IPY_MODEL_929954f82bc6407aaa6b069da848d1e3"}},"e17799ed71e04167bd46363cf84cc93f":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"ef09269769d845fb84ba39bd43a4ee0c":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"f3bb471baf44445d9ea50d0adde041c1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"ffd1d20386d14e2f945f2d84df7a681f":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}}}}},"nbformat":4,"nbformat_minor":0} From d83c0f8ea9eff1470df988c588d8d1f01f9c5bd3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Sun, 25 Feb 2024 20:49:08 +0100 Subject: [PATCH 56/57] fix(cli): update CLI with latest APIs --- .github/workflows/test.yml | 2 +- .github/workflows/test_cli.yml | 33 ++++ pyannote/audio/cli/evaluate.py | 14 +- .../cli/evaluate_config/hydra/default.yaml | 3 +- pyannote/audio/cli/train.py | 16 +- pyannote/audio/cli/train_config/config.yaml | 1 - .../cli/train_config/trainer/default.yaml | 2 +- tests/test_cli.py | 149 ++++++++++++++++++ 8 files changed, 205 insertions(+), 15 deletions(-) create mode 100644 .github/workflows/test_cli.yml create mode 100644 tests/test_cli.py diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 90a4302c6..e649027ae 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -30,4 +30,4 @@ jobs: pip install -e .[dev,testing] - name: Test with pytest run: | - pytest + pytest -k "not test_cli.py" diff --git a/.github/workflows/test_cli.yml b/.github/workflows/test_cli.yml new file mode 100644 index 000000000..731a4b5b6 --- /dev/null +++ b/.github/workflows/test_cli.yml @@ -0,0 +1,33 @@ +name: CLI tests + +on: + push: + branches: [develop] + pull_request: + branches: [develop] + +jobs: + build: + timeout-minutes: 20 + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest] + python-version: ["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 update + sudo apt-get install libsndfile1 + - name: Install pyannote.audio + run: | + pip install -e .[dev,testing,cli] + - name: Test with pytest + run: | + pytest tests/test_cli.py diff --git a/pyannote/audio/cli/evaluate.py b/pyannote/audio/cli/evaluate.py index d88c88635..3eec5e3cc 100644 --- a/pyannote/audio/cli/evaluate.py +++ b/pyannote/audio/cli/evaluate.py @@ -25,7 +25,7 @@ import hydra from omegaconf import DictConfig -from pyannote.database import FileFinder, ProtocolFile, get_protocol +from pyannote.database import FileFinder, ProtocolFile, registry from rich.progress import Progress from pyannote.audio import Inference, Model @@ -41,8 +41,16 @@ def evaluate(cfg: DictConfig) -> Optional[float]: (device,) = get_devices(needs=1) model = Model.from_pretrained(cfg.model, device=device) + # load databases into registry if it was specified + if "registry" in cfg: + for database_yml in cfg.registry.split(","): + registry.load_database(database_yml) + # load evaluation files - protocol = get_protocol(cfg.protocol, preprocessors={"audio": FileFinder()}) + protocol = registry.get_protocol( + cfg.protocol, preprocessors={"audio": FileFinder()} + ) + files = list(getattr(protocol, cfg.subset)()) # load evaluation metric @@ -65,8 +73,6 @@ def hypothesis(file: ProtocolFile): warm_up=(warm_up, warm_up), ) - metric = DiscreteDiarizationErrorRate() - for file in files: progress.update(file_task, description=file["uri"]) reference = file["annotation"] diff --git a/pyannote/audio/cli/evaluate_config/hydra/default.yaml b/pyannote/audio/cli/evaluate_config/hydra/default.yaml index 95979432b..1aaebd1b9 100644 --- a/pyannote/audio/cli/evaluate_config/hydra/default.yaml +++ b/pyannote/audio/cli/evaluate_config/hydra/default.yaml @@ -22,7 +22,8 @@ help: template: |- ${hydra.help.header} - pyannote-audio-eval protocol={protocol_name} + pyannote-audio-eval registry={path_to_database.yml} + protocol={protocol_name} subset={test | development | train} model={path_to_pretrained_model} warm_up={warm_up_duration_in_seconds} diff --git a/pyannote/audio/cli/train.py b/pyannote/audio/cli/train.py index 74041554b..f052cd5b3 100644 --- a/pyannote/audio/cli/train.py +++ b/pyannote/audio/cli/train.py @@ -51,8 +51,9 @@ def train(cfg: DictConfig) -> Optional[float]: seed_everything(seed=seed) # load databases into registry - for database_yml in cfg.registry.split(","): - registry.load_database(database_yml) + if "registry" in cfg: + 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} @@ -75,9 +76,9 @@ def train(cfg: DictConfig) -> Optional[float]: # instantiate model fine_tuning = cfg.model["_target_"] == "pyannote.audio.cli.pretrained" - model = instantiate(cfg.model) - model.task = task - model.setup(stage="fit") + model = instantiate(cfg.model, task=task) + model.prepare_data() + model.setup() # validation metric to monitor (and its direction: min or max) monitor, direction = task.val_monitor @@ -146,7 +147,6 @@ def configure_optimizers(self): # in case of fine-tuning, validate the initial model to make sure # that we actually improve over the initial performance if fine_tuning: - model.setup(stage="fit") trainer.validate(model) # train the model @@ -157,7 +157,9 @@ def configure_optimizers(self): # return the best validation score # this can be used for hyper-parameter optimization with Hydra sweepers - if monitor is not None: + # this can only be done if the trainer is not in fast dev run mode, as + # checkpointing is disabled in this mode + if monitor is not None and not trainer.fast_dev_run: best_monitor = float(checkpoint.best_model_score) if direction == "min": return best_monitor diff --git a/pyannote/audio/cli/train_config/config.yaml b/pyannote/audio/cli/train_config/config.yaml index d5b761cc9..d7ecd547a 100644 --- a/pyannote/audio/cli/train_config/config.yaml +++ b/pyannote/audio/cli/train_config/config.yaml @@ -1,4 +1,3 @@ -registry: ??? protocol: ??? defaults: diff --git a/pyannote/audio/cli/train_config/trainer/default.yaml b/pyannote/audio/cli/train_config/trainer/default.yaml index ac3a60ff4..f32031af1 100644 --- a/pyannote/audio/cli/train_config/trainer/default.yaml +++ b/pyannote/audio/cli/train_config/trainer/default.yaml @@ -30,6 +30,6 @@ precision: 32 profiler: null reload_dataloaders_every_n_epochs: 0 use_distributed_sampler: True # TODO: check what this does exactly -strategy: null +strategy: auto sync_batchnorm: False val_check_interval: 1.0 diff --git a/tests/test_cli.py b/tests/test_cli.py new file mode 100644 index 000000000..f62cc5260 --- /dev/null +++ b/tests/test_cli.py @@ -0,0 +1,149 @@ +# The MIT License (MIT) +# +# Copyright (c) 2024- 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 subprocess + +import pytest +from pyannote.database import FileFinder, get_protocol + + +@pytest.fixture() +def protocol(): + return get_protocol( + "Debug.SpeakerDiarization.Debug", preprocessors={"audio": FileFinder()} + ) + + +@pytest.fixture() +def database(): + return "./tests/data/database.yml" + + +@pytest.fixture() +def model(): + return "pyannote/ci-segmentation" + + +def test_cli_train_vad(database, protocol): + res = subprocess.run( + [ + "pyannote-audio-train", + "model=DebugSegmentation", + "task=VoiceActivityDetection", + f"+registry={database}", + f"protocol={protocol.name}", + "trainer=fast_dev_run", + "hydra.run.dir=.", # run hydra app in current directory + "hydra.output_subdir=null", # disable hydra outputs + "hydra/hydra_logging=disabled", + "hydra/job_logging=disabled", + ] + ) + assert res.returncode == 0 + + +def test_cli_train_segmentation(database, protocol): + res = subprocess.run( + [ + "pyannote-audio-train", + "model=DebugSegmentation", + "task=SpeakerDiarization", + f"+registry={database}", + f"protocol={protocol.name}", + "trainer=fast_dev_run", + "hydra.run.dir=.", # run hydra app in current directory + "hydra.output_subdir=null", # disable hydra outputs + "hydra/hydra_logging=disabled", + "hydra/job_logging=disabled", + ] + ) + assert res.returncode == 0 + + +def test_cli_train_osd(database, protocol): + res = subprocess.run( + [ + "pyannote-audio-train", + "model=DebugSegmentation", + "task=OverlappedSpeechDetection", + f"+registry={database}", + f"protocol={protocol.name}", + "trainer=fast_dev_run", + "hydra.run.dir=.", # run hydra app in current directory + "hydra.output_subdir=null", # disable hydra outputs + "hydra/hydra_logging=disabled", + "hydra/job_logging=disabled", + ] + ) + assert res.returncode == 0 + + +def test_cli_train_supervised_representation_with_arcface(database, protocol): + res = subprocess.run( + [ + "pyannote-audio-train", + "model=DebugEmbedding", + "task=SpeakerEmbedding", + f"+registry={database}", + f"protocol={protocol.name}", + "trainer=fast_dev_run", + "hydra.run.dir=.", # run hydra app in current directory + "hydra.output_subdir=null", # disable hydra outputs + "hydra/hydra_logging=disabled", + "hydra/job_logging=disabled", + ] + ) + assert res.returncode == 0 + + +def test_cli_train_segmentation_with_pyannet(database, protocol): + res = subprocess.run( + [ + "pyannote-audio-train", + "model=PyanNet", + "task=SpeakerDiarization", + f"+registry={database}", + f"protocol={protocol.name}", + "trainer=fast_dev_run", + "hydra.run.dir=.", # run hydra app in current directory + "hydra.output_subdir=null", # disable hydra outputs + "hydra/hydra_logging=disabled", + "hydra/job_logging=disabled", + ] + ) + assert res.returncode == 0 + + +def test_cli_eval_segmentation_model(database, protocol, model): + res = subprocess.run( + [ + "pyannote-audio-eval", + f"model={model}", + f"+registry={database}", + f"protocol={protocol.name}", + "hydra.run.dir=.", # run hydra app in current directory + "hydra.output_subdir=null", # disable hydra outputs + "hydra/hydra_logging=disabled", + "hydra/job_logging=disabled", + ] + ) + assert res.returncode == 0 From 99ed3d6de3d16685c33e52873dc4015245a091e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Pag=C3=A9s?= <55240756+clement-pages@users.noreply.github.com> Date: Sun, 25 Feb 2024 21:00:25 +0100 Subject: [PATCH 57/57] improve(ux): improve error message on missing specifications --- pyannote/audio/core/model.py | 10 +--------- pyannote/audio/core/task.py | 6 +++++- tests/tasks/test_specifications.py | 27 +++++++++++++++++++++++++++ 3 files changed, 33 insertions(+), 10 deletions(-) create mode 100644 tests/tasks/test_specifications.py diff --git a/pyannote/audio/core/model.py b/pyannote/audio/core/model.py index d7a264850..8af802293 100644 --- a/pyannote/audio/core/model.py +++ b/pyannote/audio/core/model.py @@ -131,15 +131,7 @@ def specifications(self) -> Union[Specifications, Tuple[Specifications]]: ) 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.prepare_data()` and `model.setup()` " - "to go over the training subset and fix this, or let lightning trainer do that for you in `trainer.fit(model)`." - ) from e + specifications = self.task.specifications return specifications diff --git a/pyannote/audio/core/task.py b/pyannote/audio/core/task.py index afad62717..0a61e2a6f 100644 --- a/pyannote/audio/core/task.py +++ b/pyannote/audio/core/task.py @@ -646,7 +646,11 @@ def setup(self, stage=None): 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() + raise UnknownSpecificationsError( + "Task specifications are not available. This is most likely because they depend on " + "the content of the training subset. Use `task.prepare_data()` and `task.setup()` " + "to go over the training subset and fix this, or let lightning trainer do that for you in `trainer.fit(model)`." + ) return self._specifications @specifications.setter diff --git a/tests/tasks/test_specifications.py b/tests/tasks/test_specifications.py new file mode 100644 index 000000000..32b816155 --- /dev/null +++ b/tests/tasks/test_specifications.py @@ -0,0 +1,27 @@ +import pytest +from pyannote.database import FileFinder, get_protocol + +from pyannote.audio.core.model import Model +from pyannote.audio.core.task import UnknownSpecificationsError +from pyannote.audio.tasks import SpeakerDiarization + + +@pytest.fixture() +def protocol(): + return get_protocol( + "Debug.SpeakerDiarization.Debug", preprocessors={"audio": FileFinder()} + ) + + +def test_unknown_specifications_error_raised_on_non_setup_task(protocol): + task = SpeakerDiarization(protocol=protocol) + with pytest.raises(UnknownSpecificationsError): + _ = task.specifications + + +def test_unknown_specifications_error_raised_on_non_setup_model_task(protocol): + task = SpeakerDiarization(protocol=protocol) + model = Model.from_pretrained("pyannote/ci-segmentation") + model.task = task + with pytest.raises(UnknownSpecificationsError): + _ = model.specifications