Entraîner des modèles de parole et d'audio sur vos annotations

Nouveauté de la v2.14.0

Ce tutoriel entraîne des modèles de parole et d'audio sur les réponses que les annotateurs donnent dans Potato et renvoie la sortie de chaque modèle aux annotateurs sous forme de pré-étiquettes. La page s'adresse à un responsable d'étude qui corrige déjà des transcriptions, des tours de parole ou des cris d'animaux dans Potato et veut un modèle qui apprend de ces corrections. Le parcours principal importe un fichier de diarisation des locuteurs, fait corriger les tours de parole par les annotateurs, entraîne un modèle de diarisation sur les tours corrigés et exporte les corrections en RTTM. Trois sections plus courtes affinent ensuite Whisper sur des tours de transcription corrigés, entraînent un détecteur de boîtes sur des spectrogrammes et entraînent un étiqueteur d'événements sonores sur la forme d'onde. Pour la boucle d'entraînement en général, lisez d'abord la vue d'ensemble de l'entraînement de modèles, puis Entraîner votre premier modèle si vous n'avez jamais lancé d'exécution.

Les quatre modules d'entraînement pour l'audio

Chaque module d'entraînement apprend d'un seul type de schéma, et la page Training ne propose pour un schéma que les modules qui lui conviennent :

Chaque module pour l'audio lit les enregistrements dans des fichiers sur le disque du serveur que soundfile ouvre, par exemple WAV, FLAC ou OGG, et MP3 avec une libsndfile récente. Un chemin tel que /media/meet000.wav désigne un fichier du dossier media/ du répertoire de la tâche, le dossier d'où la page d'annotation lit les enregistrements. Un item dont l'enregistrement est une URL http(s) est écarté de l'entraînement avec un avertissement. Téléchargez les enregistrements distants dans media/ avant d'entraîner. La référence des modules d'entraînement liste chaque paramètre.

Installez les modules d'entraînement dans l'environnement qui exécute Potato :

pip install "potato-annotation[train-audio]"

L'extra [train-audio] installe PyTorch, transformers et soundfile. Les détecteurs sur spectrogrammes ont besoin de [train-vision] à la place, ou de pip install "potato-annotation[train]" pour tous les modules pour le texte, les images, l'audio et les LLM d'un coup. Un module dont les paquets manquent reste sur la page Training avec la mention « not installed » et la commande qui installe les paquets.

Importer une diarisation sous forme de fichier RTTM

La diarisation des locuteurs découpe un enregistrement en tours selon qui parle. pyannote et NeMo écrivent les diarisations en RTTM, un format texte avec une ligne SPEAKER par tour, et dscore et md-eval évaluent les fichiers RTTM. Une ligne nomme l'identifiant de fichier de l'enregistrement, le canal, le début et la durée du tour en secondes, ainsi que le locuteur :

SPEAKER meet000 1 0.200 1.055 <NA> <NA> SPEAKER_01 <NA> <NA>
SPEAKER meet000 1 1.539 0.755 <NA> <NA> SPEAKER_00 <NA> <NA>

Placez les fichiers RTTM et les enregistrements dans un même dossier, chaque enregistrement portant le nom de son identifiant de fichier (meet000.wav pour meet000), et importez le dossier :

potato import -f rttm -i diarization/ -o interviews \
  --speaker-map "SPEAKER_00=Interviewer,SPEAKER_01=Guest"

L'importeur crée un item par enregistrement, copie l'enregistrement dans interviews/media/ et écrit config.yaml, data/diarization.jsonl et un README. Sur le projet de test à 16 enregistrements derrière cette page, la ligne de résumé indiquait :

Imported 16 item(s), 1 question(s), 0 answer(s) from 0 annotator(s), and 16 model suggestion(s) on 16 item(s) from RTTM speaker diarization.

L'importeur accepte trois options qui lui sont propres :

