Sprach- und Audiomodelle auf den eigenen Annotationen trainieren

Neu in v2.14.0

Dieses Tutorial trainiert Sprach- und Audiomodelle auf den Antworten, die Annotatoren in Potato geben, und schickt die Ausgabe jedes Modells als Vorlabels an die Annotatoren zurück. Die Seite richtet sich an Studienverantwortliche, die in Potato bereits Transkripte, Sprecher-Turns oder Tierrufe korrigieren und ein Modell wollen, das aus diesen Korrekturen lernt. Der Hauptpfad importiert eine Sprecher-Diarisierungsdatei, lässt Annotatoren die Sprecher-Turns korrigieren, trainiert ein Diarisierungsmodell auf den korrigierten Turns und exportiert die Korrekturen als RTTM. Drei kürzere Abschnitte fine-tunen dann Whisper auf korrigierten Transkript-Turns, trainieren einen Box-Detektor auf Spektrogrammen und trainieren einen Tagger für Klangereignisse auf der Wellenform. Für den Trainingskreislauf im Allgemeinen ist zuerst die Übersicht zum Modelltraining zu lesen, und Das erste Modell trainieren, wenn noch nie ein Lauf gestartet wurde.

Die vier Audio-Trainer

Jeder Trainer lernt aus einer Art von Schema, und die Training-Seite bietet für ein Schema nur die Trainer an, die zu dem Schema passen:

Jeder Audio-Trainer liest Aufnahmen aus Dateien auf der Festplatte des Servers, die soundfile öffnet, z. B. WAV, FLAC oder OGG, und MP3 mit einer aktuellen libsndfile. Ein Pfad wie /media/meet000.wav benennt eine Datei im Ordner media/ des Task-Verzeichnisses, dem Ordner, aus dem die Annotationsseite Aufnahmen abspielt. Ein Item, dessen Aufnahme eine http(s)-URL ist, bleibt beim Training mit einer Warnung außen vor. Remote-Aufnahmen werden vor dem Training in media/ heruntergeladen. Die Trainer-Referenz listet jeden Parameter.

Die Trainer werden in die Umgebung installiert, in der Potato läuft:

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

Das Extra [train-audio] installiert PyTorch, transformers und soundfile. Die Spektrogramm-Detektoren brauchen stattdessen [train-vision], oder pip install "potato-annotation[train]" für alle Text-, Bild-, Audio- und LLM-Trainer auf einmal. Ein Trainer, dessen Pakete fehlen, bleibt auf der Training-Seite als „not installed“ stehen, zusammen mit dem Befehl, der die Pakete installiert.

Eine Diarisierung als RTTM-Datei importieren

Die Sprecher-Diarisierung teilt eine Aufnahme danach in Turns, wer spricht. pyannote und NeMo schreiben Diarisierungen als RTTM, ein Textformat mit einer SPEAKER-Zeile pro Turn, und dscore und md-eval bewerten RTTM-Dateien. Eine Zeile nennt die Datei-ID der Aufnahme, den Kanal, den Beginn und die Dauer des Turns in Sekunden und den Sprecher:

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>

Die RTTM-Dateien und die Aufnahmen kommen in einen Ordner, wobei jede Aufnahme nach ihrer Datei-ID benannt ist (meet000.wav für meet000), und der Ordner wird importiert:

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

Der Importer macht pro Aufnahme ein Item, kopiert die Aufnahme nach interviews/media/ und schreibt config.yaml, data/diarization.jsonl und eine README. Beim Testprojekt mit 16 Aufnahmen hinter dieser Seite lautete die Zusammenfassungszeile:

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.

Der Importer kennt drei eigene Flags:

