Addestrare modelli per il parlato e l'audio sulle tue annotazioni

Novità nella v2.14.0

Questo tutorial addestra modelli per il parlato e l'audio sulle risposte che gli annotatori danno in Potato e rimanda l'output di ogni modello agli annotatori come pre-etichette. La pagina è scritta per un responsabile di studio che corregge già in Potato trascrizioni, turni di parlanti o richiami di animali e vuole un modello che impari da quelle correzioni. Il percorso principale importa un file di diarizzazione dei parlanti, fa correggere i turni agli annotatori, addestra un modello di diarizzazione sui turni corretti ed esporta le correzioni come RTTM. Tre sezioni più brevi eseguono poi il fine-tuning di Whisper su turni di trascrizione corretti, addestrano un detector di box sugli spettrogrammi e addestrano un tagger di eventi sonori sulla forma d'onda. Per il ciclo di addestramento in generale, leggi prima la panoramica sull'addestramento di modelli, e Addestra il tuo primo modello se non hai mai avviato un'esecuzione.

I quattro trainer per l'audio

Ogni trainer impara da un tipo di schema, e la pagina Training propone uno schema solo ai trainer adatti allo schema:

Ogni trainer per l'audio legge le registrazioni da file sul disco del server che soundfile apre, ad esempio WAV, FLAC o OGG, e MP3 con una libsndfile recente. Un percorso come /media/meet000.wav indica un file nella cartella media/ della directory del compito, la cartella da cui la pagina di annotazione riproduce le registrazioni. Un item la cui registrazione è un URL http(s) viene escluso dall'addestramento con un avviso. Scarica le registrazioni remote in media/ prima di addestrare. Il riferimento dei trainer elenca ogni parametro.

Installa i trainer nell'ambiente che esegue Potato:

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

L'extra [train-audio] installa PyTorch, transformers e soundfile. I detector per spettrogrammi richiedono invece [train-vision], oppure pip install "potato-annotation[train]" per tutti i trainer per testo, immagini, audio e LLM insieme. Un trainer di cui mancano i pacchetti resta nella pagina Training come "not installed", con il comando che installa i pacchetti.

Importare una diarizzazione come file RTTM

La diarizzazione dei parlanti divide una registrazione in turni in base a chi parla. pyannote e NeMo scrivono le diarizzazioni in RTTM, un formato di testo con una riga SPEAKER per turno, e dscore e md-eval valutano i file RTTM. Una riga indica l'id del file della registrazione, il canale, l'inizio e la durata del turno in secondi e il parlante:

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>

Metti i file RTTM e le registrazioni in una sola cartella, con ogni registrazione chiamata come il proprio id di file (meet000.wav per meet000), e importa la cartella:

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

L'importatore crea un item per registrazione, copia la registrazione in interviews/media/ e scrive config.yaml, data/diarization.jsonl e un README. Nel progetto di prova da 16 registrazioni che sta dietro a questa pagina, la riga di riepilogo diceva:

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'importatore accetta tre flag propri:

• --rttm-scheme audio|tiered sceglie lo schema su cui finiscono i turni. Il valore predefinito audio crea uno schema audio_annotation chiamato speakers le cui etichette sono i parlanti. tiered crea uno schema tiered_annotation chiamato tiers con un solo livello speaker. Usa tiered per uno studio che trascrive poi turno per turno.
• --speaker-map rinomina i parlanti, e un parlante che la mappa non nomina mantiene il nome RTTM. Usa la mappa solo quando un nome indica la stessa persona in ogni registrazione. Un diarizzatore numera i parlanti all'interno di ogni file, e SPEAKER_00 in un'intervista e SPEAKER_00 in quella successiva possono essere persone diverse.
• --media-dir DIR indica la cartella che contiene le registrazioni quando le registrazioni non sono accanto ai file RTTM.

