Download do alinhador forçado ctc - download do código-fonte do alinhador forçado ctc

alinhador forçado ctc

Outro código-fonte

v0.2

Baixar

Alinhamento forçado com modelos CTC de rosto abraçado

Por favor, marque o projeto com estrela no github (veja o canto superior direito) se você aprecia minha contribuição para a comunidade!

Este pacote Python fornece uma maneira eficiente de realizar alinhamento forçado entre texto e áudio usando modelos pré-treinados do Hugging Face. Ele aproveita o poder dos modelos Wav2Vec2, HuBERT e MMS para um alinhamento preciso, tornando-o uma ferramenta poderosa para a criação de corpus de fala.

Características

Pelo menos 5 vezes menos uso de memória: implementação aprimorada para usar muito menos memória do que a API de alinhamento forçado TorchAudio.
Ampla variedade de suporte a idiomas: funciona com vários idiomas, incluindo inglês, árabe, russo, alemão e mais 1126 idiomas.
Flexibilidade na granularidade do alinhamento: Escolha entre alinhar em nível de frase, palavra ou caractere.
Parâmetros de alinhamento personalizáveis: controle a frequência de inserção do token , limite de mesclagem para mesclagem de segmentos e muito mais.
Integração com os modelos do Hugging Face: Aproveite o poder dos modelos Wav2Vec2, HuBERT e MMS pré-treinados para um alinhamento preciso.
Aceleração de GPU: Utilize sua GPU para inferência mais rápida.
Saída em formato JSON: Fornece resultados de alinhamento claros e estruturados para fácil análise e integração.

Instalação

pip install git+https://github.com/MahmoudAshraf97/ctc-forced-aligner.git

Uso

ctc-forced-aligner --audio_path " path/to/audio.wav " --text_path " path/to/text.txt " --language " eng " --romanize

Uso de terminais

Argumentos

Argumento	Descrição	Padrão
`--audio_path`	Caminho para o arquivo de áudio	Obrigatório
`--text_path`	Caminho para o arquivo de texto	Obrigatório
`--language`	Idioma no código ISO 639-3	Obrigatório
`--romanize`	Habilitar romanização para scripts não latinos ou para modelos multilíngues, independentemente do idioma, obrigatório ao usar o modelo padrão	Falso
`--split_size`	Granularidade de alinhamento: "frase", "palavra" ou "caractere"	"palavra"
`--star_frequency`	Frequência do token : "segmento" ou "arestas"	"bordas"
`--merge_threshold`	Limite de mesclagem para mesclagem de segmentos	0,00
`--alignment_model`	Nome do modelo de alinhamento	MahmoudAshraf/mms-300m-1130-alinhador forçado
`--compute_dtype`	Calcular dtype para inferência	"float32"
`--batch_size`	Tamanho do lote para inferência	4
`--window_size`	Tamanho da janela em segundos para fragmentação de áudio	30
`--context_size`	Sobreposição entre pedaços em segundos	2
`--attn_implementation`	Implementação de atenção	"ansioso"
`--device`	Dispositivo a ser usado para inferência: “cuda” ou “cpu”	"cuda" se disponível, senão "cpu"

Exemplos

 # Align an English audio file with the text file
ctc-forced-aligner --audio_path " english_audio.wav " --text_path " english_text.txt " --language " eng " --romanize

# Align a Russian audio file with romanized text
ctc-forced-aligner --audio_path " russian_audio.wav " --text_path " russian_text.txt " --language " rus " --romanize

# Align on a sentence level
ctc-forced-aligner --audio_path " audio.wav " --text_path " text.txt " --language " eng " --split_size " sentence " --romanize

# Align using a model with native vocabulary
ctc-forced-aligner --audio_path " audio.wav " --text_path " text.txt " --language " ara " --alignment_model " jonatasgrosman/wav2vec2-large-xlsr-53-arabic "

Uso de Python

 import torch
from ctc_forced_aligner import (
    load_audio ,
    load_alignment_model ,
    generate_emissions ,
    preprocess_text ,
    get_alignments ,
    get_spans ,
    postprocess_results ,
)

audio_path = "your/audio/path"
text_path = "your/text/path"
language = "iso" # ISO-639-3 Language code
device = "cuda" if torch . cuda . is_available () else "cpu"
batch_size = 16


alignment_model , alignment_tokenizer = load_alignment_model (
    device ,
    dtype = torch . float16 if device == "cuda" else torch . float32 ,
)

audio_waveform = load_audio ( audio_path , alignment_model . dtype , alignment_model . device )


with open ( text_path , "r" ) as f :
    lines = f . readlines ()
text = "" . join ( line for line in lines ). replace ( " n " , " " ). strip ()

emissions , stride = generate_emissions (
    alignment_model , audio_waveform , batch_size = batch_size
)

tokens_starred , text_starred = preprocess_text (
    text ,
    romanize = True ,
    language = language ,
)

segments , scores , blank_token = get_alignments (
    emissions ,
    tokens_starred ,
    alignment_tokenizer ,
)

spans = get_spans ( tokens_starred , segments , blank_token )

word_timestamps = postprocess_results ( text_starred , spans , stride , scores )

Saída

Os resultados do alinhamento serão salvos em um arquivo contendo as seguintes informações no formato JSON:

text : O texto alinhado.
segments : uma lista de segmentos, cada um contendo a hora de início e de término do segmento de texto correspondente.

JSON

{
  "text" : " This is a sample text to be aligned with the audio. " ,
  "segments" : [
    {
      "start" : 0.000 ,
      "end" : 1.234 ,
      "text" : " This "
    },
    {
      "start" : 1.234 ,
      "end" : 2.567 ,
      "text" : " is "
    },
    {
      "start" : 2.567 ,
      "end" : 3.890 ,
      "text" : " a "
    },
    {
      "start" : 3.890 ,
      "end" : 5.213 ,
      "text" : " sample "
    },
    {
      "start" : 5.213 ,
      "end" : 6.536 ,
      "text" : " text "
    },
    {
      "start" : 6.536 ,
      "end" : 7.859 ,
      "text" : " to "
    },
    {
      "start" : 7.859 ,
      "end" : 9.182 ,
      "text" : " be "
    },
    {
      "start" : 9.182 ,
      "end" : 10.405 ,
      "text" : " aligned "
    },
    {
      "start" : 10.405 ,
      "end" : 11.728 ,
      "text" : " with "
    },
    {
      "start" : 11.728 ,
      "end" : 13.051 ,
      "text" : " the "
    },
    {
      "start" : 13.051 ,
      "end" : 14.374 ,
      "text" : " audio. "
    }
  ]
}

Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para abrir um problema ou enviar uma solicitação pull.

Licença

Este projeto está licenciado sob a licença BSD, observe que o modelo padrão possui licença CC-BY-NC 4.0, portanto, certifique-se de usar um modelo diferente para uso comercial.