Treine modelos de fala e áudio com as suas anotações

Novo na v2.14.0

Este tutorial treina modelos de fala e áudio com as respostas que os anotadores dão no Potato e devolve a saída de cada modelo aos anotadores como pré-rótulos. A página é escrita para um responsável por estudo que já corrige transcrições, turnos de fala ou chamadas de animais no Potato e quer um modelo que aprenda com essas correções. O caminho principal importa um arquivo de diarização de falantes, faz os anotadores corrigirem os turnos de fala, treina um modelo de diarização com os turnos corrigidos e exporta as correções como RTTM. Três seções mais curtas ajustam então o Whisper com turnos de transcrição corrigidos, treinam um detector de caixas em espectrogramas e treinam um classificador de eventos sonoros na forma de onda. Para o ciclo de treinamento em geral, leia primeiro a visão geral do treinamento de modelos, e Treine seu primeiro modelo se você nunca iniciou uma execução.

Os quatro treinadores de áudio

Cada treinador aprende com um tipo de esquema, e a página Training oferece a um esquema apenas os treinadores que se ajustam a ele:

Todo treinador de áudio lê gravações de arquivos no disco do servidor que o soundfile abre, por exemplo WAV, FLAC ou OGG, e MP3 com uma libsndfile recente. Um caminho como /media/meet000.wav nomeia um arquivo na pasta media/ do diretório da tarefa, a pasta de onde a página de anotação toca as gravações. Um item cuja gravação é uma URL http(s) fica fora do treinamento, com um aviso. Baixe as gravações remotas para media/ antes de treinar. A referência de treinadores lista todos os parâmetros.

Instale os treinadores no ambiente que executa o Potato:

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

O extra [train-audio] instala PyTorch, transformers e soundfile. Os detectores de espectrograma precisam de [train-vision], ou de pip install "potato-annotation[train]" para todos os treinadores de texto, imagem, áudio e LLM de uma vez. Um treinador cujos pacotes estão ausentes permanece na página Training como "not installed", com o comando que instala os pacotes.

Importando uma diarização como arquivo RTTM

A diarização de falantes divide uma gravação em turnos por quem está falando. pyannote e NeMo gravam diarizações como RTTM, um formato de texto com uma linha SPEAKER por turno, e dscore e md-eval avaliam arquivos RTTM. Uma linha nomeia o id do arquivo da gravação, o canal, o início e a duração do turno em segundos e o falante:

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>

Ponha os arquivos RTTM e as gravações em uma pasta, com cada gravação nomeada pelo id do arquivo (meet000.wav para meet000), e importe a pasta:

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

O importador cria um item por gravação, copia a gravação para interviews/media/ e grava config.yaml, data/diarization.jsonl e um README. No projeto de teste de 16 gravações por trás desta página, a linha de resumo foi:

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.

O importador tem três opções próprias:

• --rttm-scheme audio|tiered escolhe o esquema em que os turnos entram. O padrão audio cria um esquema audio_annotation chamado speakers cujos rótulos são os falantes. tiered cria um esquema tiered_annotation chamado tiers com uma camada speaker. Use tiered em um estudo que transcreve turno a turno depois.
• --speaker-map renomeia falantes, e um falante que o mapa não nomeia mantém o nome do RTTM. Use o mapa apenas quando um nome significa a mesma pessoa em todas as gravações. Um diarizador numera os falantes dentro de cada arquivo, e SPEAKER_00 em uma entrevista e SPEAKER_00 na seguinte podem ser pessoas diferentes.
• --media-dir DIR nomeia a pasta que contém as gravações quando as gravações não estão ao lado dos arquivos RTTM.

O importador lê apenas linhas SPEAKER e conta os outros tipos de linha como ignorados. Turnos de duração zero, turnos com início negativo, turnos sem nome de falante (<NA>) e um turno listado duas vezes também são ignorados. O RTTM separa os campos com espaços, e o importador lê um nome de falante que contém um espaço apenas até o espaço, com um aviso. Importando um projeto cobre a importação por completo.

A configuração de diarização

A configuração gerada já mostra os turnos importados como pré-anotações. Adicione uma chave de administrador e um bloco model_training ao final de config.yaml. O arquivo completo abaixo passa em 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

