Turkish Text to Speech

Texto para fala turco

Índice

• Configurar
• Pré -processamento de texto (conversão fonética e normalização para turco)
• Preparação de dados
• Treinamento FastPitch do zero (gerador de espectrograma)
• Ajustando o modelo com Hifi-Gan (gerador de formas de onda)
• Inferência

---

Configurar

Este repositório contém um Dockerfile que estende o contêiner Pytorch 21.02-PY3 NGC e encapsula algumas dependências. Para criar seu próprio contêiner, escolha um contêiner Pytorch nas versões de contêiner nvidia pytorch e crie um Dockerfile como o seguinte formato:

 FROM nvcr . io / nvidia / pytorch : 21.02 - py3
WORKDIR / path / to / working / directory / text2speech /
COPY requirements . txt .
RUN pip install - r requirements . txt

1. Construir e correr Docker

Vá para o /path/to/working/directory/text2speech/docker

$ docker build - - no - cache - t torcht2s .
$ docker run - it - - rm - - gpus all - p 2222 : 8888 - v / path / to / working / directory / text2speech : / path / to / working / directory / text2speech torcht2s

2. Adicione o ambiente ao Jupyter Notebook e inicie o Jupyter Notebook

$ python - m ipykernel install - - user - - name = torcht2s
$ jupyter notebook - - ip = 0.0 . 0.0 - - port = 8888 - - no - browser - - allow - root

3. Abra um navegador da sua máquina local e navegue para http://127.0.0.1:2222/?token=${TOKEN} e digite seu token especificado no seu terminal.

---

Pré -processamento de texto (conversão fonética e normalização para turco)

Para treinar modelos de síntese de fala, são necessários sons e sequências de fonemas que expressam sons. Esse é o WYH na primeira etapa, o texto de entrada é codificado em uma lista de símbolos. Neste estudo, usaremos caracteres e fonemas turcos como símbolos. Como turco é uma linguagem fonética, as palavras são expressas à medida que são lidas. Ou seja, as seqüências de caracteres são construídas palavras em turco. Em línguas não fonéticas como o inglês, as palavras podem ser expressas com fonemas. Para sintetizar o discurso turco com os dados em inglês, as palavras no conjunto de dados em inglês primeiro devem ser traduzidas foneticamente para turco.

• Neste estudo, foram utilizados cmudict_tr e heterônimos_tr. O Cmudict (léxico fonético turco) é um dicionário que expressa foneticamente cerca de 1,5 milhão de palavras em turco.
• Os fonemes a seguir representam a pronúncia turca dos fonemas.

 valid_symbols = [ '1' , '1:' , '2' , '2:' , '5' , 'a' , 'a:' , 'b' , 'c' , 'd' , 'dZ' , 'e' , 'e:' , 'f' , 'g' , 'gj' , 'h' , 'i' , 'i:' , 'j' ,
  'k' , 'l' , 'm' , 'n' , 'N' , 'o' , 'o:' , 'p' , 'r' , 's' , 'S' , 't' , 'tS' , 'u' , 'u' , 'v' , 'y' , 'y:' , 'z' , 'Z' ]

• A normalização do texto converte o texto da forma escrita em sua forma verbalizada e é uma etapa essencial de pré-processamento antes da síntese de texto em fala. Ele garante que o TTS possa lidar com todos os textos de entrada sem pular símbolos desconhecidos. A normalização do texto é aplicada para declarações turcas.

---

Preparação de dados

Para acelerar o treinamento, eles podem ser gerados durante a etapa de pré-processamento e ler diretamente do disco durante o treinamento. Siga estas etapas para usar o conjunto de dados personalizado.

1. Prepare um diretório com arquivos .wav, listas de filmes (divisão de treinamento/validação dos dados) com transcrições e caminhos para os arquivos .wav sob o text2speech/Fastpitch/dataset/ Location. Esses filmes devem listar um único enunciado por linha como:

 < audio file path > | < transcript >

2. Execute o script de pré-processamento para calcular pitch e mels com text2speech/Fastpitch/data_preperation.ipynb

$ python prepare_dataset . py  
    - - wav - text - filelists dataset / tts_data . txt  
    - - n - workers 16 
    - - batch - size 1 
    - - dataset - path dataset 
    - - extract - pitch 
    - - f0 - method pyin 
    - - extract - mels 