L'importatore legge solo le righe SPEAKER e conta gli altri tipi di riga come saltati. Vengono saltati anche i turni di durata zero, i turni con un inizio negativo, i turni senza nome di parlante (<NA>) e un turno elencato due volte. L'RTTM separa i campi con spazi, e l'importatore legge un nome di parlante che contiene uno spazio solo fino allo spazio, con un avviso. Importare un progetto tratta l'importazione per intero.

La configurazione per la diarizzazione

La configurazione generata mostra già i turni importati come pre-annotazioni. Aggiungi una chiave di amministratore e un blocco model_training alla fine di config.yaml. Il file completo qui sotto supera 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'importatore ordina alfabeticamente le etichette dei parlanti, e Guest viene prima di Interviewer. Il write-back del modello va per impostazione predefinita nel campo dell'item predictions, lo stesso campo che legge il blocco pre_annotation dell'importazione. Potato rifiuta di avviarsi quando un blocco pre_annotation attivo indica un campo diverso da writeback.field, perché altrimenti nessuna pre-etichetta di addestramento sarebbe visibile. Lascia fuori writeback dalla configurazione finché la prima esecuzione non ha un punteggio held-out che valga la pena mostrare agli annotatori.

Correggere i turni dei parlanti

Avvia il server dalla cartella del progetto:

cd interviews
potato start config.yaml -p 8000

Ogni registrazione si apre con i turni del diarizzatore disegnati sulla forma d'onda. Gli annotatori spostano i bordi di un turno, cambiano il parlante di un turno, eliminano un turno di rumore e disegnano ogni turno che il diarizzatore ha mancato. Le pre-annotazioni vengono archiviate solo quando un annotatore salva l'item. Un item che nessuno ha aperto non ha risposta e non addestra. Annotazione della diarizzazione dei parlanti tratta i controlli della forma d'onda e le scorciatoie da tastiera.

Il trainer diarization richiede almeno 4 registrazioni annotate nella partizione train, e la suddivisione predefinita assegna a train circa il 70% delle registrazioni etichettate. Correggi almeno 8 registrazioni prima della prima esecuzione, e di più per un punteggio held-out di cui fidarsi.

Addestrare il modello di diarizzazione

Apri http://localhost:8000/admin, inserisci la chiave di amministratore e vai a /admin/training. Scegli diarization come trainer e speakers come schema. La pagina Training propone per lo stesso schema anche hf-audio-tagger. hf-audio-tagger si adatta a etichette che indicano tipi di suono e non parlanti. Per interviste a due persone, imposta il campo Parameters su:

{"max_speakers": 2}

Fai clic su Train now. La stessa esecuzione può partire da uno script con la chiave di amministratore:

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 segue la ricetta del modello di segmentazione di pyannote (Bredin e Laurent, 2021) senza pyannote né i pesi ad accesso controllato di pyannote, ed esegue il fine-tuning di WavLM (microsoft/wavlm-base-plus) con un classificatore di frame per un massimo di max_speakers parlanti. Il modello vede chunk_s secondi di audio alla volta, 10 per impostazione predefinita. La perdita di ogni chunk è calcolata con il miglior abbinamento tra le uscite per parlante del modello e i parlanti annotati nel chunk. L'abbinamento conta perché un nome di parlante indica persone diverse in registrazioni diverse, e un classificatore sui nomi non avrebbe un bersaglio coerente. I parametri seguenti danno forma ai turni predetti:

Addestramento remoto invia un'esecuzione a un server GPU via ssh o a un cluster SLURM.

Leggere il punteggio di diarizzazione

La pagina dell'esecuzione e GET /admin/training/api/status riportano il punteggio dell'esecuzione sulle registrazioni escluse dall'addestramento. Per diarization, la metrica principale è diarization_accuracy, definita come 1 meno il tasso di errore di diarizzazione (DER) con minimo 0. Il DER somma parlato mancato, falso allarme e confusione tra parlanti e divide la somma per il parlato annotato. Potato misura il DER su una griglia di 10 ms senza tolleranza, con il miglior abbinamento uno a uno tra parlanti predetti e annotati. L'esecuzione riporta separatamente anche i tre tipi di errore. Leggi i tre numeri per capire se il modello perde parlato, inventa parlato o confonde i parlanti. Il DER ignora se un turno si chiama Interviewer o SPEAKER_01 e conta se il parlante cambia nei momenti giusti.