O importador ordena os rótulos de falantes em ordem alfabética, e Guest vem antes de Interviewer. A gravação de volta do modelo vai por padrão para o campo de item predictions, o mesmo campo que o bloco pre_annotation da importação lê. O Potato se recusa a iniciar quando um bloco pre_annotation ativado nomeia um campo diferente de writeback.field, porque então nenhum pré-rótulo de treinamento apareceria. Deixe writeback fora da configuração até que a primeira execução tenha uma pontuação em itens reservados que valha a pena mostrar aos anotadores.

Corrigindo os turnos de fala

Inicie o servidor a partir da pasta do projeto:

cd interviews
potato start config.yaml -p 8000

Cada gravação abre com os turnos do diarizador desenhados na forma de onda. Os anotadores movem as bordas de um turno, trocam o falante de um turno, excluem um turno de ruído e desenham qualquer turno que o diarizador perdeu. As pré-anotações só são armazenadas quando um anotador salva o item. Um item que ninguém abriu não tem resposta e não treina. Anotação de diarização de falantes cobre os controles da forma de onda e os atalhos de teclado.

O treinador diarization precisa de pelo menos 4 gravações anotadas na divisão train, e a divisão padrão põe cerca de 70% das gravações rotuladas em train. Corrija pelo menos 8 gravações antes da primeira execução, e mais para uma pontuação em itens reservados confiável.

Treinando o modelo de diarização

Abra http://localhost:8000/admin, informe a chave de administrador e vá para /admin/training. Escolha diarization como treinador e speakers como esquema. A página Training também oferece hf-audio-tagger para o mesmo esquema. hf-audio-tagger serve para rótulos que nomeiam tipos de som em vez de falantes. Para entrevistas de duas pessoas, defina o campo Parameters como:

{"max_speakers": 2}

Clique em Train now. A mesma execução pode ser iniciada a partir de um script com a chave de administrador:

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 a receita do modelo de segmentação do pyannote (Bredin e Laurent, 2021) sem o pyannote nem os pesos restritos do pyannote, e ajusta o WavLM (microsoft/wavlm-base-plus) com um classificador de quadros para até max_speakers falantes. O modelo vê chunk_s segundos de áudio por vez, 10 por padrão. A perda de cada trecho é calculada sob a melhor correspondência entre as saídas de falantes do modelo e os falantes anotados do trecho. A correspondência importa porque o nome de um falante se refere a pessoas diferentes em gravações diferentes, e um classificador sobre nomes não teria um alvo consistente. Os parâmetros abaixo moldam os turnos previstos:

O treinamento remoto envia uma execução a um servidor com GPU por ssh ou a um cluster SLURM.

Lendo a pontuação de diarização

A página da execução e GET /admin/training/api/status informam a pontuação da execução em gravações reservadas. Para diarization, a pontuação principal é diarization_accuracy, definida como 1 menos a taxa de erro de diarização (DER) e limitada inferiormente a 0. A DER soma fala perdida, alarme falso e confusão de falantes e divide a soma pela fala anotada. O Potato mede a DER em uma grade de 10 ms sem tolerância (collar), sob o melhor mapeamento um-para-um entre falantes previstos e anotados. A execução também informa os três tipos de erro separadamente. Leia os três números para ver se o modelo perde fala, inventa fala ou confunde falantes. A DER ignora se um turno se chama Interviewer ou SPEAKER_01 e conta se o falante muda nos momentos certos.

O nome de uma métrica inclui a divisão, como em val_der ou test_diarization_accuracy. Uma gravação com turnos anotados e sem predição conta como errada. Um modelo portanto não consegue aumentar a pontuação pulando gravações difíceis.

Publicando os turnos previstos

Quando a pontuação em itens reservados justificar mostrar os turnos do modelo aos anotadores, adicione o esquema a writeback e reinicie o servidor:

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

include_unlabeled: true também prevê nas gravações que ninguém corrigiu ainda. Sem essa configuração, uma execução prevê apenas nas gravações val e test reservadas. Treine de novo após a reinicialização. O relatório de gravação de volta em GET /admin/training/api/status informa a contagem. No projeto de teste, o relatório dizia "Published 7 prediction(s) as prelabels." para 3 gravações val e 4 gravações não corrigidas, e as gravações da divisão train mantiveram os turnos RTTM importados.