• --rttm-scheme audio|tiered choisit le schéma sur lequel les tours atterrissent. La valeur par défaut audio crée un schéma audio_annotation nommé speakers dont les étiquettes sont les locuteurs. tiered crée un schéma tiered_annotation nommé tiers avec un seul niveau speaker. Utilisez tiered pour une étude qui transcrit ensuite tour par tour.
• --speaker-map renomme les locuteurs, et un locuteur que la table ne nomme pas garde son nom RTTM. N'utilisez la table que lorsqu'un nom désigne la même personne dans tous les enregistrements. Un système de diarisation numérote les locuteurs à l'intérieur de chaque fichier, et SPEAKER_00 dans un entretien et SPEAKER_00 dans le suivant peuvent être des personnes différentes.
• --media-dir DIR nomme le dossier qui contient les enregistrements quand ils ne sont pas à côté des fichiers RTTM.

L'importeur ne lit que les lignes SPEAKER et compte les autres types de lignes comme ignorés. Les tours de durée nulle, les tours au début négatif, les tours sans nom de locuteur (<NA>) et les tours listés deux fois sont aussi ignorés. Le RTTM sépare les champs par des espaces, et l'importeur ne lit un nom de locuteur qui contient une espace que jusqu'à l'espace, avec un avertissement. Importer un projet traite l'import en détail.

La configuration de diarisation

La configuration générée montre déjà les tours importés comme pré-annotations. Ajoutez une clé d'administration et un bloc model_training à la fin de config.yaml. Le fichier complet ci-dessous passe python -m potato.validate_cli config.yaml --strict :

port: 8000
annotation_task_name: diarization (imported)
task_dir: .
output_annotation_dir: annotation_output/
data_files:
- data/diarization.jsonl
item_properties:
  id_key: id
  text_key: text
user_config:
  allow_all_users: true
  users: []
site_dir: default
pre_annotation:
  enabled: true
  field: predictions
  allow_modification: true
annotation_schemes:
- annotation_type: audio_annotation
  name: speakers
  description: Check and correct who speaks when.
  source_field: audio_url
  mode: label
  labels:
  - name: Guest
  - name: Interviewer
admin_api_key: "change-me"
model_training:
  enabled: true

L'importeur trie les étiquettes de locuteurs par ordre alphabétique, et Guest vient avant Interviewer. L'écriture en retour du modèle va par défaut dans le champ d'item predictions, le même champ que lit le bloc pre_annotation de l'import. Potato refuse de démarrer quand un bloc pre_annotation activé nomme un autre champ que writeback.field, car aucune pré-étiquette d'entraînement n'apparaîtrait alors. Laissez writeback hors de la configuration jusqu'à ce que la première exécution ait un score sur items réservés qui vaille la peine d'être montré aux annotateurs.

Corriger les tours de parole

Démarrez le serveur depuis le dossier du projet :

cd interviews
potato start config.yaml -p 8000

Chaque enregistrement s'ouvre avec les tours du système de diarisation dessinés sur la forme d'onde. Les annotateurs déplacent les bords d'un tour, changent le locuteur d'un tour, suppriment un tour de bruit et dessinent tout tour que le système de diarisation a manqué. Les pré-annotations ne sont enregistrées que lorsqu'un annotateur enregistre l'item. Un item que personne n'a ouvert n'a pas de réponse et n'entraîne rien. Annotation de diarisation des locuteurs traite des commandes de la forme d'onde et des raccourcis clavier.

Le module diarization demande au moins 4 enregistrements annotés dans la partition train, et la partition par défaut place environ 70 % des enregistrements étiquetés dans train. Corrigez au moins 8 enregistrements avant la première exécution, et davantage pour un score sur items réservés fiable.

Entraîner le modèle de diarisation

Ouvrez http://localhost:8000/admin, saisissez la clé d'administration et allez à /admin/training. Choisissez diarization comme module d'entraînement et speakers comme schéma. La page Training propose aussi hf-audio-tagger pour le même schéma. hf-audio-tagger convient à des étiquettes qui nomment des types de sons plutôt que des locuteurs. Pour des entretiens à deux personnes, définissez le champ Parameters à :

{"max_speakers": 2}

Cliquez sur Train now. La même exécution peut démarrer depuis un script avec la clé d'administration :

curl -X POST -H "X-API-Key: change-me" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "diarization", "schemas": ["speakers"], "params": {"max_speakers": 2}}'