• --rttm-scheme audio|tiered wählt das Schema, auf dem die Turns landen. Das Standardschema audio macht ein audio_annotation-Schema namens speakers, dessen Labels die Sprecher sind. tiered macht ein tiered_annotation-Schema namens tiers mit einer Ebene speaker. tiered ist für eine Studie gedacht, die anschließend Turn für Turn transkribiert.
• --speaker-map benennt Sprecher um, und ein Sprecher, den die Map nicht nennt, behält seinen RTTM-Namen. Die Map ist nur zu verwenden, wenn ein Name in jeder Aufnahme dieselbe Person meint. Ein Diarizer nummeriert Sprecher innerhalb jeder Datei, und SPEAKER_00 in einem Interview und SPEAKER_00 im nächsten können verschiedene Personen sein.
• --media-dir DIR nennt den Ordner mit den Aufnahmen, wenn die Aufnahmen nicht neben den RTTM-Dateien liegen.

Der Importer liest nur SPEAKER-Zeilen und zählt die anderen Zeilentypen als übersprungen. Turns der Länge null, Turns mit negativem Beginn, Turns ohne Sprechernamen (<NA>) und doppelt aufgeführte Turns werden ebenfalls übersprungen. RTTM trennt Felder mit Leerzeichen, und der Importer liest einen Sprechernamen mit Leerzeichen nur bis zum Leerzeichen, mit einer Warnung. Ein Projekt importieren behandelt den Import vollständig.

Die Diarisierungs-Konfiguration

Die erzeugte Konfiguration zeigt die importierten Turns bereits als Vorannotationen. Ans Ende von config.yaml kommen ein Admin-Schlüssel und ein model_training-Block. Die folgende vollständige Datei besteht 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

Der Importer sortiert die Sprecher-Labels alphabetisch, und Guest kommt vor Interviewer. Das Rückschreiben des Modells geht standardmäßig in das Item-Feld predictions, dasselbe Feld, das der pre_annotation-Block des Imports liest. Potato startet nicht, wenn ein aktivierter pre_annotation-Block ein anderes Feld als writeback.field nennt, denn dann würde kein Trainings-Vorlabel erscheinen. writeback bleibt aus der Konfiguration heraus, bis der erste Lauf einen Holdout-Score hat, der es wert ist, den Annotatoren gezeigt zu werden.

Die Sprecher-Turns korrigieren

Der Server wird aus dem Projektordner gestartet:

cd interviews
potato start config.yaml -p 8000

Jede Aufnahme öffnet sich mit den auf der Wellenform eingezeichneten Turns des Diarizers. Annotatoren verschieben die Ränder eines Turns, ändern den Sprecher eines Turns, löschen einen Turn aus Rauschen und zeichnen jeden Turn ein, den der Diarizer übersehen hat. Die Vorannotationen werden erst gespeichert, wenn ein Annotator das Item speichert. Ein Item, das niemand geöffnet hat, hat keine Antwort und trainiert nicht. Annotation der Sprecher-Diarisierung behandelt die Wellenform-Steuerung und Tastenkürzel.

Der Trainer diarization braucht mindestens 4 annotierte Aufnahmen im Train-Split, und der Standard-Split legt etwa 70 % der gelabelten Aufnahmen in Train. Vor dem ersten Lauf sind mindestens 8 Aufnahmen zu korrigieren, mehr für einen Holdout-Score, dem sich vertrauen lässt.

Das Diarisierungsmodell trainieren

http://localhost:8000/admin öffnen, den Admin-Schlüssel eingeben und zu /admin/training gehen. diarization als Trainer und speakers als Schema wählen. Die Training-Seite bietet für dasselbe Schema auch hf-audio-tagger an. hf-audio-tagger passt zu Labels, die Arten von Klang benennen statt Sprecher. Bei Interviews mit zwei Personen wird das Feld Parameters gesetzt auf:

{"max_speakers": 2}