O modelo nomeia os falantes na ordem da primeira fala dentro de cada gravação, usando primeiro os rótulos do esquema e depois SPEAKER_00, SPEAKER_01 e assim por diante. O primeiro falante ouvido em cada gravação é portanto Guest neste projeto, seja ou não essa pessoa o convidado. O modelo não tem embeddings de voz para reconhecer uma pessoa. Um falante que fica em silêncio durante a sobreposição entre dois trechos e volta a falar depois recebe um novo nome. Diga aos anotadores para verificar o nome do falante de cada turno previsto, e não apenas as bordas do turno. Modelo no ciclo cobre a revisão de pré-rótulos do menos confiável ao mais confiável e o retreinamento conforme as correções chegam.

Exportando os turnos corrigidos como RTTM

A exportação segments grava os turnos corrigidos de volta como RTTM, um arquivo por anotador:

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

A exportação grava export/segments.jsonl, uma linha por turno, e export/rttm/<annotator>.rttm. O id do arquivo em cada linha RTTM é o nome da gravação sem a extensão. pyannote.metrics, dscore ou md-eval podem então avaliar a saída original do diarizador contra o arquivo corrigido sem alterações. No projeto de teste, as primeiras linhas de export/rttm/ana.rttm eram:

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

Diarização em uma camada de falantes

Importe com --rttm-scheme tiered quando os anotadores forem adicionar outras camadas, como uma camada de transcrição, à mesma linha do tempo:

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

A importação grava um esquema tiered_annotation chamado tiers com uma camada speaker. Adicione admin_api_key e model_training como acima, com schemas: [tiers] em writeback, e a configuração passa em validate_cli --strict. diarization treina na camada de falantes e grava os turnos previstos de volta na mesma camada. O treinador escolhe a camada chamada speaker ou speakers. Na falta dela, o treinador escolhe a única camada cujo nome contém "speaker", e uma camada chamada non-speaker não conta. O último recurso é a única camada com rótulos. Quando duas camadas se qualificam, ou várias camadas têm rótulos e nenhuma tem nome de falantes, a execução deixa as gravações de fora com um aviso que nomeia as camadas.

Ajustando o Whisper com transcrições corrigidas

whisper-asr ajusta o Whisper com os turnos de transcrição que os anotadores corrigiram e depois sugere correções nos turnos que ninguém verificou. A seção parte de uma pasta de gravações sem transcrição.

Transcrevendo as gravações

Ponha as gravações na pasta media/ do projeto e transcreva as gravações na máquina do servidor:

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 executa o WhisperX quando o WhisperX está instalado e funciona na máquina, e o faster-whisper no caso contrário. O extra [transcribe] instala o faster-whisper, e o WhisperX é uma instalação separada (pip install whisperx) que traz o próprio PyTorch. O Potato recorre ao faster-whisper quando o WhisperX está ausente, não importa, não consegue rodar no dispositivo ou não consegue carregar o modelo, e o resumo nomeia o motor de cada arquivo. --asr-engine whisperx ou --asr-engine faster-whisper executa um motor sem recurso alternativo. --media-url-prefix /media grava o caminho de cada gravação como /media/<file>, o endereço de onde a página de anotação toca a gravação.

--asr-word-timestamps marca o tempo de cada palavra por alinhamento forçado e permite que o WhisperX divida um segmento no fim de uma frase. Nas gravações de teste, o WhisperX retornou um turno por gravação de 10 segundos sem a opção e três turnos por gravação com a opção. Turnos mais curtos dão mais exemplos ao whisper-asr, e a janela de entrada do Whisper é de 30 segundos. Formatos de transcrição e Como anotar transcrições do Whisper cobrem as opções de transcrição, os rótulos de falantes e a saída existente do Whisper.

A configuração de transcrição

Um esquema speech_transcript mostra cada turno da transcrição com o intervalo de tempo e uma caixa de correção. A configuração completa abaixo passa em 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 nomeia o campo sob o qual potato transcripts grava a transcrição. error_types: [asr_error] deixa uma única marca de erro, porque o estudo cobre apenas erros de transcrição. language: en fixa o idioma para o treinamento e a predição. Quando não definido, um Whisper multilíngue detecta o idioma uma vez a partir de até 16 turnos de treinamento, e o log da execução avisa quando menos de três em cada quatro dos turnos amostrados concordam.

Turnos corrigidos como exemplos de treinamento

Cada turno corrigido é um exemplo, formado pelo áudio do turno cortado da gravação pelo início e pelo fim do turno, junto com o texto corrigido. Um turno que ninguém corrigiu não é um exemplo, porque o esquema salva apenas os turnos que um anotador tocou, e um turno intocado pode estar certo ou pode não ter sido lido. Um turno marcado sem correção também não é um exemplo. Turnos mais longos que 30 segundos ficam de fora, com um aviso. O treinador se recusa a executar com menos de 10 turnos corrigidos na divisão train.

Corrija todo turno errado nas gravações que você abrir, porque a pontuação em itens reservados é calculada sobre os turnos corrigidos. Nas 12 gravações de teste, o WhisperX com tiny.en errou 11 de 36 turnos, com erros como "Epsilanti" para Ypsilanti, "Cary Town" para Kerrytown e um "I" omitido no início de um turno.

Treinando e comparando com a transcrição

Escolha whisper-asr e o esquema transcript na página Training e clique em Train now. A pontuação principal é word_accuracy, que é 1 menos a taxa de erro de palavras (WER) sobre os turnos corrigidos. A execução também informa wer_asr, a WER da transcrição original nos mesmos turnos, e um turno que o modelo deixou como está é avaliado como o texto da transcrição. Compare os dois números antes de publicar qualquer coisa. Um modelo ajustado só vale a pena ser mostrado aos anotadores quando a WER do modelo é menor que wer_asr.

A execução de teste por trás desta página mostra por que a comparação importa. Com 8 turnos corrigidos em train, min_instances reduzido para 4 e openai/whisper-tiny treinado por 3 épocas, a execução obteve uma WER de 0,31 em test contra 0,19 da transcrição original. Um modelo nesse nível substituiria texto certo por texto errado. Colete mais correções, ou parta de um checkpoint maior, e treine de novo antes de adicionar writeback.

Publicando correções sugeridas

Quando o modelo superar a transcrição, adicione o esquema a writeback, reinicie e treine de novo:

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

A predição transcreve todos os turnos de todas as gravações reservadas e não rotuladas. Um turno cujo novo texto difere da transcrição se torna uma correção sugerida, marcada como asr_error, com a probabilidade média dos tokens do modelo como confiança da sugestão. As sugestões preenchem as caixas de correção, e um anotador mantém, edita ou apaga cada sugestão.

Transcrevendo novas gravações com o modelo ajustado

Por padrão, a execução também grava ct2/, uma cópia int8 do modelo em CTranslate2, entre os artefatos da execução. A cópia precisa do pacote ctranslate2, que o extra [transcribe] instala com o faster-whisper. Passe o caminho da cópia a potato transcripts para transcrever o próximo lote de gravações com o modelo ajustado:

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

O WhisperX e o faster-whisper carregam a cópia. A página da execução mostra o id de cada execução, e a configuração descreve as pastas das execuções.

Detectando chamadas em espectrogramas

Um esquema spectrogram_annotation faz os anotadores desenharem caixas de tempo e frequência em torno de chamadas. torchvision-detect e ultralytics-detect treinam com essas caixas renderizando cada gravação como uma imagem de espectrograma do modo como o widget desenha o espectrograma. A renderização põe a frequência em um eixo linear de min_freq do esquema até max_freq, ou metade da taxa de amostragem quando max_freq não está definido, com 256 pixels de altura e 100 pixels por segundo. Cada caixa se torna uma caixa de imagem. Tempo e frequência mapeiam linearmente para pixels. O IoU de uma caixa na imagem é portanto igual ao IoU da caixa em segundos por hertz. Uma caixa sem faixa de frequência, como a que um rótulo do Audacity ou uma linha do BirdNET fornece, cobre toda a banda. Uma gravação de 41 segundos ou mais é renderizada com pelo menos 4.096 pixels de largura e é cortada em janelas e reunida de volta.

As caixas geralmente vêm de uma importação. potato import lê tabelas de seleção do Raven, trilhas de rótulos do Audacity e a saída do BirdNET-Analyzer em um projeto spectrogram_annotation, como descrevem Bioacústica no Potato e Verifique detecções do BirdNET em um espectrograma. Os treinadores aprendem com as caixas que os anotadores desenharam ou corrigiram, e os detectores leem os pixels do espectrograma em vez dos embeddings do BirdNET ou do Perch.

A configuração abaixo passa em validate_cli --strict e define o score_threshold do detector como 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

O espectro de uma gravação de 16 kHz termina em 8 kHz, e max_freq: 8000 mostra toda a banda. O score_threshold padrão de 0,25 mantém mais palpites do detector. No projeto de teste de 24 gravações, torchvision-detect com o limiar padrão previu 34 caixas para 10 chamadas anotadas nas gravações test, e cada caixa extra é mais uma caixa para um anotador excluir.