diarization suit la recette du modèle de segmentation de pyannote (Bredin et Laurent, 2021) sans pyannote ni les poids à accès restreint de pyannote, et affine WavLM (microsoft/wavlm-base-plus) avec un classifieur de trames pour au plus max_speakers locuteurs. Le modèle voit chunk_s secondes d'audio à la fois, 10 par défaut. La perte de chaque fragment est calculée sous la meilleure mise en correspondance des sorties de locuteurs du modèle avec les locuteurs annotés du fragment. La mise en correspondance compte, car un nom de locuteur renvoie à des personnes différentes selon les enregistrements, et un classifieur sur des noms n'aurait aucune cible cohérente. Les paramètres ci-dessous façonnent les tours prédits :

L'entraînement à distance envoie une exécution à un serveur GPU par ssh ou à un cluster SLURM.

Lire le score de diarisation

La page de l'exécution et GET /admin/training/api/status rapportent le score de l'exécution sur les enregistrements réservés. Pour diarization, le score principal est diarization_accuracy, défini comme 1 moins le taux d'erreur de diarisation (DER) et borné à 0. Le DER additionne la parole manquée, la fausse alarme et la confusion de locuteurs, et divise la somme par la parole annotée. Potato mesure le DER sur une grille de 10 ms sans marge, sous la meilleure correspondance biunivoque entre locuteurs prédits et annotés. L'exécution rapporte aussi les trois types d'erreur séparément. Lisez les trois nombres pour voir si le modèle manque de la parole, en invente ou confond des locuteurs. Le DER ignore si un tour s'appelle Interviewer ou SPEAKER_01 et compte si le locuteur change aux bons moments.

Un nom de métrique inclut la partition, comme dans val_der ou test_diarization_accuracy. Un enregistrement qui a des tours annotés et aucune prédiction compte comme faux. Un modèle ne peut donc pas améliorer son score en sautant les enregistrements difficiles.

Publier les tours prédits

Une fois que le score sur items réservés justifie de montrer les tours du modèle aux annotateurs, ajoutez le schéma à writeback et redémarrez le serveur :

model_training:
  enabled: true
  writeback:
    schemas: [speakers]
    include_unlabeled: true

include_unlabeled: true prédit aussi sur les enregistrements que personne n'a encore corrigés. Sans ce réglage, une exécution ne prédit que sur les enregistrements réservés val et test. Entraînez de nouveau après le redémarrage. Le rapport d'écriture en retour de GET /admin/training/api/status donne le compte. Sur le projet de test, le rapport indiquait « Published 7 prediction(s) as prelabels. » pour 3 enregistrements val et 4 enregistrements non corrigés, et les enregistrements de la partition train ont gardé les tours RTTM importés.

Le modèle nomme les locuteurs dans l'ordre de première prise de parole dans chaque enregistrement, en utilisant d'abord les étiquettes du schéma puis SPEAKER_00, SPEAKER_01, et ainsi de suite. Le premier locuteur entendu dans chaque enregistrement est donc Guest dans ce projet, que cette personne soit ou non l'invité. Le modèle n'a pas de plongements de voix pour reconnaître une personne. Un locuteur silencieux pendant le recouvrement entre deux fragments puis qui reparle plus tard reçoit un nouveau nom. Dites aux annotateurs de vérifier le nom du locuteur de chaque tour prédit, et pas seulement les bords du tour. Le modèle dans la boucle traite de la relecture des pré-étiquettes en commençant par les moins sûres et du réentraînement au fil des corrections.

Exporter les tours corrigés en RTTM

L'export segments réécrit les tours corrigés en RTTM, un fichier par annotateur :

python -m potato.export --config config.yaml --format segments --output ./export/

L'export écrit export/segments.jsonl, une ligne par tour, et export/rttm/<annotator>.rttm. L'identifiant de fichier de chaque ligne RTTM est le nom de l'enregistrement sans son extension. pyannote.metrics, dscore ou md-eval peuvent alors évaluer la sortie d'origine du système de diarisation par rapport au fichier corrigé sans modification. Sur le projet de test, les premières lignes de export/rttm/ana.rttm indiquent :

SPEAKER meet000 1 0.200 1.055 <NA> <NA> Guest <NA> <NA>
SPEAKER meet000 1 1.539 0.755 <NA> <NA> Interviewer <NA> <NA>

Diarisation sur un niveau de locuteurs

