mirror of
https://github.com/pyannote/pyannote-audio.git
synced 2026-11-20 13:07:51 +09:00
65 KiB
65 KiB
In [ ]:
!pip install -qq pyannote.audio==2.1.1
!pip install -qq richIn [ ]:
# download AMI-SDM mini corpus
%cd /content/
!git clone https://github.com/pyannote/AMI-diarization-setup
%cd /content/AMI-diarization-setup/pyannote/
!bash download_ami_sdm_mini.shIn [9]:
!PYANNOTE_DATABASE_CONFIG="/content/AMI-diarization-setup/pyannote/database.yml" pyannote-database info AMI-SDM.SpeakerDiarization.mini[92m[1m[4mtrain[0m 28 files 8h46m annotated 6h11m of speech (71%) 112 speakers [92m[1m[4mdevelopment[0m 3 files 0h56m annotated 0h40m of speech (72%) 12 speakers [92m[1m[4mtest[0m 3 files 0h56m annotated 0h39m of speech (70%) 12 speakers
In [10]:
from pyannote.database import registry, FileFinder
registry.load_database("AMI-diarization-setup/pyannote/database.yml")
dataset = registry.get_protocol("AMI-SDM.SpeakerDiarization.mini", {"audio": FileFinder()})In [ ]:
from huggingface_hub import notebook_login
notebook_login()In [11]:
from pyannote.audio import Pipeline
pretrained_pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization", token=True) In [32]:
# this takes approximately 2min to run on Google Colab GPU
from pyannote.metrics.diarization import DiarizationErrorRate
metric = DiarizationErrorRate()
for file in dataset.test():
# apply pretrained pipeline
file["pretrained pipeline"] = pretrained_pipeline(file)
# evaluate its performance
metric(file["annotation"], file["pretrained pipeline"], uem=file["annotated"])
print(f"The pretrained pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.")The pretrained pipeline reaches a Diarization Error Rate (DER) of 32.5% on AMI-SDM.SpeakerDiarization.mini test set.
In [13]:
file["annotation"]Out [13]:
In [14]:
file["pretrained pipeline"]Out [14]:
In [15]:
from pyannote.audio import Model
model = Model.from_pretrained("pyannote/segmentation", token=True)In [ ]:
from pyannote.audio.tasks import Segmentation
task = Segmentation(
dataset,
duration=model.specifications.duration,
max_num_speakers=len(model.specifications.classes),
batch_size=32,
num_workers=2,
loss="bce",
vad_loss="bce")
model.task = task
model.prepare_data()
model.setup()In [ ]:
# this takes approximately 15min to run on Google Colab GPU
from types import MethodType
from torch.optim import Adam
from pytorch_lightning.callbacks import (
EarlyStopping,
ModelCheckpoint,
RichProgressBar,
)
# we use Adam optimizer with 1e-4 learning rate
def configure_optimizers(self):
return Adam(self.parameters(), lr=1e-4)
model.configure_optimizers = MethodType(configure_optimizers, model)
# we monitor diarization error rate on the validation set
# and use to keep the best checkpoint and stop early
monitor, direction = task.val_monitor
checkpoint = ModelCheckpoint(
monitor=monitor,
mode=direction,
save_top_k=1,
every_n_epochs=1,
save_last=False,
save_weights_only=False,
filename="{epoch}",
verbose=False,
)
early_stopping = EarlyStopping(
monitor=monitor,
mode=direction,
min_delta=0.0,
patience=10,
strict=True,
verbose=False,
)
callbacks = [RichProgressBar(), checkpoint, early_stopping]
# we train for at most 20 epochs (might be shorter in case of early stopping)
from pytorch_lightning import Trainer
trainer = Trainer(accelerator="gpu",
callbacks=callbacks,
max_epochs=20,
gradient_clip_val=0.5)
trainer.fit(model)In [20]:
# save path to the best checkpoint for later use
finetuned_model = checkpoint.best_model_path
# uncomment to download the checkpoint
#from google.colab import files
#files.download(finetuned_model)In [23]:
pretrained_hyperparameters = pretrained_pipeline.parameters(instantiated=True)
pretrained_hyperparametersOut [23]:
{'segmentation': {'min_duration_off': 0.5817029604921046,
'threshold': 0.4442333667381752},
'clustering': {'method': 'centroid',
'min_cluster_size': 15,
'threshold': 0.7153814381597874}}In [ ]:
# this takes approximately 5min to run on Google Colab GPU
from pyannote.audio.pipelines import SpeakerDiarization
from pyannote.pipeline import Optimizer
pipeline = SpeakerDiarization(
segmentation=finetuned_model,
clustering="OracleClustering",
)
# as reported in the technical report, min_duration_off can safely be set to 0.0
pipeline.freeze({"segmentation": {"min_duration_off": 0.0}})
optimizer = Optimizer(pipeline)
dev_set = list(dataset.development())
iterations = optimizer.tune_iter(dev_set, show_progress=False)
best_loss = 1.0
for i, iteration in enumerate(iterations):
print(f"Best segmentation threshold so far: {iteration['params']['segmentation']['threshold']}")
if i > 20: break # 50 iterations should give slightly better resultsIn [26]:
best_segmentation_threshold = optimizer.best_params["segmentation"]["threshold"]In [ ]:
# this takes approximately 5min to run on Google Colab GPU
pipeline = SpeakerDiarization(
segmentation=finetuned_model,
embedding=pretrained_pipeline.embedding,
embedding_exclude_overlap=pretrained_pipeline.embedding_exclude_overlap,
clustering=pretrained_pipeline.klustering,
)
pipeline.freeze({
"segmentation": {
"threshold": best_segmentation_threshold,
"min_duration_off": 0.0,
},
"clustering": {
"method": "centroid",
"min_cluster_size": 15,
},
})
optimizer = Optimizer(pipeline)
iterations = optimizer.tune_iter(dev_set, show_progress=False)
best_loss = 1.0
for i, iteration in enumerate(iterations):
print(f"Best clustering threshold so far: {iteration['params']['clustering']['threshold']}")
if i > 20: break # 50 iterations should give slightly better resultsIn [28]:
best_clustering_threshold = optimizer.best_params['clustering']['threshold']In [35]:
# this takes approximately 2min to run on Google Colab GPU
finetuned_pipeline = SpeakerDiarization(
segmentation=finetuned_model,
embedding=pretrained_pipeline.embedding,
embedding_exclude_overlap=pretrained_pipeline.embedding_exclude_overlap,
clustering=pretrained_pipeline.klustering,
)
finetuned_pipeline.instantiate({
"segmentation": {
"threshold": best_segmentation_threshold,
"min_duration_off": 0.0,
},
"clustering": {
"method": "centroid",
"min_cluster_size": 15,
"threshold": best_clustering_threshold,
},
})
metric = DiarizationErrorRate()
for file in dataset.test():
# apply finetuned pipeline
file["finetuned pipeline"] = finetuned_pipeline(file)
# evaluate its performance
metric(file["annotation"], file["finetuned pipeline"], uem=file["annotated"])
print(f"The finetuned pipeline reaches a Diarization Error Rate (DER) of {100 * abs(metric):.1f}% on {dataset.name} test set.")The finetuned pipeline reaches a Diarization Error Rate (DER) of 26.6% on AMI-SDM.SpeakerDiarization.mini test set.
In [37]:
file["finetuned pipeline"]Out [37]:
In [38]:
file["annotation"]Out [38]: