feat: add support for label scope and missing classes (#1296)

- setup: switch to pyannote.database 5.0
- feat(task): add support for label scope in speaker diarization task (from pyannote.database 5.0)
- feat(task): add support for missing classes in multi-label segmentation task (from pyannote.database 5.0)
- improve(task): load metadata as tensors/arrays rather than pyannote.core instances
- BREAKING(task): rename `Segmentation` task to `SpeakerDiarization`
- BREAKING(task): remove support for variable chunk duration
This commit is contained in:
Hervé BREDIN authored and GitHub committed 2023-04-13 21:15:57 +02:00
1 parent 74939acbfa
commit 7121a73f08
20 files changed
+1575 -614

No files matched your search

+9
View File
@@ -1,5 +1,14 @@
# Changelog
## Version 3.0 (xxxx-xx-xx)
- setup: switch to pyannote.database 5.0
- feat(task): add support for label scope in speaker diarization task (from pyannote.database 5.0)
- feat(task): add support for missing classes in multi-label segmentation task (from pyannote.database 5.0)
- improve(task): load metadata as tensors rather than pyannote.core instances
- BREAKING(task): rename `Segmentation` task to `SpeakerDiarization`
- BREAKING(task): remove support for variable chunk duration
## Version 2.1.1 (2022-10-27)
- BREAKING(pipeline): rewrite speaker diarization pipeline
+399 -61
View File
@@ -2,18 +2,28 @@
"cells": [
{
"cell_type": "code",
"execution_count": null,
"execution_count": 1,
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"'Debug.SpeakerDiarization.Debug' found in /Users/hbredin/Development/pyannote/pyannote-audio/tests/data/database.yml does not define the 'scope' of speaker labels (file, database, or global). Setting it to 'file'.\n",
"'Debug.SpeakerDiarization.Bug1237' found in /Users/hbredin/Development/pyannote/pyannote-audio/tests/data/database.yml does not define the 'scope' of speaker labels (file, database, or global). Setting it to 'file'.\n"
]
}
],
"source": [
"from pyannote.database import get_protocol, FileFinder\n",
"protocol = get_protocol('Debug.SpeakerDiarization.Debug', \n",
" preprocessors={\"audio\": FileFinder()})"
"from pyannote.database import registry, FileFinder\n",
"registry.load_database('../tests/data/database.yml')\n",
"protocol = registry.get_protocol('Debug.SpeakerDiarization.Debug', \n",
" preprocessors={\"audio\": FileFinder()})"
]
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
@@ -24,26 +34,133 @@
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 3,
"metadata": {},
"outputs": [],
"outputs": [
{
"data": {
"text/html": [
"\n",
" <audio controls=\"controls\" >\n",
" <source src=\"data:audio/wav;base64,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 truncated
" Your browser does not support the audio element.\n",
" </audio>\n",
" "
],
"text/plain": [
"<IPython.lib.display.Audio object>"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from pyannote.audio.utils.preview import listen\n",
"listen(next(protocol.train()))"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Voice activity detection"
"## Voice activity detection"
]
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 4,
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"GPU available: True (mps), used: False\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Protocol Debug.SpeakerDiarization.Debug does not precompute the output of torchaudio.info(): adding a 'torchaudio.info' preprocessor for you to speed up dataloaders. See pyannote.database documentation on how to do that yourself.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"TPU available: False, using: 0 TPU cores\n",
"IPU available: False, using: 0 IPUs\n",
"HPU available: False, using: 0 HPUs\n",
"Missing logger folder: /Users/hbredin/Development/pyannote/pyannote-audio/notebook/lightning_logs\n",
"\n",
" | Name | Type | Params | In sizes | Out sizes \n",
"----------------------------------------------------------------------------------------------------------------------\n",
"0 | mfcc | MFCC | 0 | [32, 1, 32000] | [32, 1, 40, 161] \n",
"1 | lstm | LSTM | 18.9 K | [32, 161, 40] | [[32, 161, 64], [[2, 32, 32], [2, 32, 32]]]\n",
"2 | classifier | Linear | 65 | [32, 161, 64] | [32, 161, 1] \n",
"3 | activation | Sigmoid | 0 | [32, 161, 1] | [32, 161, 1] \n",
"4 | validation_metric | MetricCollection | 0 | ? | ? \n",
"----------------------------------------------------------------------------------------------------------------------\n",
"19.0 K Trainable params\n",
"0 Non-trainable params\n",
"19.0 K Total params\n",
"0.076 Total estimated model params size (MB)\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "37e122a182e544648e65bed1f71ae722",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Sanity Checking: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "4e8a349a91e447a49ea0d93cccfd266c",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Training: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "90c5c47fd1ce4ee98f9729258fab9692",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Validation: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"`Trainer.fit` stopped: `max_epochs=1` reached.\n"
]
}
],
"source": [
"from pyannote.audio.tasks import VoiceActivityDetection\n",
"vad = VoiceActivityDetection(protocol, duration=2., batch_size=32, num_workers=4)\n",
@@ -52,26 +169,6 @@
"_ = trainer.fit(model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Speaker change detection"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from pyannote.audio.tasks import SpeakerChangeDetection\n",
"scd = SpeakerChangeDetection(protocol, duration=2., batch_size=32, num_workers=4)\n",
"model = SimpleSegmentationModel(task=scd)\n",
"trainer = pl.Trainer(max_epochs=1)\n",
"_ = trainer.fit(model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
@@ -81,9 +178,82 @@
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 5,
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"GPU available: True (mps), used: False\n",
"TPU available: False, using: 0 TPU cores\n",
"IPU available: False, using: 0 IPUs\n",
"HPU available: False, using: 0 HPUs\n",
"\n",
" | Name | Type | Params | In sizes | Out sizes \n",
"----------------------------------------------------------------------------------------------------------------------\n",
"0 | mfcc | MFCC | 0 | [32, 1, 32000] | [32, 1, 40, 161] \n",
"1 | lstm | LSTM | 18.9 K | [32, 161, 40] | [[32, 161, 64], [[2, 32, 32], [2, 32, 32]]]\n",
"2 | classifier | Linear | 65 | [32, 161, 64] | [32, 161, 1] \n",
"3 | activation | Sigmoid | 0 | [32, 161, 1] | [32, 161, 1] \n",
"4 | validation_metric | MetricCollection | 0 | ? | ? \n",
"----------------------------------------------------------------------------------------------------------------------\n",
"19.0 K Trainable params\n",
"0 Non-trainable params\n",
"19.0 K Total params\n",
"0.076 Total estimated model params size (MB)\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9a8333c0ebdf41a79482d81e94bf0e76",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Sanity Checking: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "96c422e9449e40fa82a7f274cc6e5e16",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Training: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "1f343adebc5a407ab7b33b5b88094edf",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Validation: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"`Trainer.fit` stopped: `max_epochs=1` reached.\n"
]
}
],
"source": [
"from pyannote.audio.tasks import OverlappedSpeechDetection\n",
"ovl = OverlappedSpeechDetection(protocol, duration=2., batch_size=32, num_workers=4)\n",
@@ -93,45 +263,154 @@
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Segmentation"
"## (Local) speaker diarization"
]
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 6,
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"GPU available: True (mps), used: False\n",
"TPU available: False, using: 0 TPU cores\n",
"IPU available: False, using: 0 IPUs\n",
"HPU available: False, using: 0 HPUs\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "574568dce865407e912423c55dfb002d",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Output()"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
],
"text/plain": []
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
"</pre>\n"
],
"text/plain": [
"\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"\n",
" | Name | Type | Params | In sizes | Out sizes \n",
"----------------------------------------------------------------------------------------------------------------------\n",
"0 | mfcc | MFCC | 0 | [32, 1, 32000] | [32, 1, 40, 161] \n",
"1 | lstm | LSTM | 18.9 K | [32, 161, 40] | [[32, 161, 64], [[2, 32, 32], [2, 32, 32]]]\n",
"2 | classifier | Linear | 195 | [32, 161, 64] | [32, 161, 3] \n",
"3 | activation | Sigmoid | 0 | [32, 161, 3] | [32, 161, 3] \n",
"4 | validation_metric | MetricCollection | 0 | ? | ? \n",
"----------------------------------------------------------------------------------------------------------------------\n",
"19.1 K Trainable params\n",
"0 Non-trainable params\n",
"19.1 K Total params\n",
"0.077 Total estimated model params size (MB)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" - 27.32% of all chunks contain no speech at all.\n",
" - 66.79% contain 1 speaker or less\n",
" - 91.25% contain 2 speakers or less\n",
" - 98.04% contain 3 speakers or less\n",
" - 100.00% contain 4 speakers or less\n",
"Setting `max_speakers_per_chunk` to 3. You can override this value (or avoid this estimation step) by passing `max_speakers_per_chunk=3` to the task constructor.\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "423b6758f1c84f3b8ece70744862fb66",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Sanity Checking: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "e85cb23d204c4876a82a8202edc273c5",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Training: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "b8f5929201654acf83fbca919a5ac63b",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Validation: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"`Trainer.fit` stopped: `max_epochs=1` reached.\n"
]
}
],
"source": [
"from pyannote.audio.tasks import Segmentation\n",
"seg = Segmentation(protocol, duration=2., batch_size=32, num_workers=4)\n",
"from pyannote.audio.tasks import SpeakerDiarization\n",
"seg = SpeakerDiarization(protocol, duration=2., batch_size=32, num_workers=4)\n",
"model = SimpleSegmentationModel(task=seg)\n",
"trainer = pl.Trainer(max_epochs=1)\n",
"_ = trainer.fit(model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Speaker tracking"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from pyannote.audio.tasks import SpeakerTracking\n",
"spk = SpeakerTracking(protocol, duration=2., batch_size=32, num_workers=4)\n",
"model = SimpleSegmentationModel(task=spk)\n",
"trainer = pl.Trainer(max_epochs=1)\n",
"_ = trainer.fit(model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
@@ -141,9 +420,68 @@
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 7,
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"GPU available: True (mps), used: False\n",
"TPU available: False, using: 0 TPU cores\n",
"IPU available: False, using: 0 IPUs\n",
"HPU available: False, using: 0 HPUs\n",
"Loading Debug.SpeakerDiarization.Debug training labels: 10file [00:00, 363.55file/s]\n",
"\n",
" | Name | Type | Params | In sizes | Out sizes \n",
"----------------------------------------------------------------------------------------------------------------------\n",
"0 | mfcc | MFCC | 0 | [32, 1, 32000] | [32, 1, 40, 161] \n",
"1 | lstm | LSTM | 18.9 K | [32, 161, 40] | [[32, 161, 64], [[2, 32, 32], [2, 32, 32]]]\n",
"2 | loss_func | ArcFaceLoss | 832 | ? | ? \n",
"3 | validation_metric | MetricCollection | 0 | ? | ? \n",
"----------------------------------------------------------------------------------------------------------------------\n",
"19.8 K Trainable params\n",
"0 Non-trainable params\n",
"19.8 K Total params\n",
"0.079 Total estimated model params size (MB)\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "b34c5cbe6c9c409fb5572b0be9598076",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Sanity Checking: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "71077814aa154ba3b4892e8be13a98fe",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Training: 0it [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"`Trainer.fit` stopped: `max_epochs=1` reached.\n"
]
}
],
"source": [
"from pyannote.audio.tasks import SpeakerEmbedding\n",
"emb = SpeakerEmbedding(protocol, duration=2., num_workers=4)\n",
@@ -169,7 +507,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
"version": "3.9.13"
}
},
"nbformat": 4,
+1 -1
View File
@@ -2,7 +2,7 @@ registry: ???
protocol: ???
defaults:
- task: SpeakerSegmentation
- task: SpeakerDiarization
- model: PyanNet
- optimizer: Adam
- scheduler: CosineAnnealingWarmRestarts
@@ -1,6 +1,6 @@
# @package _group_
_target_: pyannote.audio.tasks.Segmentation
duration: 5.0
_target_: pyannote.audio.tasks.MultiLabelSegmentation
duration: 3.0
warm_up: 0.0
balance: null
weight: null
@@ -0,0 +1,8 @@
# @package _group_
_target_: pyannote.audio.tasks.SpeakerDiarization
duration: 5.0
max_speakers_per_chunk: 3
max_speakers_per_frame: 2
batch_size: 32
num_workers: 10
pin_memory: False
+4 -1
View File
@@ -215,7 +215,10 @@ class Task(pl.LightningDataModule):
super().__init__()
# dataset
self.protocol, self.has_validation = check_protocol(protocol)
self.protocol, checks = check_protocol(protocol)
self.has_validation = checks["has_validation"]
self.has_scope = checks["has_scope"]
self.has_classes = checks["has_classes"]
# batching
self.duration = duration
+1 -1
View File
@@ -23,8 +23,8 @@
from .multilabel import MultiLabelSegmentation
from .overlapped_speech_detection import OverlappedSpeechDetection
from .resegmentation import Resegmentation
from .segmentation import SpeakerSegmentation
from .speaker_diarization import SpeakerDiarization
from .speaker_segmentation import SpeakerSegmentation
from .voice_activity_detection import VoiceActivityDetection
__all__ = [
+8 -4
View File
@@ -20,21 +20,25 @@
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from .segmentation.multilabel import MultiLabelSegmentation # isort:skip
from .segmentation.speaker_diarization import SpeakerDiarization # isort:skip
from .segmentation.voice_activity_detection import VoiceActivityDetection # isort:skip
from .segmentation.overlapped_speech_detection import ( # isort:skip
OverlappedSpeechDetection,
)
from .segmentation.multilabel import MultiLabelSegmentation # isort:skip
from .segmentation.segmentation import Segmentation # isort:skip
from .embedding.arcface import SupervisedRepresentationLearningWithArcFace # isort:skip
# Segmentation has been renamed to SpeakerDiarization but we keep Segmentation here for backward compatibility
Segmentation = SpeakerDiarization
# SpeakerEmbedding is more human-friendly
SpeakerEmbedding = SupervisedRepresentationLearningWithArcFace
__all__ = [
"Segmentation",
"SpeakerDiarization",
"VoiceActivityDetection",
"OverlappedSpeechDetection",
"MultiLabelSegmentation",
"SpeakerEmbedding",
"Segmentation",
]
+400 -178
View File
@@ -24,115 +24,382 @@ import itertools
import math
import random
import warnings
from typing import Dict, Optional, Sequence, Text, Union
from collections import defaultdict
from typing import Dict, Optional, Sequence, Union
import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn.functional
from pyannote.core import Segment, SlidingWindowFeature
from pyannote.database.protocol import SegmentationProtocol, SpeakerDiarizationProtocol
from pyannote.database.protocol.protocol import Scope, Subset
from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger
from torch.utils.data._utils.collate import default_collate
from torchaudio.backend.common import AudioMetaData
from torchmetrics import Metric
from torchmetrics.classification import BinaryAUROC, MulticlassAUROC, MultilabelAUROC
from pyannote.audio.core.io import AudioFile
from pyannote.audio.core.task import Problem
from pyannote.audio.utils.powerset import Powerset
from pyannote.audio.utils.random import create_rng_for_worker
Subsets = list(Subset.__args__)
Scopes = list(Scope.__args__)
class SegmentationTaskMixin:
"""Methods common to most segmentation tasks"""
def get_file(self, file_id):
file = dict()
file["audio"] = str(self.audios[file_id], encoding="utf-8")
_audio_info = self.audio_infos[file_id]
_encoding = self.audio_encodings[file_id]
sample_rate = _audio_info["sample_rate"]
num_frames = _audio_info["num_frames"]
num_channels = _audio_info["num_channels"]
bits_per_sample = _audio_info["bits_per_sample"]
encoding = str(_encoding, encoding="utf-8")
file["torchaudio.info"] = AudioMetaData(
sample_rate=sample_rate,
num_frames=num_frames,
num_channels=num_channels,
bits_per_sample=bits_per_sample,
encoding=encoding,
)
return file
def setup(self, stage: Optional[str] = None):
"""Setup method
# ==================================================================
# PREPARE TRAINING DATA
# ==================================================================
Parameters
----------
stage : {'fit', 'validate', 'test'}, optional
Setup stage. Defaults to 'fit'.
"""
self._train = []
self._train_metadata = dict()
# duration of training chunks
# TODO: handle variable duration case
duration = getattr(self, "duration", 0.0)
for f in self.protocol.train():
# list of possible values for each metadata key
metadata_unique_values = defaultdict(list)
file = dict()
metadata_unique_values["subset"] = Subsets
for key, value in f.items():
if isinstance(self.protocol, SpeakerDiarizationProtocol):
metadata_unique_values["scope"] = Scopes
# keep track of unique labels in self._train_metadata["annotation"]
if key == "annotation":
for label in value.labels():
self._train_metadata.setdefault("annotation", set()).add(label)
elif isinstance(self.protocol, SegmentationProtocol):
classes = getattr(self, "classes", list())
# pass "audio" entry as it is
elif key == "audio":
pass
# 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)
# remove segments shorter than chunks from "annotated" entry
elif key == "annotated":
value = [
segment for segment in value if segment.duration > self.duration
]
file["_annotated_duration"] = sum(
segment.duration for segment in value
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]
)
# keey track of unique text-like entries (incl. "uri" and "database")
# and pass them as they are
elif isinstance(value, Text):
self._train_metadata.setdefault(key, set()).add(value)
# 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)
]
)
# pass score-like entries as they are
elif isinstance(value, SlidingWindowFeature):
pass
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:
msg = (
f"Protocol '{self.protocol.name}' defines a '{key}' entry of type {type(value)} "
f"which we do not know how to handle."
warnings.warn(
f"Ignoring '{key}' metadata because of its type ({type(value)}). Only str and int are supported for now.",
category=UserWarning,
)
warnings.warn(msg)
file[key] = value
metadata.append(metadatum)
self._train.append(file)
database_unique_labels = list()
self._train_metadata = {
key: sorted(values) for key, values in self._train_metadata.items()
}
# reset list of file-scoped labels
file_unique_labels = list()
# ==================================================================
# PREPARE VALIDATION DATA
# ==================================================================
# 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
self._validation = []
validation_chunks = list()
for f in self.protocol.development():
# obtain indexes of files in the validation subset
validation_file_ids = np.where(
self.metadata["subset"] == Subsets.index("development")
)[0]
for segment in f["annotated"]:
# iterate over files in the validation subset
for file_id in validation_file_ids:
if segment.duration < self.duration:
continue
# get annotated regions in file
annotated_regions = self.annotated_regions[
self.annotated_regions["file_id"] == file_id
]
num_chunks = round(segment.duration // self.duration)
# iterate over annotated regions
for annotated_region in annotated_regions:
# number of chunks in annotated region
num_chunks = round(annotated_region["duration"] // duration)
# iterate over chunks
for c in range(num_chunks):
start_time = segment.start + c * self.duration
chunk = Segment(start_time, start_time + self.duration)
self._validation.append((f, chunk))
start_time = annotated_region["start"] + c * duration
validation_chunks.append((file_id, start_time, duration))
random.shuffle(self._validation)
def setup_loss_func(self):
if self.specifications.powerset:
self.model.powerset = Powerset(
len(self.specifications.classes),
self.specifications.powerset_max_classes,
)
dtype = [("file_id", "i"), ("start", "f"), ("duration", "f")]
self.validation_chunks = np.array(validation_chunks, dtype=dtype)
def default_metric(
self,
@@ -151,67 +418,16 @@ class SegmentationTaskMixin:
f"The {self.specifications.problem} problem type hasn't been given a default segmentation metric yet."
)
def adapt_y(self, one_hot_y: np.ndarray) -> np.ndarray:
raise NotImplementedError(
f"{self.__class__.__name__} must implement the `adapt_y` method."
)
def prepare_chunk(
self,
file: AudioFile,
chunk: Segment,
duration: float = None,
) -> dict:
"""Extract audio chunk and corresponding frame-wise labels
Parameters
----------
file : AudioFile
Audio file.
chunk : Segment
Audio chunk.
duration : float, optional
Fix chunk duration to avoid rounding errors. Defaults to self.duration
Returns
-------
sample : dict
Dictionary with the following keys:
X : np.ndarray
Audio chunk as (num_samples, num_channels) array.
y : SlidingWindowFeature
Frame-wise labels as (num_frames, num_labels) array.
"""
sample = dict()
# read (and resample if needed) audio chunk
duration = duration or self.duration
sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration)
# use model introspection to predict how many frames it will output
num_samples = sample["X"].shape[1]
num_frames, _ = self.model.introspection(num_samples)
resolution = duration / num_frames
# discretize annotation, using model resolution
sample["y"] = file["annotation"].discretize(
support=chunk, resolution=resolution, duration=duration
)
return sample
def train__iter__helper(self, rng: random.Random, **domain_filter):
def train__iter__helper(self, rng: random.Random, **filters):
"""Iterate over training samples with optional domain filtering
Parameters
----------
rng : random.Random
Random number generator
domain_filter : dict, optional
When provided (as {domain_key: domain_value} dict), filter training files so that
only files such as file[domain_key] == domain_value are used for generating chunks.
filters : dict, optional
When provided (as {key: value} dict), filter training files so that
only files such as file[key] == value are used for generating chunks.
Yields
------
@@ -219,37 +435,48 @@ class SegmentationTaskMixin:
Training chunks.
"""
train = self._train
# indices of training files that matches domain filters
training = self.metadata["subset"] == Subsets.index("train")
for key, value in filters.items():
training &= self.metadata[key] == value
file_ids = np.where(training)[0]
try:
domain_key, domain_value = domain_filter.popitem()
except KeyError:
domain_key = None
# turn annotated duration into a probability distribution
annotated_duration = self.annotated_duration[file_ids]
prob_annotated_duration = annotated_duration / np.sum(annotated_duration)
if domain_key is not None:
train = [f for f in train if f[domain_key] == domain_value]
duration = self.duration
num_chunks_per_file = getattr(self, "num_chunks_per_file", 1)
while True:
# select one file at random (with probability proportional to its annotated duration)
file, *_ = rng.choices(
train,
weights=[f["_annotated_duration"] for f in train],
k=1,
)
file_id = np.random.choice(file_ids, p=prob_annotated_duration)
# select one annotated region at random (with probability proportional to its duration)
segment, *_ = rng.choices(
file["annotated"],
weights=[s.duration for s in file["annotated"]],
k=1,
)
# generate `num_chunks_per_file` chunks from this file
for _ in range(num_chunks_per_file):
# select one chunk at random (with uniform distribution)
start_time = rng.uniform(segment.start, segment.end - self.duration)
chunk = Segment(start_time, start_time + self.duration)
# find indices of annotated regions in this file
annotated_region_indices = np.where(
self.annotated_regions["file_id"] == file_id
)[0]
yield self.prepare_chunk(file, chunk, duration=self.duration)
# turn annotated regions duration into a probability distribution
prob_annotated_regions_duration = self.annotated_regions["duration"][
annotated_region_indices
] / np.sum(self.annotated_regions["duration"][annotated_region_indices])
# selected one annotated region at random (with probability proportional to its duration)
annotated_region_index = np.random.choice(
annotated_region_indices, p=prob_annotated_regions_duration
)
# select one chunk at random in this annotated region
_, _, start, end = self.annotated_regions[annotated_region_index]
start_time = rng.uniform(start, end - duration)
yield self.prepare_chunk(file_id, start_time, duration)
def train__iter__(self):
"""Iterate over training samples
@@ -274,16 +501,20 @@ class SegmentationTaskMixin:
chunks = self.train__iter__helper(rng)
else:
chunks_by_domain = {
domain: self.train__iter__helper(rng, **{balance: domain})
for domain in self._train_metadata[balance]
}
# create a subchunk generator for each combination of "balance" keys
subchunks = dict()
for product in itertools.product(
[self.metadata_unique_values[key] for key in balance]
):
filters = {key: value for key, value in zip(balance, product)}
subchunks[product] = self.train__iter__helper(rng, **filters)
while True:
# select one subchunk generator at random (with uniform probability)
# so that it is balanced on average
if balance is not None:
domain = rng.choice(self._train_metadata[balance])
chunks = chunks_by_domain[domain]
chunks = subchunks[rng.choice(subchunks)]
# generate random chunk
yield next(chunks)
@@ -292,30 +523,10 @@ class SegmentationTaskMixin:
return default_collate([b["X"] for b in batch])
def collate_y(self, batch) -> torch.Tensor:
return default_collate([b["y"].data for b in batch])
# gather common set of labels
# b["y"] is a SlidingWindowFeature instance
labels = sorted(set(itertools.chain(*(b["y"].labels for b in batch))))
num_labels = len(labels)
batch_size = len(batch)
num_frames = len(batch[0]["y"])
if num_labels == 0:
return torch.from_numpy(
np.zeros((batch_size, num_frames, 1), dtype=np.int64)
)
Y = np.zeros((batch_size, num_frames, num_labels), dtype=np.int64)
for i, b in enumerate(batch):
for local_idx, label in enumerate(b["y"].labels):
global_idx = labels.index(label)
Y[i, :, global_idx] = b["y"].data[:, local_idx]
return torch.from_numpy(Y)
def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor:
return collated_y
def collate_meta(self, batch) -> torch.Tensor:
return default_collate([b["meta"] for b in batch])
def collate_fn(self, batch, stage="train"):
"""Collate function used for most segmentation tasks
@@ -343,6 +554,9 @@ class SegmentationTaskMixin:
# collate y
collated_y = self.collate_y(batch)
# collate metadata
collated_meta = self.collate_meta(batch)
# apply augmentation (only in "train" stage)
self.augmentation.train(mode=(stage == "train"))
augmented = self.augmentation(
@@ -351,19 +565,28 @@ class SegmentationTaskMixin:
targets=collated_y.unsqueeze(1),
)
return {"X": augmented.samples, "y": self.adapt_y(augmented.targets.squeeze(1))}
return {
"X": augmented.samples,
"y": augmented.targets.squeeze(1),
"meta": collated_meta,
}
def train__len__(self):
# Number of training samples in one epoch
duration = sum(file["_annotated_duration"] for file in self._train)
duration = np.sum(self.annotated_duration)
return max(self.batch_size, math.ceil(duration / self.duration))
def val__getitem__(self, idx):
f, chunk = self._validation[idx]
return self.prepare_chunk(f, chunk, duration=self.duration)
validation_chunk = self.validation_chunks[idx]
return self.prepare_chunk(
validation_chunk["file_id"],
validation_chunk["start"],
duration=validation_chunk["duration"],
)
def val__len__(self):
return len(self._validation)
return len(self.validation_chunks)
def validation_step(self, batch, batch_idx: int):
"""Compute validation area under the ROC curve
@@ -384,12 +607,10 @@ class SegmentationTaskMixin:
_, num_frames, _ = y_pred.shape
# y_pred = (batch_size, num_frames, num_classes)
# compute warmup frames boundaries and weight
warm_up_left = round(self.warm_up[0] / self.duration * num_frames)
warm_up_right = round(self.warm_up[1] / self.duration * num_frames)
# - remove warm-up frames
# - downsample remaining frames
warm_up_left = round(self.warm_up[0] / self.duration * num_frames)
warm_up_right = round(self.warm_up[1] / self.duration * num_frames)
preds = y_pred[:, warm_up_left : num_frames - warm_up_right : 10]
target = y[:, warm_up_left : num_frames - warm_up_right : 10]
@@ -397,6 +618,7 @@ class SegmentationTaskMixin:
# pyannote.audio is more explicit so we have to reshape target and preds for
# torchmetrics to be happy... more details can be found here:
# https://torchmetrics.readthedocs.io/en/latest/references/modules.html#input-types
if self.specifications.problem == Problem.BINARY_CLASSIFICATION:
# target: shape (batch_size, num_frames), type binary
# preds: shape (batch_size, num_frames, 1), type float
+154 -28
View File
@@ -20,12 +20,14 @@
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import warnings
from typing import Dict, Optional, Sequence, Text, Tuple, Union, List
from typing import Dict, List, Optional, Sequence, Text, Tuple, Union
import numpy as np
import torch
import torch.nn.functional as F
from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature
from pyannote.database import Protocol
from pyannote.database.protocol import SegmentationProtocol
from torch_audiomentations.core.transforms_interface import BaseWaveformTransform
from torchmetrics import Metric
@@ -93,6 +95,12 @@ class MultiLabelSegmentation(SegmentationTaskMixin, Task):
augmentation: BaseWaveformTransform = None,
metric: Union[Metric, Sequence[Metric], Dict[str, Metric]] = None,
):
if not isinstance(protocol, SegmentationProtocol):
raise ValueError(
f"MultiLabelSegmentation task expects a SegmentationProtocol but you gave {type(protocol)}. "
)
super().__init__(
protocol,
duration=duration,
@@ -116,42 +124,160 @@ class MultiLabelSegmentation(SegmentationTaskMixin, Task):
super().setup(stage=stage)
classes_from_training_set = sorted(self._train_metadata["annotation"])
if self.classes is None:
classes = classes_from_training_set
else:
if set(classes_from_training_set) != set(self.classes):
warnings.warn(
f"Mismatch between classes passed to the task ({self.classes}) "
f"and those of the training set ({classes_from_training_set})."
)
classes = self.classes
self.specifications = Specifications(
classes=classes,
classes=self.classes,
problem=Problem.MULTI_LABEL_CLASSIFICATION,
resolution=Resolution.FRAME,
duration=self.duration,
warm_up=self.warm_up,
)
def collate_y(self, batch) -> torch.Tensor:
def prepare_chunk(self, file_id: int, start_time: float, duration: float):
"""Prepare chunk for multi-label segmentation
labels = self.specifications.classes
Parameters
----------
file_id : int
File index
start_time : float
Chunk start time
duration : float
Chunk duration.
batch_size, num_frames, num_labels = (
len(batch),
len(batch[0]["y"]),
len(labels),
Returns
-------
sample : dict
Dictionary containing the chunk data with the following keys:
- `X`: waveform
- `y`: target (see Notes below)
- `meta`:
- `database`: database index
- `file`: file index
Notes
-----
y is a trinary matrix with shape (num_frames, num_classes):
- 0: class is inactive
- 1: class is active
- -1: we have no idea
"""
file = self.get_file(file_id)
chunk = Segment(start_time, start_time + duration)
sample = dict()
sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration)
# TODO: this should be cached
# use model introspection to predict how many frames it will output
num_samples = sample["X"].shape[1]
num_frames, _ = self.model.introspection(num_samples)
resolution = duration / num_frames
frames = SlidingWindow(start=0.0, duration=resolution, step=resolution)
# gather all annotations of current file
annotations = self.annotations[self.annotations["file_id"] == file_id]
# gather all annotations with non-empty intersection with current chunk
chunk_annotations = annotations[
(annotations["start"] < chunk.end) & (annotations["end"] > chunk.start)
]
# discretize chunk annotations at model output resolution
start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start
start_idx = np.floor(start / resolution).astype(np.int)
end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start
end_idx = np.ceil(end / resolution).astype(np.int)
# frame-level targets (-1 for un-annotated classes)
y = -np.ones((num_frames, len(self.classes)), dtype=np.int8)
y[:, self.annotated_classes[file_id]] = 0
for start, end, label in zip(
start_idx, end_idx, chunk_annotations["global_label_idx"]
):
y[start:end, label] = 1
sample["y"] = SlidingWindowFeature(y, frames, labels=self.classes)
metadata = self.metadata[file_id]
sample["meta"] = {key: metadata[key] for key in metadata.dtype.names}
sample["meta"]["file"] = file_id
return sample
def training_step(self, batch, batch_idx: int):
X = batch["X"]
y_pred = self.model(X)
y_true = batch["y"]
assert y_pred.shape == y_true.shape
# TODO: add support for frame weights
# TODO: add support for class weights
# mask (frame, class) index for which label is missing
mask: torch.Tensor = y_true != -1
y_pred = y_pred[mask]
y_true = y_true[mask]
loss = F.binary_cross_entropy(y_pred, y_true.type(torch.float))
self.model.log(
f"{self.logging_prefix}TrainLoss",
loss,
on_step=False,
on_epoch=True,
prog_bar=True,
logger=True,
)
Y = np.zeros((batch_size, num_frames, num_labels), dtype=np.int64)
return {"loss": loss}
for i, b in enumerate(batch):
for local_idx, label in enumerate(b["y"].labels):
global_idx = labels.index(label)
Y[i, :, global_idx] = b["y"].data[:, local_idx]
def validation_step(self, batch, batch_idx: int):
return torch.from_numpy(Y)
X = batch["X"]
y_pred = self.model(X)
y_true = batch["y"]
assert y_pred.shape == y_true.shape
# TODO: add option to give more weights to smaller classes
# TODO: add option to balance training samples between classes
# TODO: add support for frame weights
# TODO: add support for class weights
# TODO: compute metrics for each class separately
# mask (frame, class) index for which label is missing
mask: torch.Tensor = y_true != -1
y_pred = y_pred[mask]
y_true = y_true[mask]
loss = F.binary_cross_entropy(y_pred, y_true.type(torch.float))
self.model.log(
f"{self.logging_prefix}ValLoss",
loss,
on_step=False,
on_epoch=True,
prog_bar=True,
logger=True,
)
return {"loss": loss}
@property
def val_monitor(self):
"""Quantity (and direction) to monitor
Useful for model checkpointing or early stopping.
Returns
-------
monitor : str
Name of quantity to monitor.
mode : {'min', 'max}
Minimize
See also
--------
pytorch_lightning.callbacks.ModelCheckpoint
pytorch_lightning.callbacks.EarlyStopping
"""
return f"{self.logging_prefix}ValLoss", "min"
@@ -23,7 +23,8 @@
from typing import Dict, Sequence, Text, Tuple, Union
import torch
import numpy as np
from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature
from pyannote.database import Protocol
from torch_audiomentations.core.transforms_interface import BaseWaveformTransform
from torchmetrics import Metric
@@ -131,20 +132,67 @@ class OverlappedSpeechDetection(SegmentationTaskMixin, Task):
self.balance = balance
self.weight = weight
def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor:
"""Get overlapped speech detection targets
def prepare_chunk(self, file_id: int, start_time: float, duration: float):
"""Prepare chunk for overlapped speech detection
Parameters
----------
collated_y : (batch_size, num_frames, num_speakers) tensor
One-hot-encoding of current chunk speaker activity:
* collated_y[b, f, s] = 1 if sth speaker is active at fth frame
* collated_y[b, f, s] = 0 otherwise.
file_id : int
File index
start_time : float
Chunk start time
duration : float
Chunk duration.
Returns
-------
y : (batch_size, num_frames, ) np.ndarray
y[b, f] = 1 if there is two or more active speakers at fth frame, 0 otherwise.
sample : dict
Dictionary containing the chunk data with the following keys:
- `X`: waveform
- `y`: target as a SlidingWindowFeature instance
- `meta`:
- `database`: database index
- `file`: file index
"""
return 1 * (torch.sum(collated_y, dim=2, keepdim=False) > 1)
file = self.get_file(file_id)
chunk = Segment(start_time, start_time + duration)
sample = dict()
sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration)
# use model introspection to predict how many frames it will output
# TODO: this should be cached
num_samples = sample["X"].shape[1]
num_frames, _ = self.model.introspection(num_samples)
resolution = duration / num_frames
frames = SlidingWindow(start=0.0, duration=resolution, step=resolution)
# gather all annotations of current file
annotations = self.annotations[self.annotations["file_id"] == file_id]
# gather all annotations with non-empty intersection with current chunk
chunk_annotations = annotations[
(annotations["start"] < chunk.end) & (annotations["end"] > chunk.start)
]
# discretize chunk annotations at model output resolution
start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start
start_idx = np.floor(start / resolution).astype(np.int)
end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start
end_idx = np.ceil(end / resolution).astype(np.int)
# frame-level targets
y = np.zeros((num_frames, 1), dtype=np.uint8)
for start, end in zip(start_idx, end_idx):
y[start:end, 0] += 1
y = 1 * (y > 1)
sample["y"] = SlidingWindowFeature(y, frames, labels=["speech"])
metadata = self.metadata[file_id]
sample["meta"] = {key: metadata[key] for key in metadata.dtype.names}
sample["meta"]["file"] = file_id
return sample
@@ -29,9 +29,11 @@ import numpy as np
import torch
import torch.nn.functional
from matplotlib import pyplot as plt
from pyannote.core import SlidingWindow
from pyannote.database import Protocol
from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature
from pyannote.database.protocol import SpeakerDiarizationProtocol
from pyannote.database.protocol.protocol import Scope, Subset
from pytorch_lightning.loggers import MLFlowLogger, TensorBoardLogger
from rich.progress import track
from torch_audiomentations.core.transforms_interface import BaseWaveformTransform
from torchmetrics import Metric
from typing_extensions import Literal
@@ -51,14 +53,18 @@ from pyannote.audio.torchmetrics import (
)
from pyannote.audio.utils.loss import binary_cross_entropy, mse_loss, nll_loss
from pyannote.audio.utils.permutation import permutate
from pyannote.audio.utils.powerset import Powerset
Subsets = list(Subset.__args__)
Scopes = list(Scope.__args__)
class Segmentation(SegmentationTaskMixin, Task):
"""Speaker segmentation
class SpeakerDiarization(SegmentationTaskMixin, Task):
"""Speaker diarization
Parameters
----------
protocol : Protocol
protocol : SpeakerDiarizationProtocol
pyannote.database protocol
duration : float, optional
Chunks duration. Defaults to 2s.
@@ -83,8 +89,8 @@ class Segmentation(SegmentationTaskMixin, Task):
Defaults to 0. (i.e. no warm-up).
balance: str, optional
When provided, training samples are sampled uniformly with respect to that key.
For instance, setting `balance` to "uri" will make sure that each file will be
equally represented in the training samples.
For instance, setting `balance` to "database" will make sure that each database
will be equally represented in the training samples.
weight: str, optional
When provided, use this key as frame-wise weight in loss function.
batch_size : int, optional
@@ -121,7 +127,7 @@ class Segmentation(SegmentationTaskMixin, Task):
def __init__(
self,
protocol: Protocol,
protocol: SpeakerDiarizationProtocol,
duration: float = 2.0,
max_speakers_per_chunk: int = None,
max_speakers_per_frame: int = None,
@@ -150,6 +156,11 @@ class Segmentation(SegmentationTaskMixin, Task):
metric=metric,
)
if not isinstance(protocol, SpeakerDiarizationProtocol):
raise ValueError(
"SpeakerDiarization task requires a SpeakerDiarizationProtocol."
)
# deprecation warnings
if max_speakers_per_chunk is None and max_num_speakers is not None:
max_speakers_per_chunk = max_num_speakers
@@ -181,38 +192,76 @@ class Segmentation(SegmentationTaskMixin, Task):
super().setup(stage=stage)
# estimate maximum number of speakers per chunk when not provided
if self.max_speakers_per_chunk is None:
# TODO: optimize this
training = self.metadata["subset"] == Subsets.index("train")
# slide a window (with 1s step) over the whole training set
# and keep track of the number of speakers in each location
num_speakers = []
for file in self._train:
start = file["annotated"][0].start
end = file["annotated"][-1].end
window = SlidingWindow(
start=start,
end=end,
duration=self.duration,
step=1.0,
)
for chunk in window:
num_speakers.append(len(file["annotation"].crop(chunk).labels()))
num_unique_speakers = []
progress_description = f"Estimating maximum number of speakers per {self.duration:g}s chunk in the training set"
for file_id in track(
np.where(training)[0], description=progress_description
):
annotations = self.annotations[
np.where(self.annotations["file_id"] == file_id)[0]
]
annotated_regions = self.annotated_regions[
np.where(self.annotated_regions["file_id"] == file_id)[0]
]
for region in annotated_regions:
# find annotations within current region
region_start = region["start"]
region_end = region["end"]
region_annotations = annotations[
np.where(
(annotations["start"] >= region_start)
* (annotations["end"] <= region_end)
)[0]
]
for window_start in np.arange(
region_start, region_end - self.duration, 0.25 * self.duration
):
window_end = window_start + self.duration
window_annotations = region_annotations[
np.where(
(region_annotations["start"] <= window_end)
* (region_annotations["end"] >= window_start)
)[0]
]
num_unique_speakers.append(
len(np.unique(window_annotations["file_label_idx"]))
)
# because there might a few outliers, estimate the upper bound for the
# number of speakers as the 99th percentile
# number of speakers as the 97th percentile
num_speakers, counts = zip(*list(Counter(num_speakers).items()))
num_speakers, counts = zip(*list(Counter(num_unique_speakers).items()))
num_speakers, counts = np.array(num_speakers), np.array(counts)
sorting_indices = np.argsort(num_speakers)
num_speakers = num_speakers[sorting_indices]
counts = counts[sorting_indices]
ratios = np.cumsum(counts) / np.sum(counts)
for k, ratio in zip(num_speakers, ratios):
if k == 0:
print(f" - {ratio:7.2%} of all chunks contain no speech at all.")
elif k == 1:
print(f" - {ratio:7.2%} contain 1 speaker or less")
else:
print(f" - {ratio:7.2%} contain {k} speakers or less")
self.max_speakers_per_chunk = max(
2,
num_speakers[np.where(np.cumsum(counts) / np.sum(counts) > 0.99)[0][0]],
num_speakers[np.where(ratios > 0.97)[0][0]],
)
print(
f"Setting `max_speakers_per_chunk` to {self.max_speakers_per_chunk}. "
f"You can override this value (or avoid this estimation step) by passing `max_speakers_per_chunk={self.max_speakers_per_chunk}` to the task constructor."
)
if (
@@ -238,42 +287,143 @@ class Segmentation(SegmentationTaskMixin, Task):
permutation_invariant=True,
)
def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor:
"""Get speaker diarization targets
def setup_loss_func(self):
if self.specifications.powerset:
self.model.powerset = Powerset(
len(self.specifications.classes),
self.specifications.powerset_max_classes,
)
def prepare_chunk(self, file_id: int, start_time: float, duration: float):
"""Prepare chunk
Parameters
----------
collated_y : (batch_size, num_frames, num_speakers) tensor
One-hot-encoding of current chunk speaker activity:
* one_hot_y[b, f, s] = 1 if sth speaker is active at fth frame
* one_hot_y[b, f, s] = 0 otherwise.
file_id : int
File index
start_time : float
Chunk start time
duration : float
Chunk duration.
Returns
-------
y : (batch_size, num_frames, max_speakers_per_chunk) tensor
Same as collated_y, except we only keep ``max_speakers_per_chunk`` most
talkative speakers (per sample).
sample : dict
Dictionary containing the chunk data with the following keys:
- `X`: waveform
- `y`: target as a SlidingWindowFeature instance where y.labels is
in meta.scope space.
- `meta`:
- `scope`: target scope (0: file, 1: database, 2: global)
- `database`: database index
- `file`: file index
"""
batch_size, num_frames, num_speakers = collated_y.shape
file = self.get_file(file_id)
# maximum number of active speakers in a chunk
max_speakers_per_chunk = max(
1, torch.max(torch.sum(torch.sum(collated_y, dim=1) > 0.0, dim=1))
)
# get label scope
label_scope = Scopes[self.metadata[file_id]["scope"]]
label_scope_key = f"{label_scope}_label_idx"
# sort speakers in descending talkativeness order
indices = torch.argsort(torch.sum(collated_y, dim=1), dim=1, descending=True)
#
chunk = Segment(start_time, start_time + duration)
# keep max_speakers_per_chunk most talkative speakers, for each chunk
y = torch.zeros(
(batch_size, num_frames, max_speakers_per_chunk), dtype=collated_y.dtype
)
for b, index in enumerate(indices):
for k, i in zip(range(max_speakers_per_chunk), index):
y[b, :, k] = collated_y[b, :, i.item()]
sample = dict()
sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration)
return y
# use model introspection to predict how many frames it will output
# TODO: this should be cached
num_samples = sample["X"].shape[1]
num_frames, _ = self.model.introspection(num_samples)
resolution = duration / num_frames
frames = SlidingWindow(start=0.0, duration=resolution, step=resolution)
# gather all annotations of current file
annotations = self.annotations[self.annotations["file_id"] == file_id]
# gather all annotations with non-empty intersection with current chunk
chunk_annotations = annotations[
(annotations["start"] < chunk.end) & (annotations["end"] > chunk.start)
]
# discretize chunk annotations at model output resolution
start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start
start_idx = np.floor(start / resolution).astype(np.int)
end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start
end_idx = np.ceil(end / resolution).astype(np.int)
# get list and number of labels for current scope
labels = list(np.unique(chunk_annotations[label_scope_key]))
num_labels = len(labels)
if num_labels > self.max_speakers_per_chunk:
pass
# initial frame-level targets
y = np.zeros((num_frames, num_labels), dtype=np.uint8)
# map labels to indices
mapping = {label: idx for idx, label in enumerate(labels)}
for start, end, label in zip(
start_idx, end_idx, chunk_annotations[label_scope_key]
):
mapped_label = mapping[label]
y[start:end, mapped_label] = 1
sample["y"] = SlidingWindowFeature(y, frames, labels=labels)
metadata = self.metadata[file_id]
sample["meta"] = {key: metadata[key] for key in metadata.dtype.names}
sample["meta"]["file"] = file_id
return sample
def collate_y(self, batch) -> torch.Tensor:
"""
Parameters
----------
batch : list
List of samples to collate.
"y" field is expected to be a SlidingWindowFeature.
Returns
-------
y : torch.Tensor
Collated target tensor of shape (num_frames, self.max_speakers_per_chunk)
If one chunk has more than `self.max_speakers_per_chunk` speakers, we keep
the max_speakers_per_chunk most talkative ones. If it has less, we pad with
zeros (artificial inactive speakers).
"""
collated_y = []
for b in batch:
y = b["y"].data
num_speakers = len(b["y"].labels)
if num_speakers > self.max_speakers_per_chunk:
# sort speakers in descending talkativeness order
indices = np.argsort(-np.sum(y, axis=0), axis=0)
# keep only the most talkative speakers
y = y[:, indices[: self.max_speakers_per_chunk]]
# TODO: we should also sort the speaker labels in the same way
elif num_speakers < self.max_speakers_per_chunk:
# create inactive speakers by zero padding
y = np.pad(
y,
((0, 0), (0, self.max_speakers_per_chunk - num_speakers)),
mode="constant",
)
else:
# we have exactly the right number of speakers
pass
collated_y.append(y)
return torch.from_numpy(np.stack(collated_y))
def segmentation_loss(
self,
@@ -509,15 +659,6 @@ class Segmentation(SegmentationTaskMixin, Task):
OptimalFalseAlarmRate(),
]
def train__iter__(self):
for chunk in super().train__iter__():
# TODO: document why this filtering is needed
if self.specifications.powerset:
if len(chunk["y"].labels) <= self.max_speakers_per_chunk:
yield chunk
else:
yield chunk
# TODO: no need to compute gradient in this method
def validation_step(self, batch, batch_idx: int):
"""Compute validation loss and metric
@@ -667,7 +808,7 @@ class Segmentation(SegmentationTaskMixin, Task):
# visualize first 9 validation samples of first batch in Tensorboard/MLflow
if self.specifications.powerset:
y = permutated_target_powerset.float().cpu().numpy()
y = permutated_target.float().cpu().numpy()
y_pred = multilabel.cpu().numpy()
else:
y = target.float().cpu().numpy()
@@ -22,7 +22,8 @@
from typing import Dict, Sequence, Text, Tuple, Union
import torch
import numpy as np
from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature
from pyannote.database import Protocol
from torch_audiomentations.core.transforms_interface import BaseWaveformTransform
from torchmetrics import Metric
@@ -113,20 +114,66 @@ class VoiceActivityDetection(SegmentationTaskMixin, Task):
],
)
def adapt_y(self, collated_y: torch.Tensor) -> torch.Tensor:
"""Get voice activity detection targets
def prepare_chunk(self, file_id: int, start_time: float, duration: float):
"""Prepare chunk for voice activity detection
Parameters
----------
collated_y : (batch_size, num_frames, num_speakers) tensor
One-hot-encoding of current chunk speaker activity:
* one_hot_y[b, f, s] = 1 if sth speaker is active at fth frame
* one_hot_y[b, f, s] = 0 otherwise.
file_id : int
File index
start_time : float
Chunk start time
duration : float
Chunk duration.
Returns
-------
y : (batch_size, num_frames, ) tensor
y[b, f] = 1 if at least one speaker is active at fth frame, 0 otherwise.
sample : dict
Dictionary containing the chunk data with the following keys:
- `X`: waveform
- `y`: target as a SlidingWindowFeature instance
- `meta`:
- `database`: database index
- `file`: file index
"""
return 1 * (torch.sum(collated_y, dim=2, keepdims=False) > 0)
file = self.get_file(file_id)
chunk = Segment(start_time, start_time + duration)
sample = dict()
sample["X"], _ = self.model.audio.crop(file, chunk, duration=duration)
# use model introspection to predict how many frames it will output
# TODO: this should be cached
num_samples = sample["X"].shape[1]
num_frames, _ = self.model.introspection(num_samples)
resolution = duration / num_frames
frames = SlidingWindow(start=0.0, duration=resolution, step=resolution)
# gather all annotations of current file
annotations = self.annotations[self.annotations["file_id"] == file_id]
# gather all annotations with non-empty intersection with current chunk
chunk_annotations = annotations[
(annotations["start"] < chunk.end) & (annotations["end"] > chunk.start)
]
# discretize chunk annotations at model output resolution
start = np.maximum(chunk_annotations["start"], chunk.start) - chunk.start
start_idx = np.floor(start / resolution).astype(np.int)
end = np.minimum(chunk_annotations["end"], chunk.end) - chunk.start
end_idx = np.ceil(end / resolution).astype(np.int)
# frame-level targets
y = np.zeros((num_frames, 1), dtype=np.uint8)
for start, end in zip(start_idx, end_idx):
y[start:end, 0] = 1
sample["y"] = SlidingWindowFeature(y, frames, labels=["speech"])
metadata = self.metadata[file_id]
sample["meta"] = {key: metadata[key] for key in metadata.dtype.names}
sample["meta"]["file"] = file_id
return sample
+14 -2
View File
@@ -40,7 +40,10 @@ def check_protocol(protocol: Protocol) -> Protocol:
Returns
-------
fixed_protocol : Protocol
has_validation : bool
checks: dict
has_validation : bool
has_scope : bool
has_classes : bool
Raises
------
@@ -108,6 +111,9 @@ def check_protocol(protocol: Protocol) -> Protocol:
)
print(msg)
has_scope = "scope" in file
has_classes = "classes" in file
# does protocol define a validation set?
if isinstance(protocol, SpeakerVerificationProtocol):
validation_method = "development_trial"
@@ -121,4 +127,10 @@ def check_protocol(protocol: Protocol) -> Protocol:
else:
has_validation = True
return protocol, has_validation
checks = {
"has_validation": has_validation,
"has_scope": has_scope,
"has_classes": has_classes,
}
return protocol, checks
+1 -1
View File
@@ -6,7 +6,7 @@ huggingface_hub >= 0.8.1
networkx >= 2.6,<3.0
omegaconf >=2.1,<3.0
pyannote.core >=4.4,<5.0
pyannote.database >=4.1.1,<5.0
pyannote.database >=5.0,<6.0
pyannote.metrics >=3.2,<4.0
pyannote.pipeline >=2.3,<3.0
pytorch_lightning >=1.8.0,<1.9
+5 -3
View File
@@ -1,9 +1,9 @@
from lightning_lite.utilities.seed import seed_everything
import torch
from lightning_lite.utilities.seed import seed_everything
from pyannote.database import FileFinder, get_protocol
from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel
from pyannote.audio.tasks import MultiLabelSegmentation, VoiceActivityDetection
from pyannote.database import FileFinder, get_protocol
def setup_tasks(task):
@@ -30,13 +30,15 @@ def get_next5(dl):
def test_seeding_ensures_data_loaders():
"Setting a global seed for the dataloaders ensures that we get data back in the same order"
seed_everything(1)
for task in [VoiceActivityDetection, MultiLabelSegmentation]:
seed_everything(1)
protocol, vad = setup_tasks(task)
dl = create_dl(SimpleSegmentationModel, vad)
last5a = get_next5(dl)
seed_everything(1)
protocol, vad = setup_tasks(task)
dl = create_dl(SimpleSegmentationModel, vad)
last5b = get_next5(dl)
+11 -11
View File
@@ -1,13 +1,13 @@
import pytest
from pyannote.database import FileFinder, get_protocol
from pytorch_lightning import Trainer
from pyannote.audio.models.segmentation.debug import SimpleSegmentationModel
from pyannote.audio.tasks import (
OverlappedSpeechDetection,
Segmentation,
SpeakerDiarization,
VoiceActivityDetection,
)
from pyannote.database import FileFinder, get_protocol
@pytest.fixture()
@@ -18,7 +18,7 @@ def protocol():
def test_train_segmentation(protocol):
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model = SimpleSegmentationModel(task=segmentation)
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
@@ -51,12 +51,12 @@ def test_finetune_with_task_that_does_not_need_setup_for_specs(protocol):
def test_finetune_with_task_that_needs_setup_for_specs(protocol):
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model = SimpleSegmentationModel(task=segmentation)
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model.task = segmentation
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
@@ -64,7 +64,7 @@ def test_finetune_with_task_that_needs_setup_for_specs(protocol):
def test_transfer_with_task_that_does_not_need_setup_for_specs(protocol):
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model = SimpleSegmentationModel(task=segmentation)
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
@@ -82,7 +82,7 @@ def test_transfer_with_task_that_needs_setup_for_specs(protocol):
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model.task = segmentation
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
@@ -90,12 +90,12 @@ def test_transfer_with_task_that_needs_setup_for_specs(protocol):
def test_finetune_freeze_with_task_that_needs_setup_for_specs(protocol):
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model = SimpleSegmentationModel(task=segmentation)
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model.task = segmentation
model.freeze_up_to("mfcc")
trainer = Trainer(fast_dev_run=True)
@@ -118,7 +118,7 @@ def test_finetune_freeze_with_task_that_does_not_need_setup_for_specs(protocol):
def test_transfer_freeze_with_task_that_does_not_need_setup_for_specs(protocol):
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model = SimpleSegmentationModel(task=segmentation)
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
@@ -137,7 +137,7 @@ def test_transfer_freeze_with_task_that_needs_setup_for_specs(protocol):
trainer = Trainer(fast_dev_run=True)
trainer.fit(model)
segmentation = Segmentation(protocol)
segmentation = SpeakerDiarization(protocol)
model.task = segmentation
model.freeze_up_to("mfcc")
trainer = Trainer(fast_dev_run=True)
+240 -239
View File
@@ -1,29 +1,10 @@
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": [],
"toc_visible": true,
"authorship_tag": "ABX9TyMc87txSanOjHXPQP0Zpu9J",
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
},
"accelerator": "GPU",
"gpuClass": "standard"
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
"colab_type": "text",
"id": "view-in-github"
},
"source": [
"<a href=\"https://colab.research.google.com/github/pyannote/pyannote-audio/blob/develop/tutorials/adapting_pretrained_pipeline.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
@@ -31,6 +12,9 @@
},
{
"cell_type": "markdown",
"metadata": {
"id": "npzkG4poB2BH"
},
"source": [
"# Adapting pyannote.audio 2.1 pretrained speaker diarization pipeline to your own data\n",
"\n",
@@ -41,31 +25,28 @@
"Version 2.1 introduces a major overhaul of the default speaker diarization pipeline, made of three main stages: speaker segmentation applied to a short sliding window, neural speaker embedding of each (local) speakers, and (global) agglomerative clustering.\n",
"\n",
"Despite its decent out-of-the-box performance, the default pipeline may suffer from the domain mismatch problem (common to most machine learning models) and not perform well on your own data. This tutorial will guide you through two recipes to adapt it to your own data and (hopefully) get better performance. Depending on the number and duration of labeled conversations, you may either focus on optimizing hyper-parameters or additionally fine-tune the internal speaker segmentation model."
],
"metadata": {
"id": "npzkG4poB2BH"
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pnaQ4JSLF8Ms"
},
"source": [
"⚠ Make sure that you switch to a GPU runtime (Runtime > Change runtime type). \n",
"If you don't, everything will be extremely slow."
],
"metadata": {
"id": "pnaQ4JSLF8Ms"
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CZjbjOBBDrdm"
},
"source": [
"## Installation\n",
"\n",
"Let's start by installing `pyannote.audio` 2.1.1 (and `rich` for pretty progress bars)."
],
"metadata": {
"id": "CZjbjOBBDrdm"
}
]
},
{
"cell_type": "code",
@@ -81,47 +62,45 @@
},
{
"cell_type": "markdown",
"metadata": {
"id": "ndQ10VIf2W1c"
},
"source": [
"⚠ Restart the runtime (Runtime > Restart runtime). \n",
"If you don't, `pyannote.database` will throw an error below."
],
"metadata": {
"id": "ndQ10VIf2W1c"
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lz-b8j6RD7H6"
},
"source": [
"## Data preparation\n",
"\n",
"First things first: we need data... Annotated data! Ideally, lots of annotated data! \n",
"\n",
"For the purpose of this tutorial, we will rely on the AMI-SDM (single distance microphone) corpus. \n"
],
"metadata": {
"id": "lz-b8j6RD7H6"
}
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "uSQVKFDC0cOe"
},
"outputs": [],
"source": [
"# download AMI-SDM mini corpus\n",
"%cd /content/\n",
"!git clone https://github.com/pyannote/AMI-diarization-setup\n",
"%cd /content/AMI-diarization-setup/pyannote/\n",
"!bash download_ami_sdm_mini.sh"
],
"metadata": {
"id": "uSQVKFDC0cOe"
},
"execution_count": null,
"outputs": []
]
},
{
"cell_type": "code",
"source": [
"!PYANNOTE_DATABASE_CONFIG=\"/content/AMI-diarization-setup/pyannote/database.yml\" pyannote-database info AMI-SDM.SpeakerDiarization.mini"
],
"execution_count": 9,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
@@ -129,11 +108,10 @@
"id": "wTKkOeMr2QUL",
"outputId": "d9cc39fd-4cc2-44fe-a922-533370221d31"
},
"execution_count": 9,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[92m\u001b[1m\u001b[4mtrain\u001b[0m\n",
" 28 files\n",
@@ -152,35 +130,41 @@
" 12 speakers\n"
]
}
],
"source": [
"!PYANNOTE_DATABASE_CONFIG=\"/content/AMI-diarization-setup/pyannote/database.yml\" pyannote-database info AMI-SDM.SpeakerDiarization.mini"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "09LrQFIfp0zC"
},
"source": [
"Note that we use a \"mini\" version of AMI-SDM so that the tutorial can be run in half an hour but the full version is also available for you to get better results. \n",
"\n",
"If you want to try it, replace `download_ami_sdm_mini.sh` by `download_ami_sdm.sh` and `AMI-SDM.SpeakerDiarization.mini` by `AMI-SDM.SpeakerDiarization.only_words` and you are good to go! "
],
"metadata": {
"id": "09LrQFIfp0zC"
}
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"id": "l6V8Exw41XBp"
},
"outputs": [],
"source": [
"import os\n",
"os.environ[\"PYANNOTE_DATABASE_CONFIG\"] = \"/content/AMI-diarization-setup/pyannote/database.yml\"\n",
"from pyannote.database import get_protocol, FileFinder\n",
"dataset = get_protocol(\"AMI-SDM.SpeakerDiarization.mini\", {\"audio\": FileFinder()})"
],
"metadata": {
"id": "l6V8Exw41XBp"
},
"execution_count": 10,
"outputs": []
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HivpZEgZEVAu"
},
"source": [
"## Pretrained pipeline\n",
"\n",
@@ -192,37 +176,51 @@
"* visit [hf.co/pyannote/speaker-diarization](https://hf.co/pyannote/speaker-diarization) and accept the terms\n",
"* visit [hf.co/pyannote/segmentation](https://hf.co/pyannote/segmentation) (used internally by the speaker diarization pipeline)and accept the terms\n",
"* log in using `notebook_login`"
],
"metadata": {
"id": "HivpZEgZEVAu"
}
]
},
{
"cell_type": "code",
"source": [
"from huggingface_hub import notebook_login\n",
"notebook_login()"
],
"execution_count": null,
"metadata": {
"id": "FbXEQUGXscTQ"
},
"execution_count": null,
"outputs": []
"outputs": [],
"source": [
"from huggingface_hub import notebook_login\n",
"notebook_login()"
]
},
{
"cell_type": "code",
"source": [
"from pyannote.audio import Pipeline\n",
"pretrained_pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization\", use_auth_token=True) "
],
"execution_count": 11,
"metadata": {
"id": "l7eN_Y792Cxt"
},
"execution_count": 11,
"outputs": []
"outputs": [],
"source": [
"from pyannote.audio import Pipeline\n",
"pretrained_pipeline = Pipeline.from_pretrained(\"pyannote/speaker-diarization\", use_auth_token=True) "
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "lDIIp7iaICUC",
"outputId": "b4880a85-692b-470d-f133-d95128bdecd9"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The pretrained pipeline reaches a Diarization Error Rate (DER) of 32.5% on AMI-SDM.SpeakerDiarization.mini test set.\n"
]
}
],
"source": [
"# this takes approximately 2min to run on Google Colab GPU\n",
"from pyannote.metrics.diarization import DiarizationErrorRate\n",
@@ -236,30 +234,11 @@
" metric(file[\"annotation\"], file[\"pretrained pipeline\"], uem=file[\"annotated\"])\n",
"\n",
"print(f\"The pretrained pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "lDIIp7iaICUC",
"outputId": "b4880a85-692b-470d-f133-d95128bdecd9"
},
"execution_count": 32,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"The pretrained pipeline reaches a Diarization Error Rate (DER) of 32.5% on AMI-SDM.SpeakerDiarization.mini test set.\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"file[\"annotation\"]"
],
"execution_count": 13,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
@@ -268,26 +247,26 @@
"id": "r4UydYQkKsxW",
"outputId": "7069d8e5-7dc7-4701-bcd5-1663998cfd1d"
},
"execution_count": 13,
"outputs": [
{
"output_type": "execute_result",
"data": {
"image/png": "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 truncated
"text/plain": [
"<pyannote.core.annotation.Annotation at 0x7f51bdcefb50>"
],
"image/png": "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 truncated
]
},
"execution_count": 13,
"metadata": {},
"execution_count": 13
"output_type": "execute_result"
}
],
"source": [
"file[\"annotation\"]"
]
},
{
"cell_type": "code",
"source": [
"file[\"pretrained pipeline\"]"
],
"execution_count": 14,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
@@ -296,86 +275,94 @@
"id": "s4C7xMQlKwVX",
"outputId": "930c571f-069b-44ad-f87e-ce8d471176a6"
},
"execution_count": 14,
"outputs": [
{
"output_type": "execute_result",
"data": {
"image/png": "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 truncated
"text/plain": [
"<pyannote.core.annotation.Annotation at 0x7f51bdbad1c0>"
],
"image/png": "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 truncated
]
},
"execution_count": 14,
"metadata": {},
"execution_count": 14
"output_type": "execute_result"
}
],
"source": [
"file[\"pretrained pipeline\"]"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qrYuCLLUKALA"
},
"source": [
"## Fine-tuning the segmentation model\n",
"\n",
"When a sufficiently large training set of labeled conversations is available, fine-tuning the internal speaker segmentation model may lead to significant performance boost. \n",
"\n",
"Starting from the pretrained model..."
],
"metadata": {
"id": "qrYuCLLUKALA"
}
]
},
{
"cell_type": "code",
"source": [
"from pyannote.audio import Model\n",
"model = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)"
],
"execution_count": 15,
"metadata": {
"id": "jeUDgr4f55v6"
},
"execution_count": 15,
"outputs": []
"outputs": [],
"source": [
"from pyannote.audio import Model\n",
"model = Model.from_pretrained(\"pyannote/segmentation\", use_auth_token=True)"
]
},
{
"cell_type": "markdown",
"source": [
"... we prepare it for fine-tuning on the training dataset:"
],
"metadata": {
"id": "SAyCf7ontua_"
}
},
"source": [
"... we prepare it for fine-tuning on the training dataset:"
]
},
{
"cell_type": "code",
"source": [
"from pyannote.audio.tasks import Segmentation\n",
"task = Segmentation(dataset, \n",
" duration=model.specifications.duration, \n",
" max_num_speakers=len(model.specifications.classes), \n",
" batch_size=32,\n",
" num_workers=2, \n",
" loss=\"bce\", \n",
" vad_loss=\"bce\")\n",
"model.task = task\n",
"model.setup(stage=\"fit\")"
],
"execution_count": null,
"metadata": {
"id": "Kk_a7ABQ6PPH"
},
"execution_count": null,
"outputs": []
"outputs": [],
"source": [
"from pyannote.audio.tasks import SpeakerDiarization\n",
"task = SpeakerDiarization(\n",
" dataset, \n",
" duration=model.specifications.duration, \n",
" max_num_speakers=len(model.specifications.classes), \n",
" batch_size=32,\n",
" num_workers=2, \n",
" loss=\"bce\", \n",
" vad_loss=\"bce\")\n",
"model.task = task\n",
"model.setup(stage=\"fit\")"
]
},
{
"cell_type": "markdown",
"source": [
"The actual training is done with [`lightning`](https://github.com/Lightning-AI/lightning):"
],
"metadata": {
"id": "TgobhVTKt9sH"
}
},
"source": [
"The actual training is done with [`lightning`](https://github.com/Lightning-AI/lightning):"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "f_bVYrNo6TmI"
},
"outputs": [],
"source": [
"# this takes approximately 15min to run on Google Colab GPU\n",
"from types import MethodType\n",
@@ -423,15 +410,15 @@
" max_epochs=20,\n",
" gradient_clip_val=0.5)\n",
"trainer.fit(model)"
],
"metadata": {
"id": "f_bVYrNo6TmI"
},
"execution_count": null,
"outputs": []
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"id": "830LvZfdd3Rn"
},
"outputs": [],
"source": [
"# save path to the best checkpoint for later use\n",
"finetuned_model = checkpoint.best_model_path\n",
@@ -439,30 +426,22 @@
"# uncomment to download the checkpoint\n",
"#from google.colab import files\n",
"#files.download(finetuned_model)"
],
"metadata": {
"id": "830LvZfdd3Rn"
},
"execution_count": 20,
"outputs": []
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2NVGAIMd-uPI"
},
"source": [
"## Optimizing the pipeline hyper-parameters\n",
"\n",
"The pretrained `pyannote/speaker-diarization` pipeline relies on its own set of hyper-parameters adapted to the internal `pyannote/segmentation` pretrained model:"
],
"metadata": {
"id": "2NVGAIMd-uPI"
}
]
},
{
"cell_type": "code",
"source": [
"pretrained_hyperparameters = pretrained_pipeline.parameters(instantiated=True)\n",
"pretrained_hyperparameters"
],
"execution_count": 23,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
@@ -470,10 +449,8 @@
"id": "8OUIBHP7-xk_",
"outputId": "20b3af76-d2d3-4bf9-eb58-2589f8e86939"
},
"execution_count": 23,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"{'segmentation': {'min_duration_off': 0.5817029604921046,\n",
@@ -483,13 +460,21 @@
" 'threshold': 0.7153814381597874}}"
]
},
"execution_count": 23,
"metadata": {},
"execution_count": 23
"output_type": "execute_result"
}
],
"source": [
"pretrained_hyperparameters = pretrained_pipeline.parameters(instantiated=True)\n",
"pretrained_hyperparameters"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "y1rRE4NqJmb5"
},
"source": [
"There is no reason the above hyper-parameters are optimal for the newly finetuned speaker segmentation model. Let's optimize them:\n",
"\n",
@@ -500,13 +485,15 @@
"* `clustering.min_cluster_size` controls what to do with small speaker clusters. Clusters smaller than that are assigned to the most similar large cluster. `15` is a good default value.\n",
"\n",
"We start by optimizing `segmentation.threshold` by assuming that the subsequent clustering step is perfect (cf. `OracleClustering`)."
],
"metadata": {
"id": "y1rRE4NqJmb5"
}
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "FSWW7bIphgAI"
},
"outputs": [],
"source": [
"# this takes approximately 5min to run on Google Colab GPU\n",
"from pyannote.audio.pipelines import SpeakerDiarization\n",
@@ -527,35 +514,35 @@
"for i, iteration in enumerate(iterations):\n",
" print(f\"Best segmentation threshold so far: {iteration['params']['segmentation']['threshold']}\")\n",
" if i > 20: break # 50 iterations should give slightly better results"
],
"metadata": {
"id": "FSWW7bIphgAI"
},
"execution_count": null,
"outputs": []
]
},
{
"cell_type": "markdown",
"source": [
"Then, we use the optimized value of `segmentation.threshold` and optimize `clustering.threshold`."
],
"metadata": {
"id": "pAUx-1Pw3Uc9"
}
},
"source": [
"Then, we use the optimized value of `segmentation.threshold` and optimize `clustering.threshold`."
]
},
{
"cell_type": "code",
"source": [
"best_segmentation_threshold = optimizer.best_params[\"segmentation\"][\"threshold\"]"
],
"execution_count": 26,
"metadata": {
"id": "CSzOWLL5Q29-"
},
"execution_count": 26,
"outputs": []
"outputs": [],
"source": [
"best_segmentation_threshold = optimizer.best_params[\"segmentation\"][\"threshold\"]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "M_pQkyQ5RCjl"
},
"outputs": [],
"source": [
"# this takes approximately 5min to run on Google Colab GPU\n",
"pipeline = SpeakerDiarization(\n",
@@ -582,35 +569,47 @@
"for i, iteration in enumerate(iterations):\n",
" print(f\"Best clustering threshold so far: {iteration['params']['clustering']['threshold']}\")\n",
" if i > 20: break # 50 iterations should give slightly better results"
],
"metadata": {
"id": "M_pQkyQ5RCjl"
},
"execution_count": null,
"outputs": []
]
},
{
"cell_type": "markdown",
"source": [
"Finally, we use the optimized values of `segmentation.threshold` and `clustering.threshold` to evaluate the performance of the finetuned pipeline:"
],
"metadata": {
"id": "BDA2XT-wAzDO"
}
},
"source": [
"Finally, we use the optimized values of `segmentation.threshold` and `clustering.threshold` to evaluate the performance of the finetuned pipeline:"
]
},
{
"cell_type": "code",
"source": [
"best_clustering_threshold = optimizer.best_params['clustering']['threshold']"
],
"execution_count": 28,
"metadata": {
"id": "GBJv2j1U_5mj"
},
"execution_count": 28,
"outputs": []
"outputs": [],
"source": [
"best_clustering_threshold = optimizer.best_params['clustering']['threshold']"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "ir1VUqNEimcN",
"outputId": "d8edfb16-8f97-4d84-d4d2-3066d8b7c791"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The finetuned pipeline reaches a Diarization Error Rate (DER) of 26.6% on AMI-SDM.SpeakerDiarization.mini test set.\n"
]
}
],
"source": [
"# this takes approximately 2min to run on Google Colab GPU\n",
"finetuned_pipeline = SpeakerDiarization(\n",
@@ -642,30 +641,11 @@
" metric(file[\"annotation\"], file[\"finetuned pipeline\"], uem=file[\"annotated\"])\n",
"\n",
"print(f\"The finetuned pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.\")"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "ir1VUqNEimcN",
"outputId": "d8edfb16-8f97-4d84-d4d2-3066d8b7c791"
},
"execution_count": 35,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"The finetuned pipeline reaches a Diarization Error Rate (DER) of 26.6% on AMI-SDM.SpeakerDiarization.mini test set.\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"file[\"finetuned pipeline\"]"
],
"execution_count": 37,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
@@ -674,26 +654,26 @@
"id": "LFvNtdZTBDZh",
"outputId": "f72da25d-7df7-4d8f-97b1-b5ca0f2febe7"
},
"execution_count": 37,
"outputs": [
{
"output_type": "execute_result",
"data": {
"image/png": "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 truncated
"text/plain": [
"<pyannote.core.annotation.Annotation at 0x7f52d9dfc970>"
],
"image/png": "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 truncated
]
},
"execution_count": 37,
"metadata": {},
"execution_count": 37
"output_type": "execute_result"
}
],
"source": [
"file[\"finetuned pipeline\"]"
]
},
{
"cell_type": "code",
"source": [
"file[\"annotation\"]"
],
"execution_count": 38,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
@@ -702,23 +682,28 @@
"id": "odzLUrqaBHgV",
"outputId": "1864ccc7-076e-41bf-ba63-13df32d57fda"
},
"execution_count": 38,
"outputs": [
{
"output_type": "execute_result",
"data": {
"image/png": "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 truncated
"text/plain": [
"<pyannote.core.annotation.Annotation at 0x7f51bcebc3d0>"
],
"image/png": "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 truncated
]
},
"execution_count": 38,
"metadata": {},
"execution_count": 38
"output_type": "execute_result"
}
],
"source": [
"file[\"annotation\"]"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "muYEOZ36VJo5"
},
"source": [
"## Conclusion\n",
"\n",
@@ -735,10 +720,26 @@
"For technical questions and bug reports, please check [pyannote.audio](https://github.com/pyannote/pyannote-audio) Github repository so that my (or anyone's) public answer benefits other people as well. \n",
"\n",
"For scientific consulting enquiries, please contact [me](herve@niderb.fr)."
],
"metadata": {
"id": "muYEOZ36VJo5"
}
]
}
]
}
],
"metadata": {
"accelerator": "GPU",
"colab": {
"authorship_tag": "ABX9TyMc87txSanOjHXPQP0Zpu9J",
"include_colab_link": true,
"provenance": [],
"toc_visible": true
},
"gpuClass": "standard",
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
+2 -2
View File
@@ -378,8 +378,8 @@
"metadata": {},
"outputs": [],
"source": [
"from pyannote.audio.tasks import Segmentation\n",
"seg_task = Segmentation(ami, duration=5.0, max_num_speakers=4)"
"from pyannote.audio.tasks import SpeakerDiarization\n",
"seg_task = SpeakerDiarization(ami, duration=5.0, max_num_speakers=4)"
]
},
{