Importez avec --rttm-scheme tiered quand les annotateurs ajouteront d'autres niveaux, comme un niveau de transcription, à la même ligne de temps :

potato import -f rttm -i diarization/ -o interviews --rttm-scheme tiered

L'import écrit un schéma tiered_annotation nommé tiers avec un seul niveau speaker. Ajoutez admin_api_key et model_training comme ci-dessus, avec schemas: [tiers] sous writeback, et la configuration passe validate_cli --strict. diarization s'entraîne sur le niveau des locuteurs et réécrit les tours prédits sur le même niveau. Le module choisit le niveau nommé speaker ou speakers. À défaut, il choisit l'unique niveau dont le nom contient « speaker », et un niveau nommé non-speaker ne compte pas. Le dernier recours est l'unique niveau qui a des étiquettes. Quand deux niveaux conviennent, ou que plusieurs niveaux ont des étiquettes sans qu'aucun soit nommé pour des locuteurs, l'exécution écarte les enregistrements avec un avertissement qui nomme les niveaux.

Affiner Whisper sur des transcriptions corrigées

whisper-asr affine Whisper sur les tours de transcription que les annotateurs ont corrigés, puis suggère des corrections sur les tours que personne n'a vérifiés. La section part d'un dossier d'enregistrements sans transcription.

Transcrire les enregistrements

Placez les enregistrements dans le dossier media/ du projet et transcrivez-les sur la machine du serveur :

pip install "potato-annotation[transcribe]"
potato transcripts media --transcribe --asr-model small.en --asr-word-timestamps \
  --media-url-prefix /media -o data/interviews.json

potato transcripts --transcribe exécute WhisperX quand WhisperX est installé et fonctionne sur la machine, et faster-whisper sinon. L'extra [transcribe] installe faster-whisper, et WhisperX s'installe à part (pip install whisperx) et apporte son propre PyTorch. Potato se rabat sur faster-whisper quand WhisperX est absent, ne s'importe pas, ne peut pas tourner sur l'appareil ou ne peut pas charger le modèle, et le résumé nomme le moteur utilisé pour chaque fichier. --asr-engine whisperx ou --asr-engine faster-whisper exécute un seul moteur sans repli. --media-url-prefix /media écrit le chemin de chaque enregistrement sous la forme /media/<file>, l'adresse d'où la page d'annotation lit l'enregistrement.

--asr-word-timestamps date chaque mot par alignement forcé et permet à WhisperX de couper un segment à la fin d'une phrase. Sur les enregistrements de test, WhisperX a renvoyé un tour par enregistrement de 10 secondes sans l'option et trois tours par enregistrement avec l'option. Des tours plus courts donnent plus d'exemples à whisper-asr, et la fenêtre d'entrée de Whisper est de 30 secondes. Formats de transcription et Comment annoter des transcriptions Whisper traitent des options de transcription, des étiquettes de locuteurs et des sorties Whisper existantes.

La configuration de transcription

Un schéma speech_transcript montre chaque tour de la transcription avec sa plage de temps et une zone de correction. La configuration complète ci-dessous passe validate_cli --strict :

annotation_task_name: "Interview transcript correction"
task_dir: .
output_annotation_dir: annotation_output/
data_files:
  - data/interviews.json
item_properties:
  id_key: id
  text_key: conversation
admin_api_key: "change-me"
annotation_schemes:
  - annotation_type: speech_transcript
    name: transcript
    description: "Play each turn and type the right text wherever the transcript is wrong."
    segments_key: conversation
    error_types: [asr_error]
model_training:
  enabled: true
  trainer_params:
    whisper-asr:
      model_name: openai/whisper-small
      language: en

segments_key: conversation nomme le champ sous lequel potato transcripts écrit la transcription. error_types: [asr_error] ne laisse qu'un drapeau d'erreur, car l'étude ne porte que sur les erreurs de transcription. language: en fixe la langue pour l'entraînement et la prédiction. Sans ce réglage, un Whisper multilingue détecte la langue une seule fois sur au plus 16 tours d'entraînement, et le journal de l'exécution avertit quand moins de trois tours échantillonnés sur quatre s'accordent.

Les tours corrigés comme exemples d'entraînement