3. Prepare listas de arquivos com caminhos para pinças pré-calculadas em execução create_picth_text_file(manifest_path) de text2speech/Fastpitch/data_preperation.ipynb Esses filmes devem listar um único enunciado por linha como:

 < mel or wav file path > | < pitch file path > | < text > | < speaker_id >

O conjunto de dados completo tem a seguinte estrutura:

. / dataset
├── mels
├── pitch
├── wavs
├── tts_data . txt  # train + val
├── tts_data_train . txt
├── tts_data_val . txt
├── tts_pitch_data . txt  # train + val
├── tts_pitch_data_train . txt
├── tts_pitch_data_val . txt

---

Treinamento FastPitch do zero (gerador de espectrograma)

O treinamento produzirá um modelo FastPitch capaz de gerar espectrogramas MEL a partir de texto bruto. Ele será serializado como um único arquivo de ponto de verificação .pt , juntamente com uma série de pontos de verificação intermediários.

$ python train . py - - cuda - - amp - - p - arpabet 1.0 - - dataset - path dataset  
                - - output saved_fastpicth_models / 
                - - training - files dataset / tts_pitch_data_train . txt  
                - - validation - files dataset / tts_pitch_data_val . txt  
                - - epochs 1000 - - learning - rate 0.001 - - batch - size 32 
                - - load - pitch - from - disk

---

Ajustando o modelo com Hifi-Gan

A última etapa é converter o espectrograma na forma de onda. O processo para gerar fala do espectrograma também é chamado de vocoder.

Alguns geradores de espectrograma MEL são propensos a modelar viés. Como os espectrogramas diferem dos dados verdadeiros nos quais o HIFI-GAN foi treinado, a qualidade do áudio gerado pode sofrer. Para superar esse problema, um modelo HIFI-GAN pode ser ajustado às saídas de um gerador de espectrograma MEL específico para se adaptar a esse viés. Nesta seção, executaremos o ajuste fino em saídas de compitch rápido.

1. Gerar espectrogramas MEL para todas as enunciados no conjunto de dados com o modelo FastPitch

• Copie o arquivo de saída FastPitch mais bem-informado .PT no text2speech/Hifigan/data/pretrained_fastpicth_model/ Diretório.
• Copiar arquivo manifesto tts_pitch_data.txt no text2speech/Hifigan/data/ diretório.

$ python extract_mels . py - - cuda 
    - o data / mels - fastpitch - tr22khz  
    - - dataset - path / text2speech / Fastpitch / dataset 
    - - dataset - files data / tts_pitch_data . txt  # train + val 
    - - load - pitch - from - disk 
    - - checkpoint - path data / pretrained_fastpicth_model / FastPitch_checkpoint . pt - bs 16

Agora, os espectrogramas MEL devem ser preparados no diretório text2speech/Hifigan/data/mels-fastpitch-tr22khz . O script de ajuste fino carregará um modelo HIFI-GAN existente e executará várias épocas de treinamento usando espectrogramas gerados na última etapa.

2. Tune o modelo FastPitch com Hifi-Gan

Esta etapa produzirá outro arquivo de ponto de verificação do modelo .pt HIFI-GAN FINED para o modelo FastPitch específico.

• Abra uma nova pasta results no diretório text2speech/Hifigan .

$ nohup python train . py - - cuda - - output / results / hifigan_tr22khz 
 - - epochs 1000 - - dataset_path / Fastpitch / dataset 
 - - input_mels_dir / data / mels - fastpitch - tr22khz 
 - - training_files / Fastpitch / dataset / tts_data . txt 
 - - validation_files / Fastpitch / dataset / tts_data . txt 
 - - fine_tuning - - fine_tune_lr_factor 3 - - batch_size 16  
 - - learning_rate 0.0003 - - lr_decay 0.9998 - - validation_interval 10 > log . txt

3. Abra outro terminal e registro de faixa como seguinte

$ tail - f log . txt 

---

Inferência

Execute o seguinte comando para sintetizar o áudio do texto bruto com o gerador MEL-Spectrograma

 python inference . py - - cuda 
  - - hifigan / Hifigan / results / hifigan_tr22khz / hifigan_gen_checkpoint . pt 
  - - fastpitch / Fastpitch / saved_fastpicth_models / FastPitch_checkpoint . pt 
  - i test_text . txt 
  - o wavs /

O discurso é gerado a partir de um arquivo aprovado com o argumento -i . O áudio de saída será armazenado no caminho especificado pelo argumento -o .