Il nome di una metrica include la partizione, come in val_der o test_diarization_accuracy. Una registrazione con turni annotati e senza predizione conta come sbagliata. Un modello non può quindi alzare il punteggio saltando le registrazioni difficili.

Pubblicare i turni predetti

Quando il punteggio held-out giustifica la visualizzazione dei turni del modello agli annotatori, aggiungi lo schema a writeback e riavvia il server:

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

include_unlabeled: true predice anche le registrazioni che nessuno ha ancora corretto. Senza questa impostazione, un'esecuzione predice solo le registrazioni val e test escluse dall'addestramento. Addestra di nuovo dopo il riavvio. Il rapporto di write-back in GET /admin/training/api/status fornisce il conteggio. Nel progetto di prova, il rapporto diceva "Published 7 prediction(s) as prelabels." per 3 registrazioni val e 4 registrazioni non corrette, e le registrazioni nella partizione train hanno mantenuto i turni RTTM importati.

Il modello nomina i parlanti nell'ordine del primo parlato in ogni registrazione, usando prima le etichette dello schema e poi SPEAKER_00, SPEAKER_01 e così via. Il primo parlante che si sente in ogni registrazione è quindi Guest in questo progetto, che quella persona sia o no l'ospite. Il modello non ha embedding vocali con cui riconoscere una persona. Un parlante che tace durante la sovrapposizione tra due chunk e parla di nuovo più tardi riceve un nuovo nome. Di' agli annotatori di controllare il nome del parlante di ogni turno predetto, e non solo i bordi del turno. Il modello nel ciclo tratta la revisione delle pre-etichette partendo dalle meno sicure e il riaddestramento man mano che arrivano le correzioni.

Esportare i turni corretti come RTTM

L'esportazione segments riscrive i turni corretti come RTTM, un file per annotatore:

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

L'esportazione scrive export/segments.jsonl, una riga per turno, e export/rttm/<annotator>.rttm. L'id di file in ogni riga RTTM è il nome della registrazione senza estensione. pyannote.metrics, dscore o md-eval possono poi valutare l'output originale del diarizzatore rispetto al file corretto senza modifiche. Nel progetto di prova, le prime righe di export/rttm/ana.rttm dicevano:

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

Diarizzazione su un livello dei parlanti

Importa con --rttm-scheme tiered quando gli annotatori aggiungeranno altri livelli, come un livello di trascrizione, alla stessa linea temporale:

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

L'importazione scrive uno schema tiered_annotation chiamato tiers con un solo livello speaker. Aggiungi admin_api_key e model_training come sopra, con schemas: [tiers] sotto writeback, e la configurazione supera validate_cli --strict. diarization si addestra sul livello dei parlanti e riscrive i turni predetti sullo stesso livello. Il trainer sceglie il livello chiamato speaker o speakers. In mancanza, sceglie l'unico livello il cui nome contiene "speaker", e un livello chiamato non-speaker non conta. L'ultima alternativa è l'unico livello con etichette. Quando due livelli sono adatti, o più livelli hanno etichette e nessuno è chiamato come i parlanti, l'esecuzione esclude le registrazioni con un avviso che nomina i livelli.

Fine-tuning di Whisper su trascrizioni corrette

whisper-asr esegue il fine-tuning di Whisper sui turni di trascrizione che gli annotatori hanno corretto, poi suggerisce correzioni sui turni che nessuno ha controllato. La sezione parte da una cartella di registrazioni senza trascrizione.

Trascrivere le registrazioni