Chaque tour corrigé est un exemple, composé de l'audio du tour découpé dans l'enregistrement selon le début et la fin du tour, avec le texte corrigé. Un tour que personne n'a corrigé n'est pas un exemple, car le schéma n'enregistre que les tours qu'un annotateur a touchés, et un tour intact peut être juste ou ne pas avoir été lu. Un tour signalé sans correction n'est pas non plus un exemple. Les tours de plus de 30 secondes sont écartés avec un avertissement. Le module refuse de tourner avec moins de 10 tours corrigés dans la partition train.

Corrigez chaque tour faux des enregistrements que vous ouvrez, car le score sur items réservés est calculé sur les tours corrigés. Sur les 12 enregistrements de test, WhisperX avec tiny.en s'est trompé sur 11 tours sur 36, avec des erreurs telles que « Epsilanti » pour Ypsilanti, « Cary Town » pour Kerrytown et un « I » perdu au début d'un tour.

Entraîner et comparer à la transcription

Choisissez whisper-asr et le schéma transcript sur la page Training et cliquez sur Train now. Le score principal est word_accuracy, soit 1 moins le taux d'erreur sur les mots (WER) sur les tours corrigés. L'exécution rapporte aussi wer_asr, le WER de la transcription d'origine sur les mêmes tours, et un tour que le modèle a laissé tel quel est évalué comme le texte de la transcription. Comparez les deux nombres avant de publier quoi que ce soit. Un modèle affiné ne vaut la peine d'être montré aux annotateurs que lorsque son WER est inférieur à wer_asr.

L'exécution de test derrière cette page montre pourquoi la comparaison compte. Avec 8 tours corrigés dans train, min_instances abaissé à 4 et openai/whisper-tiny entraîné pendant 3 époques, l'exécution a obtenu un WER de 0,31 sur test contre 0,19 pour la transcription d'origine. Un modèle de ce niveau remplacerait du texte juste par du texte faux. Recueillez plus de corrections, ou partez d'un point de contrôle plus grand, et entraînez de nouveau avant d'ajouter writeback.

Publier des corrections suggérées

Une fois que le modèle bat la transcription, ajoutez le schéma à writeback, redémarrez et entraînez de nouveau :

model_training:
  enabled: true
  trainer_params:
    whisper-asr:
      model_name: openai/whisper-small
      language: en
  writeback:
    schemas: [transcript]
    include_unlabeled: true

La prédiction transcrit chaque tour de chaque enregistrement réservé et non étiqueté. Un tour dont le nouveau texte diffère de la transcription devient une correction suggérée, signalée asr_error, avec la probabilité moyenne des jetons du modèle comme confiance de la suggestion. Les suggestions remplissent les zones de correction, et un annotateur garde, modifie ou efface chaque suggestion.

Transcrire de nouveaux enregistrements avec le modèle affiné

Par défaut, l'exécution écrit aussi ct2/, une copie CTranslate2 en int8 du modèle, parmi les artefacts de l'exécution. La copie demande le paquet ctranslate2, que l'extra [transcribe] installe avec faster-whisper. Passez le chemin de la copie à potato transcripts pour transcrire le lot d'enregistrements suivant avec le modèle affiné :

potato transcripts media/batch2 --transcribe \
  --asr-model annotation_output/training/runs/<run_id>/artifacts/ct2 \
  --media-url-prefix /media/batch2 -o data/batch2.json

WhisperX et faster-whisper chargent tous deux la copie. La page de l'exécution montre l'identifiant de chaque exécution, et la configuration décrit les dossiers des exécutions.

Détecter des cris sur des spectrogrammes

Un schéma spectrogram_annotation fait dessiner aux annotateurs des boîtes temps-fréquence autour des cris. torchvision-detect et ultralytics-detect s'entraînent sur ces boîtes en rendant chaque enregistrement sous forme d'image de spectrogramme, comme le widget dessine le spectrogramme. Le rendu place la fréquence sur un axe linéaire de min_freq à max_freq du schéma, ou à la moitié de la fréquence d'échantillonnage quand max_freq n'est pas défini, sur 256 pixels de haut et 100 pixels par seconde. Chaque boîte devient une boîte d'image. Le temps et la fréquence se projettent linéairement sur les pixels. L'IoU d'une boîte sur l'image est donc égal à son IoU en secondes par hertz. Une boîte sans plage de fréquences, comme en donne une étiquette Audacity ou une ligne BirdNET, couvre toute la bande. Un enregistrement de 41 secondes ou plus est rendu sur au moins 4 096 pixels de large, découpé en fenêtres puis recousu.