Auf Train now klicken. Derselbe Lauf lässt sich mit dem Admin-Schlüssel aus einem Skript starten:

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 folgt dem Rezept des Segmentierungsmodells von pyannote (Bredin und Laurent, 2021) ohne pyannote und dessen gesperrte Gewichte und fine-tunt WavLM (microsoft/wavlm-base-plus) mit einem Frame-Klassifikator für bis zu max_speakers Sprecher. Das Modell sieht jeweils chunk_s Sekunden Audio, standardmäßig 10. Der Loss jedes Chunks wird unter der besten Zuordnung der Sprecher-Ausgaben des Modells zu den annotierten Sprechern des Chunks berechnet. Die Zuordnung ist wichtig, weil ein Sprechername in verschiedenen Aufnahmen auf verschiedene Personen verweist und ein Klassifikator über Namen kein konsistentes Ziel hätte. Die folgenden Parameter prägen die vorhergesagten Turns:

Remote-Training schickt einen Lauf per ssh an einen GPU-Server oder an einen SLURM-Cluster.

Den Diarisierungs-Score lesen

Die Lauf-Seite und GET /admin/training/api/status melden den Score des Laufs auf zurückgehaltenen Aufnahmen. Bei diarization ist der Hauptscore diarization_accuracy, definiert als 1 minus die Diarization Error Rate (DER) und bei 0 nach unten begrenzt. Die DER addiert verpasste Sprache, Fehlalarm und Sprecherverwechslung und teilt die Summe durch die annotierte Sprache. Potato misst die DER auf einem 10-ms-Raster ohne Collar, unter der besten Eins-zu-eins-Zuordnung vorhergesagter zu annotierten Sprechern. Der Lauf meldet die drei Fehlerarten außerdem separat. Die drei Zahlen zeigen, ob das Modell Sprache verpasst, Sprache erfindet oder Sprecher verwechselt. Die DER ignoriert, ob ein Turn Interviewer oder SPEAKER_01 heißt, und zählt, ob der Sprecher zu den richtigen Zeiten wechselt.

Ein Metrikname enthält den Split, wie in val_der oder test_diarization_accuracy. Eine Aufnahme mit annotierten Turns und ohne Vorhersage zählt als falsch. Ein Modell kann den Score daher nicht erhöhen, indem es schwierige Aufnahmen überspringt.

Die vorhergesagten Turns veröffentlichen

Sobald der Holdout-Score dafür spricht, den Annotatoren die Turns des Modells zu zeigen, wird das Schema zu writeback hinzugefügt und der Server neu gestartet:

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

include_unlabeled: true sagt auch auf den Aufnahmen voraus, die noch niemand korrigiert hat. Ohne die Einstellung sagt ein Lauf nur auf den zurückgehaltenen Val- und Test-Aufnahmen voraus. Nach dem Neustart wird erneut trainiert. Der Rückschreibe-Bericht in GET /admin/training/api/status nennt die Zahl. Beim Testprojekt lautete der Bericht „Published 7 prediction(s) as prelabels.“ für 3 Val-Aufnahmen und 4 unkorrigierte Aufnahmen, und die Aufnahmen im Train-Split behielten die importierten RTTM-Turns.

Das Modell benennt Sprecher in der Reihenfolge der ersten Sprache innerhalb jeder Aufnahme, zuerst mit den Labels des Schemas und dann mit SPEAKER_00, SPEAKER_01 und so weiter. Der erste gehörte Sprecher jeder Aufnahme ist in diesem Projekt daher Guest, ob diese Person der Gast ist oder nicht. Das Modell hat keine Stimm-Embeddings, an denen es eine Person erkennen könnte. Ein Sprecher, der durch die Überlappung zweier Chunks hindurch schweigt und später wieder spricht, erhält einen neuen Namen. Annotatoren sollen den Sprechernamen jedes vorhergesagten Turns prüfen und nicht nur dessen Ränder. Das Modell im Kreislauf behandelt das Prüfen von Vorlabels mit der geringsten Konfidenz zuerst und das Neutrainieren, während Korrekturen eintreffen.

Die korrigierten Turns als RTTM exportieren