Metti le registrazioni nella cartella media/ del progetto e trascrivile sulla macchina del server:

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 esegue WhisperX quando WhisperX è installato e funziona sulla macchina, e altrimenti faster-whisper. L'extra [transcribe] installa faster-whisper, e WhisperX è un'installazione separata (pip install whisperx) che porta il proprio PyTorch. Potato ripiega su faster-whisper quando WhisperX manca, non si importa, non può girare sul dispositivo o non riesce a caricare il modello, e il riepilogo nomina il motore per ogni file. --asr-engine whisperx o --asr-engine faster-whisper esegue un solo motore senza ripiego. --media-url-prefix /media scrive il percorso di ogni registrazione come /media/<file>, l'indirizzo da cui la pagina di annotazione riproduce la registrazione.

--asr-word-timestamps assegna un tempo a ogni parola con l'allineamento forzato e permette a WhisperX di dividere un segmento alla fine di una frase. Sulle registrazioni di prova, WhisperX ha restituito un turno per ogni registrazione di 10 secondi senza il flag e tre turni per registrazione con il flag. Turni più brevi danno a whisper-asr più esempi, e la finestra di input di Whisper è di 30 secondi. Formati di trascrizione e Come annotare le trascrizioni di Whisper trattano le opzioni di trascrizione, le etichette dei parlanti e l'output Whisper esistente.

La configurazione per le trascrizioni

Uno schema speech_transcript mostra ogni turno della trascrizione con il suo intervallo di tempo e una casella di correzione. La configurazione completa qui sotto supera 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 indica il campo sotto cui potato transcripts scrive la trascrizione. error_types: [asr_error] lascia un solo indicatore di errore, perché lo studio copre solo gli errori di trascrizione. language: en fissa la lingua per l'addestramento e la predizione. Se non è impostata, un Whisper multilingue rileva la lingua una volta da un massimo di 16 turni di addestramento, e il log dell'esecuzione avvisa quando meno di tre turni campionati su quattro concordano.

I turni corretti come esempi di addestramento

Ogni turno corretto è un esempio, composto dall'audio del turno ritagliato dalla registrazione tra l'inizio e la fine del turno, insieme al testo corretto. Un turno che nessuno ha corretto non è un esempio, perché lo schema salva solo i turni che un annotatore ha toccato, e un turno non toccato può essere giusto o non letto. Neppure un turno segnalato senza correzione è un esempio. I turni più lunghi di 30 secondi vengono esclusi con un avviso. Il trainer rifiuta di partire con meno di 10 turni corretti nella partizione train.

Correggi ogni turno sbagliato nelle registrazioni che apri, perché il punteggio held-out è calcolato sui turni corretti. Sulle 12 registrazioni di prova, WhisperX con tiny.en ha sbagliato 11 turni su 36, con errori come "Epsilanti" per Ypsilanti, "Cary Town" per Kerrytown e una "I" mancante all'inizio di un turno.

Addestrare e confrontare con la trascrizione

Scegli whisper-asr e lo schema transcript nella pagina Training e fai clic su Train now. Il punteggio principale è word_accuracy, cioè 1 meno il tasso di errore sulle parole (WER) sui turni corretti. L'esecuzione riporta anche wer_asr, il WER della trascrizione originale sugli stessi turni, e un turno che il modello ha lasciato com'è viene valutato come testo della trascrizione. Confronta i due numeri prima di pubblicare qualcosa. Un modello addestrato vale la pena di essere mostrato agli annotatori solo quando il suo WER è inferiore a wer_asr.

L'esecuzione di prova dietro a questa pagina mostra perché il confronto conta. Con 8 turni corretti in train, min_instances abbassato a 4 e openai/whisper-tiny addestrato per 3 epoche, l'esecuzione ha ottenuto un WER su test di 0.31 contro 0.19 della trascrizione originale. Un modello a quel livello sostituirebbe testo giusto con testo sbagliato. Raccogli più correzioni, o parti da un checkpoint più grande, e addestra di nuovo prima di aggiungere writeback.