Les boîtes viennent d'ordinaire d'un import. potato import lit les tables de sélection Raven, les pistes d'étiquettes Audacity et la sortie de BirdNET-Analyzer dans un projet spectrogram_annotation, comme le décrivent la bioacoustique dans Potato et Vérifier les détections de BirdNET sur un spectrogramme. Les modules d'entraînement apprennent des boîtes que les annotateurs ont dessinées ou corrigées, et les détecteurs lisent les pixels du spectrogramme plutôt que les plongements de BirdNET ou de Perch.

La configuration ci-dessous passe validate_cli --strict et fixe le score_threshold du détecteur à 0,5 :

annotation_task_name: "Dawn chorus calls"
task_dir: .
output_annotation_dir: annotation_output/
data_files:
  - data/recordings.jsonl
item_properties:
  id_key: id
  text_key: id
admin_api_key: "change-me"
annotation_schemes:
  - annotation_type: spectrogram_annotation
    name: calls
    description: "Draw a box around each call and pick its type."
    source_field: audio_url
    max_freq: 8000
    labels:
      - name: whistle
      - name: chirp
model_training:
  enabled: true
  trainer_params:
    torchvision-detect:
      score_threshold: 0.5
  writeback:
    schemas: [calls]
    include_unlabeled: true

Le spectre d'un enregistrement à 16 kHz s'arrête à 8 kHz, et max_freq: 8000 montre toute la bande. Le score_threshold par défaut de 0,25 garde davantage d'hypothèses du détecteur. Sur le projet de test à 24 enregistrements, torchvision-detect au seuil par défaut a prédit 34 boîtes pour 10 cris annotés sur les enregistrements de test, et chaque boîte en trop est une boîte de plus à supprimer pour un annotateur.

Chaque ligne de données nomme son enregistrement, comme dans {"id": "site_00", "audio_url": "/media/site_00.wav"}. Un détecteur ne s'entraîne que sur les enregistrements qui ont au moins une boîte, car un enregistrement sans boîte ressemble à un enregistrement que personne n'a vérifié. Les détecteurs demandent 20 enregistrements annotés dans la partition train par défaut (min_instances).

torchvision-detect affine un Faster R-CNN à partir des poids COCO de torchvision, et ultralytics-detect entraîne un détecteur YOLO. Le détecteur YOLO est plus rapide à entraîner et à exécuter. Ultralytics est sous licence AGPL-3.0, et un modèle entraîné et distribué avec Ultralytics est soumis aux conditions de l'AGPL. La page Training vous demande de confirmer la licence avant une exécution ultralytics-detect, et une exécution par l'API demande "accept_licence": true. Les deux détecteurs sont évalués par le mAP à un IoU de 0,5 sur le spectrogramme rendu, et les deux réécrivent les boîtes prédites dans start_s, end_s, low_hz et high_hz, marquées comme sortie du modèle, pour préremplir le widget. Les modèles de vision traitent des paramètres des détecteurs et du découpage en tuiles.

Étiqueter des événements sonores avec hf-audio-tagger

hf-audio-tagger apprend les segments de temps étiquetés d'un schéma audio_annotation, comme la parole, la musique, les cris ou les toux. Le module affine un encodeur de parole, facebook/wav2vec2-base par défaut, pour dire quelles étiquettes sont actives dans chaque trame d'environ 20 ms. Chaque étiquette est évaluée séparément. Des segments qui se chevauchent avec des étiquettes différentes sont donc appris tels qu'annotés. Les segments prédits reviennent sous forme de régions modifiables sur la forme d'onde. La configuration ci-dessous passe validate_cli --strict :

annotation_task_name: "Dawn chorus events"
task_dir: .
output_annotation_dir: annotation_output/
data_files:
  - data/recordings.jsonl
item_properties:
  id_key: id
  text_key: id