Der Export segments schreibt die korrigierten Turns als RTTM zurück, eine Datei pro Annotator:

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

Der Export schreibt export/segments.jsonl, eine Zeile pro Turn, und export/rttm/<annotator>.rttm. Die Datei-ID in jeder RTTM-Zeile ist der Name der Aufnahme ohne Endung. pyannote.metrics, dscore oder md-eval können dann die ursprüngliche Ausgabe des Diarizers unverändert gegen die korrigierte Datei bewerten. Beim Testprojekt lauteten die ersten Zeilen von export/rttm/ana.rttm:

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

Diarisierung auf einer Sprecher-Ebene

Mit --rttm-scheme tiered wird importiert, wenn Annotatoren derselben Zeitleiste weitere Ebenen hinzufügen, etwa eine Transkriptionsebene:

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

Der Import schreibt ein tiered_annotation-Schema namens tiers mit einer Ebene speaker. admin_api_key und model_training kommen wie oben hinzu, mit schemas: [tiers] unter writeback, und die Konfiguration besteht validate_cli --strict. diarization trainiert auf der Sprecher-Ebene und schreibt vorhergesagte Turns auf dieselbe Ebene zurück. Der Trainer wählt die Ebene namens speaker oder speakers. Gibt es sie nicht, wählt der Trainer die eine Ebene, deren Name „speaker“ enthält, und eine Ebene namens non-speaker zählt nicht. Der letzte Fallback ist die einzige Ebene mit Labels. Qualifizieren sich zwei Ebenen, oder haben mehrere Ebenen Labels und keine ist nach Sprechern benannt, lässt der Lauf die Aufnahmen mit einer Warnung aus, die die Ebenen nennt.

Whisper auf korrigierten Transkripten fine-tunen

whisper-asr fine-tunt Whisper auf den Transkript-Turns, die Annotatoren korrigiert haben, und schlägt dann Korrekturen für die Turns vor, die niemand geprüft hat. Der Abschnitt beginnt bei einem Ordner mit Aufnahmen ohne Transkript.

Die Aufnahmen transkribieren

Die Aufnahmen kommen in den Ordner media/ des Projekts und werden auf der Maschine des Servers transkribiert:

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 führt WhisperX aus, wenn WhisperX installiert ist und auf der Maschine funktioniert, sonst faster-whisper. Das Extra [transcribe] installiert faster-whisper, und WhisperX ist eine separate Installation (pip install whisperx), die ihr eigenes PyTorch mitbringt. Potato fällt auf faster-whisper zurück, wenn WhisperX fehlt, sich nicht importieren lässt, auf dem Gerät nicht laufen kann oder das Modell nicht laden kann, und die Zusammenfassung nennt die Engine für jede Datei. --asr-engine whisperx oder --asr-engine faster-whisper führt eine Engine ohne Fallback aus. --media-url-prefix /media schreibt den Pfad jeder Aufnahme als /media/<file>, die Adresse, von der die Annotationsseite die Aufnahme abspielt.

--asr-word-timestamps taktet jedes Wort per Forced Alignment und lässt WhisperX ein Segment am Satzende teilen. Bei den Testaufnahmen lieferte WhisperX ohne das Flag einen Turn pro 10-Sekunden-Aufnahme und mit dem Flag drei Turns pro Aufnahme. Kürzere Turns geben whisper-asr mehr Beispiele, und das Eingabefenster von Whisper beträgt 30 Sekunden. Transkriptformate und Whisper-Transkripte annotieren behandeln die Transkriptionsoptionen, Sprecher-Labels und vorhandene Whisper-Ausgaben.

Die Transkript-Konfiguration