Pubblicare le correzioni suggerite

Quando il modello batte la trascrizione, aggiungi lo schema a writeback, riavvia e addestra di nuovo:

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

La predizione trascrive ogni turno di ogni registrazione esclusa dall'addestramento e non etichettata. Un turno il cui nuovo testo differisce dalla trascrizione diventa una correzione suggerita, segnalata asr_error, con la probabilità media dei token del modello come confidenza del suggerimento. I suggerimenti riempiono le caselle di correzione, e un annotatore conserva, modifica o cancella ogni suggerimento.

Trascrivere nuove registrazioni con il modello addestrato

Per impostazione predefinita l'esecuzione scrive anche ct2/, una copia int8 CTranslate2 del modello, tra gli artefatti dell'esecuzione. La copia richiede il pacchetto ctranslate2, che l'extra [transcribe] installa insieme a faster-whisper. Passa il percorso della copia a potato transcripts per trascrivere il gruppo successivo di registrazioni con il modello addestrato:

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 e faster-whisper caricano entrambi la copia. La pagina dell'esecuzione mostra l'id di ogni esecuzione, e Configurazione descrive le cartelle delle esecuzioni.

Rilevare richiami sugli spettrogrammi

In uno schema spectrogram_annotation gli annotatori disegnano box tempo-frequenza attorno ai richiami. torchvision-detect e ultralytics-detect si addestrano su quei box rendendo ogni registrazione come immagine di spettrogramma nel modo in cui il widget disegna lo spettrogramma. Il rendering mette la frequenza su un asse lineare da min_freq dello schema a max_freq, o a metà della frequenza di campionamento quando max_freq non è impostato, con altezza di 256 pixel e 100 pixel al secondo. Ogni box diventa un box sull'immagine. Tempo e frequenza si associano linearmente ai pixel. L'IoU di un box sull'immagine è quindi uguale all'IoU del box in secondi per hertz. Un box senza intervallo di frequenza, come lo dà un'etichetta di Audacity o una riga di BirdNET, copre l'intera banda. Una registrazione di 41 secondi o più viene resa con una larghezza di almeno 4.096 pixel, tagliata in finestre e ricomposta.

I box di solito arrivano da un'importazione. potato import legge le tabelle di selezione di Raven, le tracce di etichette di Audacity e l'output di BirdNET-Analyzer in un progetto spectrogram_annotation, come descrivono La bioacustica in Potato e Verificare i rilevamenti di BirdNET su uno spettrogramma. I trainer imparano dai box che gli annotatori hanno disegnato o corretto, e i detector leggono i pixel dello spettrogramma e non gli embedding di BirdNET o Perch.

La configurazione qui sotto supera validate_cli --strict e imposta score_threshold del detector a 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

Lo spettro di una registrazione a 16 kHz termina a 8 kHz, e max_freq: 8000 mostra l'intera banda. Il score_threshold predefinito di 0.25 conserva più ipotesi del detector. Nel progetto di prova da 24 registrazioni, torchvision-detect alla soglia predefinita ha predetto 34 box per 10 richiami annotati sulle registrazioni test, e ogni box in più è un box in più da eliminare per un annotatore.

Ogni riga di dati indica la propria registrazione, come in {"id": "site_00", "audio_url": "/media/site_00.wav"}. Un detector si addestra solo su registrazioni con almeno un box, perché una registrazione senza box ha lo stesso aspetto di una registrazione che nessuno ha controllato. I detector richiedono per impostazione predefinita 20 registrazioni annotate nella partizione train (min_instances).