admin_api_key: "change-me"
annotation_schemes:
  - annotation_type: audio_annotation
    name: events
    description: "Mark every call on the waveform and pick its type."
    source_field: audio_url
    mode: label
    labels:
      - name: whistle
      - name: chirp
model_training:
  enabled: true
  writeback:
    schemas: [events]
    include_unlabeled: true

L'étiqueteur traite tout passage d'un enregistrement qu'aucun annotateur n'a marqué comme « aucune étiquette ici ». L'hypothèse convient à une étude où les annotateurs marquent chaque événement, et la description du schéma ci-dessus demande « every call ». Là où les annotateurs ne marquent que certains événements, le modèle apprend à manquer les autres. Le score principal est le F1 des segments, où un segment prédit correspond à un segment annoté de même étiquette à un IoU d'au moins 0,5, et l'exécution rapporte aussi l'IoU moyen des segments appariés. Le module demande 10 enregistrements annotés dans la partition train par défaut.

La page Training propose à la fois hf-audio-tagger et diarization pour un schéma audio_annotation. Choisissez hf-audio-tagger quand une étiquette nomme un type de son et signifie la même chose dans tous les enregistrements. Choisissez diarization quand les étiquettes sont des locuteurs dont les noms sont locaux à chaque enregistrement.

Les exécutions derrière cette page

Les commandes et les configurations de cette page ont été exécutées sur Potato 2.14.0 sur un portable, avec les modèles plus petits nommés ci-dessous. Le parcours de diarisation a tourné de bout en bout, depuis un import RTTM de 16 enregistrements synthétiques à deux locuteurs dont 20 % des tours avaient un mauvais locuteur, en passant par des corrections sur 12 enregistrements, une exécution diarization et l'écriture en retour, jusqu'à l'export segments. L'exécution a utilisé un encodeur de test à une couche à la place de WavLM. Le score de l'exécution ne dit donc rien sur de la vraie parole. La section sur Whisper a utilisé 12 enregistrements de parole synthétisée, transcrits par WhisperX avec tiny.en et affinés à partir de openai/whisper-tiny. Les sections sur les spectrogrammes et sur l'étiqueteur ont utilisé 24 enregistrements synthétiques de tonalités à 3 kHz et 6 kHz. Chaque bloc de configuration passe python -m potato.validate_cli --strict.

Pour aller plus loin

• Vue d'ensemble de l'entraînement de modèles explique la boucle d'entraînement, la page Training et les scores sur items réservés.
• Modules d'entraînement liste chaque module avec ses schémas, son installation et ses paramètres.
• Configuration documente chaque clé model_training, l'écriture en retour et les routes.
• Le modèle dans la boucle traite de la relecture des pré-étiquettes et du réentraînement automatique.
• Annotation audio prépare des tâches de classification, d'événements, de transcription et de diarisation.
• Formats de transcription liste chaque format de transcription que Potato lit.
• La référence en amont documente diarization, whisper-asr, hf-audio-tagger et les spectrogrammes paramètre par paramètre.

Références

• Bain, M., Huh, J., Han, T., and Zisserman, A. (2023). WhisperX: Time-Accurate Speech Transcription of Long-Form Audio. Interspeech 2023, 4489–4493. doi:10.21437/Interspeech.2023-78
• Bredin, H., and Laurent, A. (2021). End-To-End Speaker Segmentation for Overlap-Aware Resegmentation. Interspeech 2021, 3111–3115. doi:10.21437/Interspeech.2021-560
• Chen, S., Wang, C., Chen, Z., Wu, Y., Liu, S., Chen, Z., Li, J., Kanda, N., Yoshioka, T., Xiao, X., Wu, J., Zhou, L., Ren, S., Qian, Y., Qian, Y., Wu, J., Zeng, M., Yu, X., and Wei, F. (2022). WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing. IEEE Journal of Selected Topics in Signal Processing. doi:10.1109/JSTSP.2022.3188113
• Radford, A., Kim, J. W., Xu, T., Brockman, G., McLeavey, C., and Sutskever, I. (2023). Robust Speech Recognition via Large-Scale Weak Supervision. Proceedings of the 40th International Conference on Machine Learning, PMLR 202, 28492–28518. proceedings.mlr.press