Ein speech_transcript-Schema zeigt jeden Turn des Transkripts mit seiner Zeitspanne und einem Korrekturfeld. Die folgende vollständige Konfiguration besteht 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 nennt das Feld, unter dem potato transcripts das Transkript schreibt. error_types: [asr_error] lässt ein Fehler-Flag übrig, weil die Studie nur Transkriptionsfehler abdeckt. language: en legt die Sprache für Training und Vorhersage fest. Bleibt sie ungesetzt, erkennt ein mehrsprachiges Whisper die Sprache einmal anhand von bis zu 16 Trainings-Turns, und das Lauf-Log warnt, wenn weniger als drei von vier der gezogenen Turns übereinstimmen.

Korrigierte Turns als Trainingsbeispiele

Jeder korrigierte Turn ist ein Beispiel, bestehend aus dem Audio des Turns, das anhand von Anfang und Ende des Turns aus der Aufnahme geschnitten wird, und dem korrigierten Text. Ein Turn, den niemand korrigiert hat, ist kein Beispiel, denn das Schema speichert nur die Turns, die ein Annotator angefasst hat, und ein unberührter Turn kann richtig sein oder ungelesen. Ein markierter Turn ohne Korrektur ist ebenfalls kein Beispiel. Turns, die länger als 30 Sekunden sind, bleiben mit einer Warnung außen vor. Der Trainer verweigert den Lauf mit weniger als 10 korrigierten Turns im Train-Split.

Auf den geöffneten Aufnahmen ist jeder falsche Turn zu korrigieren, denn der Holdout-Score wird über die korrigierten Turns berechnet. Bei den 12 Testaufnahmen hatte WhisperX mit tiny.en 11 von 36 Turns falsch, mit Fehlern wie „Epsilanti“ für Ypsilanti, „Cary Town“ für Kerrytown und einem ausgelassenen „I“ am Anfang eines Turns.

Trainieren und mit dem Transkript vergleichen

Auf der Training-Seite whisper-asr und das Schema transcript wählen und auf Train now klicken. Der Hauptscore ist word_accuracy, also 1 minus die Word Error Rate (WER) über die korrigierten Turns. Der Lauf meldet außerdem wer_asr, die WER des ursprünglichen Transkripts auf denselben Turns, und ein Turn, den das Modell unverändert ließ, wird mit dem Text des Transkripts bewertet. Vor dem Veröffentlichen von irgendetwas sind beide Zahlen zu vergleichen. Ein gefine-tuntes Modell lohnt sich für Annotatoren nur, wenn die WER des Modells unter wer_asr liegt.

Der Testlauf hinter dieser Seite zeigt, warum der Vergleich zählt. Mit 8 korrigierten Turns im Train-Split, auf 4 gesenktem min_instances und openai/whisper-tiny über 3 Epochen erzielte der Lauf eine Test-WER von 0,31 gegenüber 0,19 beim ursprünglichen Transkript. Ein Modell auf diesem Niveau würde korrekten Text durch falschen ersetzen. Es sind mehr Korrekturen zu sammeln oder von einem größeren Checkpoint zu starten und erneut zu trainieren, bevor writeback hinzukommt.

Vorgeschlagene Korrekturen veröffentlichen

Sobald das Modell das Transkript schlägt, wird das Schema zu writeback hinzugefügt, neu gestartet und erneut trainiert:

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

Die Vorhersage transkribiert jeden Turn jeder zurückgehaltenen und ungelabelten Aufnahme. Ein Turn, dessen neuer Text vom Transkript abweicht, wird zu einer vorgeschlagenen Korrektur, markiert als asr_error, mit der mittleren Token-Wahrscheinlichkeit des Modells als Konfidenz des Vorschlags. Die Vorschläge füllen die Korrekturfelder, und ein Annotator behält, bearbeitet oder löscht jeden Vorschlag.

Neue Aufnahmen mit dem gefine-tunten Modell transkribieren