torchvision-detect esegue il fine-tuning di un Faster R-CNN dai pesi COCO di torchvision, e ultralytics-detect addestra un detector YOLO. Il detector YOLO è più veloce da addestrare e da eseguire. Ultralytics è distribuito con licenza AGPL-3.0, e un modello addestrato e distribuito con Ultralytics è soggetto ai termini dell'AGPL. La pagina Training chiede di confermare la licenza prima di un'esecuzione di ultralytics-detect, e un'esecuzione via API richiede "accept_licence": true. Entrambi i detector sono valutati con la mAP a IoU 0.5 sullo spettrogramma reso, ed entrambi riscrivono i box predetti in start_s, end_s, low_hz e high_hz, contrassegnati come output del modello, per precompilare il widget. Modelli per la visione tratta i parametri dei detector e la suddivisione in tile.

Etichettare eventi sonori con hf-audio-tagger

hf-audio-tagger impara i segmenti temporali etichettati di uno schema audio_annotation, come parlato, musica, richiami o colpi di tosse. Il trainer esegue il fine-tuning di un encoder di parlato, facebook/wav2vec2-base per impostazione predefinita, perché dica quali etichette sono attive in ogni frame di circa 20 ms. Ogni etichetta è valutata separatamente. I segmenti sovrapposti con etichette diverse vengono quindi appresi come sono stati annotati. I segmenti predetti tornano come regioni modificabili sulla forma d'onda. La configurazione qui sotto supera 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

Il tagger tratta ogni tratto di una registrazione che nessun annotatore ha marcato come "nessuna etichetta qui". L'assunzione si adatta a uno studio in cui gli annotatori marcano ogni evento, e la descrizione dello schema qui sopra chiede "every call". Dove gli annotatori marcano solo alcuni eventi, il modello impara a mancare gli altri. Il punteggio principale è l'F1 sui segmenti, in cui un segmento predetto corrisponde a un segmento annotato con la stessa etichetta a un IoU di almeno 0.5, e l'esecuzione riporta anche l'IoU medio dei segmenti corrispondenti. Il trainer richiede per impostazione predefinita 10 registrazioni annotate nella partizione train.

La pagina Training propone sia hf-audio-tagger sia diarization per uno schema audio_annotation. Scegli hf-audio-tagger quando un'etichetta indica un tipo di suono e ha lo stesso significato in ogni registrazione. Scegli diarization quando le etichette sono parlanti i cui nomi sono locali a ogni registrazione.

Le esecuzioni dietro a questa pagina

I comandi e le configurazioni di questa pagina sono stati eseguiti con Potato 2.14.0 su un portatile, con i modelli più piccoli indicati qui sotto. Il percorso della diarizzazione è stato eseguito dall'inizio alla fine, da un'importazione RTTM di 16 registrazioni sintetiche a due parlanti con il 20% dei turni assegnato al parlante sbagliato, passando per le correzioni su 12 registrazioni, un'esecuzione di diarization e il write-back, fino all'esportazione segments. L'esecuzione ha usato un encoder di prova a un solo livello al posto di WavLM. Il punteggio dell'esecuzione quindi non dice nulla sul parlato reale. La sezione su Whisper ha usato 12 registrazioni di parlato sintetizzato, trascritte da WhisperX con tiny.en e sottoposte a fine-tuning da openai/whisper-tiny. Le sezioni su spettrogrammi e tagger hanno usato 24 registrazioni sintetiche di toni a 3 kHz e 6 kHz. Ogni blocco di configurazione supera python -m potato.validate_cli --strict.

Ulteriori letture

• Panoramica sull'addestramento di modelli spiega il ciclo di addestramento, la pagina Training e i punteggi held-out.
• Trainer elenca ogni trainer con i suoi schemi, l'installazione e i parametri.
• Configurazione documenta ogni chiave di model_training, il write-back e le route.
• Il modello nel ciclo tratta la revisione delle pre-etichette e il riaddestramento automatico.
• Annotazione audio imposta compiti di classificazione, eventi, trascrizione e diarizzazione.
• Formati di trascrizione elenca ogni formato di trascrizione che Potato legge.
• Il riferimento upstream documenta diarization, whisper-asr, hf-audio-tagger e gli spettrogrammi parametro per parametro.

Riferimenti

• 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