Cada linha de dados nomeia a gravação, como em {"id": "site_00", "audio_url": "/media/site_00.wav"}. Um detector treina apenas com gravações que têm pelo menos uma caixa, porque uma gravação sem caixas tem a mesma aparência de uma gravação que ninguém verificou. Os detectores precisam de 20 gravações anotadas na divisão train por padrão (min_instances).

torchvision-detect ajusta um Faster R-CNN a partir dos pesos COCO do torchvision, e ultralytics-detect treina um detector YOLO. O detector YOLO é mais rápido de treinar e de executar. O Ultralytics tem licença AGPL-3.0, e um modelo treinado e distribuído com o Ultralytics está sujeito aos termos da AGPL. A página Training pede que você confirme a licença antes de uma execução de ultralytics-detect, e uma execução pela API precisa de "accept_licence": true. Os dois detectores são avaliados pelo mAP com IoU 0,5 no espectrograma renderizado, e os dois gravam de volta as caixas previstas em start_s, end_s, low_hz e high_hz, marcadas como saída de modelo, para preencher o widget. Modelos de visão cobre os parâmetros dos detectores e a divisão em blocos.

Classificando eventos sonoros com hf-audio-tagger

hf-audio-tagger aprende os segmentos de tempo rotulados de um esquema audio_annotation, como fala, música, chamadas ou tosses. O treinador ajusta um codificador de fala, facebook/wav2vec2-base por padrão, para dizer quais rótulos estão ativos em cada quadro de cerca de 20 ms. Cada rótulo é avaliado separadamente. Segmentos sobrepostos com rótulos diferentes são portanto aprendidos como foram anotados. Os segmentos previstos voltam como regiões editáveis na forma de onda. A configuração abaixo passa em 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

O classificador trata qualquer trecho de uma gravação que nenhum anotador marcou como "nenhum rótulo aqui". A suposição serve a um estudo em que os anotadores marcam todos os eventos, e a descrição do esquema acima pede "todas as chamadas". Onde os anotadores marcam apenas alguns eventos, o modelo aprende a perder o resto. A pontuação principal é o F1 de segmentos, em que um segmento previsto corresponde a um segmento anotado com o mesmo rótulo com IoU de pelo menos 0,5, e a execução também informa o IoU médio dos segmentos correspondentes. O treinador precisa de 10 gravações anotadas na divisão train por padrão.

A página Training oferece hf-audio-tagger e diarization para um esquema audio_annotation. Escolha hf-audio-tagger quando um rótulo nomeia um tipo de som e significa a mesma coisa em todas as gravações. Escolha diarization quando os rótulos são falantes cujos nomes são locais a cada gravação.

As execuções por trás desta página

Os comandos e as configurações desta página foram executados com o Potato 2.14.0 em um notebook, com os modelos menores citados abaixo. O caminho de diarização rodou de ponta a ponta, desde uma importação RTTM de 16 gravações sintéticas de dois falantes com 20% dos turnos recebendo o falante errado, passando por correções em 12 gravações, uma execução de diarization e a gravação de volta, até a exportação segments. A execução usou um codificador de teste de uma camada no lugar do WavLM. A pontuação da execução portanto não diz nada sobre fala real. A seção do Whisper usou 12 gravações de fala sintetizada, transcritas pelo WhisperX com tiny.en e ajustadas a partir de openai/whisper-tiny. As seções de espectrograma e de classificador usaram 24 gravações sintéticas de tons a 3 kHz e 6 kHz. Todo bloco de configuração passa em python -m potato.validate_cli --strict.

Leitura complementar

• A visão geral do treinamento de modelos explica o ciclo de treinamento, a página Training e as pontuações em itens reservados.
• Treinadores lista todos os treinadores com os esquemas, a instalação e os parâmetros.
• A configuração documenta todas as chaves de model_training, a gravação de volta e as rotas.
• Modelo no ciclo cobre a revisão de pré-rótulos e o retreinamento automático.
• Anotação de áudio configura tarefas de classificação, eventos, transcrição e diarização.
• Formatos de transcrição lista todos os formatos de transcrição que o Potato lê.
• A referência do projeto original documenta, parâmetro por parâmetro, diarization, whisper-asr, hf-audio-tagger e espectrogramas.

Referências

• 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