Standardmäßig schreibt der Lauf unter seinen Artefakten außerdem ct2/, eine int8-CTranslate2-Kopie des Modells. Die Kopie braucht das Paket ctranslate2, das das Extra [transcribe] zusammen mit faster-whisper installiert. Der Pfad der Kopie wird an potato transcripts übergeben, um den nächsten Stapel Aufnahmen mit dem gefine-tunten Modell zu transkribieren:

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 und faster-whisper laden beide die Kopie. Die Lauf-Seite zeigt die ID jedes Laufs, und Konfiguration beschreibt die Lauf-Ordner.

Rufe auf Spektrogrammen detektieren

Bei einem spectrogram_annotation-Schema zeichnen Annotatoren Zeit-Frequenz-Boxen um Rufe. torchvision-detect und ultralytics-detect trainieren auf diesen Boxen, indem sie jede Aufnahme als Spektrogrammbild rendern, so wie das Widget das Spektrogramm zeichnet. Das Rendering legt die Frequenz auf eine lineare Achse von min_freq des Schemas bis max_freq, oder die halbe Abtastrate, wenn max_freq nicht gesetzt ist, bei 256 Pixeln Höhe und 100 Pixeln pro Sekunde. Jede Box wird zu einer Bildbox. Zeit und Frequenz werden linear auf Pixel abgebildet. Die IoU einer Box auf dem Bild entspricht daher der IoU der Box in Sekunden mal Hertz. Eine Box ohne Frequenzbereich, wie sie ein Audacity-Label oder eine BirdNET-Zeile liefert, deckt das ganze Band ab. Eine Aufnahme von 41 Sekunden oder mehr wird mindestens 4.096 Pixel breit gerendert, in Fenster geschnitten und wieder zusammengesetzt.

Boxen stammen meist aus einem Import. potato import liest Raven-Selection-Tables, Audacity-Label-Spuren und BirdNET-Analyzer-Ausgaben in ein spectrogram_annotation-Projekt, wie Bioakustik in Potato und BirdNET-Detektionen auf einem Spektrogramm prüfen beschreiben. Die Trainer lernen aus den Boxen, die Annotatoren gezeichnet oder korrigiert haben, und die Detektoren lesen die Spektrogramm-Pixel statt BirdNET- oder Perch-Embeddings.

Die folgende Konfiguration besteht validate_cli --strict und setzt score_threshold des Detektors auf 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

Das Spektrum einer 16-kHz-Aufnahme endet bei 8 kHz, und max_freq: 8000 zeigt das ganze Band. Der Standardwert 0,25 für score_threshold behält mehr Vermutungen des Detektors. Beim Testprojekt mit 24 Aufnahmen sagte torchvision-detect beim Standard-Schwellenwert 34 Boxen für 10 annotierte Rufe auf den Test-Aufnahmen voraus, und jede zusätzliche Box ist eine weitere Box, die ein Annotator löschen muss.

Jede Datenzeile nennt ihre Aufnahme, wie in {"id": "site_00", "audio_url": "/media/site_00.wav"}. Ein Detektor trainiert nur auf Aufnahmen mit mindestens einer Box, denn eine Aufnahme ohne Boxen sieht aus wie eine Aufnahme, die niemand geprüft hat. Die Detektoren brauchen standardmäßig 20 annotierte Aufnahmen im Train-Split (min_instances).

torchvision-detect fine-tunt ein Faster R-CNN aus den COCO-Gewichten von torchvision, und ultralytics-detect trainiert einen YOLO-Detektor. Der YOLO-Detektor ist schneller zu trainieren und auszuführen. Ultralytics steht unter AGPL-3.0, und ein mit Ultralytics trainiertes und verbreitetes Modell unterliegt den Bedingungen der AGPL. Die Training-Seite verlangt vor einem ultralytics-detect-Lauf die Bestätigung der Lizenz, und ein API-Lauf braucht "accept_licence": true. Beide Detektoren werden per mAP bei IoU 0,5 auf dem gerenderten Spektrogramm bewertet, und beide schreiben vorhergesagte Boxen in start_s, end_s, low_hz und high_hz zurück, als Modellausgabe markiert, um das Widget vorzubefüllen. Vision-Modelle behandelt die Parameter der Detektoren und das Kacheln.

Klangereignisse taggen mit hf-audio-tagger

hf-audio-tagger lernt die gelabelten Zeitsegmente eines audio_annotation-Schemas, etwa Sprache, Musik, Rufe oder Husten. Der Trainer fine-tunt einen Sprach-Encoder, standardmäßig facebook/wav2vec2-base, damit er sagt, welche Labels in jedem Frame von etwa 20 ms aktiv sind. Jedes Label wird separat bewertet. Überlappende Segmente mit verschiedenen Labels werden daher so gelernt, wie sie annotiert sind. Vorhergesagte Segmente kommen als editierbare Regionen auf der Wellenform zurück. Die folgende Konfiguration besteht 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

Der Tagger behandelt jede Strecke einer Aufnahme, die kein Annotator markiert hat, als „kein Label hier“. Die Annahme passt zu einer Studie, in der Annotatoren jedes Ereignis markieren, und die Beschreibung des Schemas oben verlangt „every call“. Wo Annotatoren nur einige Ereignisse markieren, lernt das Modell, den Rest zu verpassen. Der Hauptscore ist Segment-F1, bei dem ein vorhergesagtes Segment ein annotiertes Segment mit demselben Label bei einer IoU von mindestens 0,5 trifft, und der Lauf meldet außerdem die mittlere IoU der getroffenen Segmente. Der Trainer braucht standardmäßig 10 annotierte Aufnahmen im Train-Split.

Die Training-Seite bietet für ein audio_annotation-Schema sowohl hf-audio-tagger als auch diarization an. hf-audio-tagger ist zu wählen, wenn ein Label eine Art von Klang benennt und in jeder Aufnahme dasselbe bedeutet. diarization ist zu wählen, wenn die Labels Sprecher sind, deren Namen lokal zu jeder Aufnahme gehören.

Die Läufe hinter dieser Seite

Die Befehle und Konfigurationen auf dieser Seite wurden gegen Potato 2.14.0 auf einem Laptop ausgeführt, mit den unten genannten kleineren Modellen. Der Diarisierungspfad lief von Anfang bis Ende, von einem RTTM-Import von 16 synthetischen Aufnahmen mit zwei Sprechern, bei denen 20 % der Turns den falschen Sprecher erhielten, über Korrekturen an 12 Aufnahmen, einen diarization-Lauf und das Rückschreiben bis zum Export segments. Der Lauf nutzte einen einlagigen Test-Encoder anstelle von WavLM. Der Score des Laufs sagt daher nichts über echte Sprache. Der Whisper-Abschnitt nutzte 12 Aufnahmen synthetisierter Sprache, von WhisperX mit tiny.en transkribiert und von openai/whisper-tiny aus gefine-tunt. Die Abschnitte zu Spektrogramm und Tagger nutzten 24 synthetische Aufnahmen von Tönen bei 3 kHz und 6 kHz. Jeder Konfigurationsblock besteht python -m potato.validate_cli --strict.

Weiterführende Links

• Übersicht zum Modelltraining erklärt den Trainingskreislauf, die Training-Seite und Holdout-Scores.
• Trainer listet jeden Trainer mit seinen Schemas, der Installation und den Parametern.
• Konfiguration dokumentiert jeden model_training-Schlüssel, das Rückschreiben und die Routen.
• Das Modell im Kreislauf behandelt das Prüfen von Vorlabels und das automatische Neutrainieren.
• Audioannotation richtet Klassifikations-, Ereignis-, Transkriptions- und Diarisierungsaufgaben ein.
• Transkriptformate listet jedes Transkriptformat, das Potato liest.
• Die Upstream-Referenz dokumentiert diarization, whisper-asr, hf-audio-tagger und Spektrogramme Parameter für Parameter.

Literatur

• 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