Download de Ossian - Download de código -fonte Ossian

Ossian

Código-Fonte de IA

v0.1.0

Baixar

Ossian + DNN Demo

Ossian é uma coleção de código Python para a criação de sistemas de texto em fala (TTS), com ênfase na facilidade de pesquisa na construção de sistemas TTS com supervisão mínima de especialistas. O trabalho foi iniciado com o financiamento do projeto FP7 da UE simples4All, e esse repositório contém uma versão que é considerável mais atualizada do que o disponível anteriormente. Em particular, a versão original do kit de ferramentas se baseou no HTS para executar a modelagem acústica. Embora ainda seja possível usar o HTS, agora ele suporta o uso de redes neurais treinadas com o Merlin Toolkit como duração e modelos acústicos. Todos os comentários e feedback sobre maneiras de melhorá -lo são muito bem -vindos.

Aqui está algum documento chinês. 一些中文文档和总结可以发现于： Doc. Ossiano chinês.

Dependências

Perl 5 é necessário.

Python 2.7 é necessário.

Use o instalador do pacote pip - dentro de um Python virtualenv conforme necessário - para obter alguns pacotes necessários:

 pip install numpy
pip install scipy
pip install configobj
pip install scikit-learn
pip install regex
pip install lxml
pip install argparse

Usaremos o Merlin Toolkit para treinar redes neurais, criando as seguintes dependências:

 pip install bandmat 
pip install theano
pip install matplotlib

Usaremos sox para processar dados de fala:

 apt-get install sox

Obtendo as ferramentas

Clone o repositório Ossian Github da seguinte forma:

 git clone https://github.com/candlewill/Ossian.git

Isso criará um diretório chamado ./Ossian ; A discussão a seguir pressupõe que uma variável de ambiente $OSSIAN esteja definida para apontar para este diretório.

Instale do zero

Ossian conta com o Sistema Hidden Model Toolkit (HTK) e HMM (HTS) para alinhamento e modelagem acústica (opcionalmente)-aqui estão algumas anotações sobre a obtenção e a compilação das ferramentas necessárias. Para obter uma cópia do código -fonte HTK, é necessário se registrar no site HTK para obter um nome de usuário e senha. Supõe -se aqui que estes foram obtidos e as variáveis de ambiente $HTK_USERNAME e $HTK_PASSWORD apontam para eles.

A execução do script a seguir baixará e instalará as ferramentas necessárias (incluindo Merlin):

 ./scripts/setup_tools.sh $HTK_USERNAME $HTK_PASSWORD

O script ./scripts/setup_tools.sh fará as seguintes coisas:

Clones no repo Merlin para $OSSIAN/tools/merlin e redefine sua cabeça para 8aed278

CD na merlin/tools/WORLD/ e construa -o, depois copie analysis e synth em $OSSIAN/tools/bin/ :

 cd $OSSIAN /tools/merlin/tools/WORLD/
make -f makefile
make -f makefile analysis
make -f makefile synth
mkdir -p $OSSIAN /tools/bin/
cp $OSSIAN /tools/merlin/tools/WORLD/build/{analysis,synth} $OSSIAN /tools/bin/

Faça o download do HTK, HDECODE, HTS e aplique o patch HTS. Construa HTK e instale -o em $OSSIAN/tools/ pasta.
Faça o download do HTS-Engine e instale-o em $OSSIAN/tools/
Faça o download do SPTK e instale -o em $OSSIAN/tools/
Os pacotes g2p-r1668-r3 e corenlp-python serão instalados se você mudasse o valor de SEQUITUR , STANFORD de 0 para 1.

Como todas as ferramentas são instaladas em $OSSIAN/tools/ diretório, o diretório $OSSIAN/tools/bin incluiria todos os binários usados pela Ossian.

Instale a partir da pré-criada

Se você instalou as ferramentas mencionadas acima manualmente e não deseja instalar do zero, pode criar um link suave para dizer ao Ossian onde instalou essas ferramentas.

 # 1 Mannuly clone the merlin repo
# 2 Downlaod WORLD, HTK, HDecode, HTS, HTS-engine, SPTK, build and install.
# 3 Copy all of the binaries into one folder. E.g., bin.

# 3 Where is your merlin dir
export merlin_dir=/home/dl80/heyunchao/Programs/Ossian/tools/merlin
# 4 Where is the bin direcotry inculuding all the binaries
export bin_dir=/home/dl80/heyunchao/Programs/Ossian/tools/bin

# 5 Create soft link in your Ossian/tools direcotry
cd /home/dl80/heyunchao/Programs/MyOssian_Github/tools
ln -s $merlin_dir merlin
ln -s $bin_dir bin

Fornecemos uma coleção binária pré-criada aqui Ossian_Required_Bin.tar. Faça o download e vá para o diretório $bin_dir , se alguém não quiser construir para o Scratch.

Adquirir alguns dados

Ossian espera que seus dados de treinamento estejam nos diretórios:

 ./corpus/<OSSIAN_LANG>/speakers/<DATA_NAME>/txt/*.txt
 ./corpus/<OSSIAN_LANG>/speakers/<DATA_NAME>/wav/*.wav

Os arquivos de texto e onda devem ser numerados de forma consistente entre si. <OSSIAN_LANG> e <DATA_NAME> são seqüências arbitrárias, mas é sensato escolher aquelas que fazem sentido óbvio.

Faça o download e descompacte este corpus de brinquedo (romeno) para obter algumas orientações:

 cd $OSSIAN
wget https://www.dropbox.com/s/uaz1ue2dked8fan/romanian_toy_demo_corpus_for_ossian.tar?dl=0
tar xvf romanian_toy_demo_corpus_for_ossian.tar?dl=0

Isso criará as seguintes estruturas de diretório:

 ./corpus/rm/speakers/rss_toy_demo/
./corpus/rm/text_corpora/wikipedia_10K_words/

Vamos começar construindo algumas vozes neste pequeno conjunto de dados. Os resultados parecerão ruins, mas se você conseguir falar, não importa o quanto as ferramentas estejam funcionando e você poderá treinar mais dados de sua própria escolha. Abaixo estão as instruções sobre como treinar vozes baseadas em redes neurais e baseadas em HTS nesses dados.

Você pode baixar conjuntos de dados de 1 hora em vários idiomas que preparamos aqui: http://tundra.simple4all.org/ssw8data.html

Voz baseada em DNN usando uma receita ingênua

Ossian treina vozes de acordo com uma determinada 'receita' - a receita especifica uma sequência de processos aplicados a uma expressão para transformá -la do texto em fala e é fornecida em um arquivo chamado $OSSIAN/recipes/<RECIPE>.cfg (onde <RECIPE> é o nome de uma receita específica que você está usando). Começaremos com uma receita chamada naive_01_nn . Se você deseja adicionar componentes ao sintetizador, a melhor maneira de iniciar será levar o arquivo para uma receita existente, copie -o para um arquivo com um novo nome e modifique -o.

A receita naive_01_nn é uma receita independente de idioma que usa ingenuamente letras como unidades de modelagem acústica. Funcionará razoavelmente para idiomas com ortografias sensíveis (por exemplo, romeno) e menos bem para o inglês.

Ossian colocará todos os arquivos gerados durante o treinamento nos dados <DATA_NAME> no idioma <OSSIAN_LANG> de acordo com a receita <RECIPE> em um diretório chamado:

 $OSSIAN/train/<OSSIAN_LANG>/speakers/<DATA_NAME>/<RECIPE>/

Quando se houver uma voz com sucesso, os componentes necessários na síntese são copiados para:

 $OSSIAN/voices/<OSSIAN_LANG>/<DATA_NAME>/<RECIPE>/

Supondo que queremos começar treinando uma voz do zero, podemos querer verificar se esses locais ainda não existem para nossa combinação de dados/idioma/receita:

 rm -r $OSSIAN/train/rm/speakers/rss_toy_demo/naive_01_nn/ $OSSIAN/voices/rm/rss_toy_demo/naive_01_nn/

Então, para treinar, faça isso:

 cd $OSSIAN
python ./scripts/train.py -s rss_toy_demo -l rm naive_01_nn

Como várias mensagens impressas durante o treinamento o informarão, o treinamento das próprias redes neurais que será usado para a duração e a modelagem acústica não é diretamente suportada na Ossian. Os dados e configurações necessários para treinar redes para duração e modelo acústico são preparados pela linha de comando acima, mas o Merlin Toolkit precisa ser chamado separadamente para realmente treinar os modelos. Os NNs que produz então precisam ser convertidos de volta em um formato adequado para ossianos. Isso é um pouco confuso, mas uma melhor integração entre Ossian e Merlin é uma área contínua de desenvolvimento.

Veja como fazer isso - essas mesmas instruções serão impressas quando você ligou ./scripts/train.py acima. Primeiro, treine o modelo de duração:

 cd $OSSIAN
export THEANO_FLAGS=""; python ./tools/merlin/src/run_merlin.py $OSSIAN/train/rm/speakers/rss_toy_demo/naive_01_nn/processors/duration_predictor/config.cfg

Para esses dados de brinquedos, o treinamento em CPU como essa será rápido. Como alternativa, para usar a GPU para treinamento, faça:

 ./scripts/util/submit.sh ./tools/merlin/src/run_merlin.py $OSSIAN/train/rm/speakers/rss_toy_demo/naive_01_nn/processors/duration_predictor/config.cfg

Se o treinamento correu bem, você poderá exportar o modelo treinado para um formato melhor para a Ossian. O problema básico é que as ferramentas NN-TTS armazenam o modelo como um arquivo de picles do Python-se isso for feito em uma máquina GPU, ele só poderá ser usado em uma máquina GPU. Este script se converte para um formato mais flexível, entendido por Ossian - chame -o com o mesmo arquivo de configuração que você usou para treinamento e o nome de um diretório quando o novo formato for colocado:

 python ./scripts/util/store_merlin_model.py $OSSIAN/train/rm/speakers/rss_toy_demo/naive_01_nn/processors/duration_predictor/config.cfg $OSSIAN/voices/rm/rss_toy_demo/naive_01_nn/processors/duration_predictor

Ao treinar o modelo de duração, haverá muitos avisos dizendo WARNING: no silence found! - Teses não são um problema e podem ser ignorados.

Da mesma forma para o modelo acústico:

 cd $OSSIAN
export THEANO_FLAGS=""; python ./tools/merlin/src/run_merlin.py $OSSIAN/train/rm/speakers/rss_toy_demo/naive_01_nn/processors/acoustic_predictor/config.cfg

Ou:

 ./scripts/util/submit.sh ./tools/merlin/src/run_merlin.py $OSSIAN/train/rm/speakers/rss_toy_demo/naive_01_nn/processors/acoustic_predictor/config.cfg

Então:

 python ./scripts/util/store_merlin_model.py $OSSIAN/train/rm/speakers/rss_toy_demo/naive_01_nn/processors/acoustic_predictor/config.cfg $OSSIAN/voices/rm/rss_toy_demo/naive_01_nn/processors/acoustic_predictor

Se o treinamento correu bem, você pode sintetizar o discurso. Há um exemplo de frase romena em $OSSIAN/test/txt/romanian.txt - sintetizaremos um arquivo de onda em $OSSIAN/test/wav/romanian_toy_naive.wav como este:

 mkdir $OSSIAN/test/wav/

python ./scripts/speak.py -l rm -s rss_toy_demo -o ./test/wav/romanian_toy_HTS.wav naive_01_nn ./test/txt/romanian.txt

Você pode encontrar o áudio para esta frase aqui para comparação (ela não foi usada no treinamento).

Os arquivos de configuração usados para a duração e o treinamento de modelos acústicos funcionarão como está para o conjunto de dados de brinquedos, mas quando você passar para outros conjuntos de dados, você deseja experimentar editá-los para obter melhor permanência. Em particular, você deseja aumentar o treinamento para treinar vozes em quantidades maiores de dados; Isso pode ser definido como por exemplo, 30 para o modelo acústico e por exemplo, 100 para o modelo de duração. Você também deseja experimentar o Learning_rate, Batch_size e a arquitetura de rede (HIDNEL_LAYER_SIZE, HENDEN_LAYER_TYPE). Atualmente, a Ossian suporta apenas redes de feed-forward.

Síntese

O comando para síntese a nova onda dada o texto como entrada é:

python ./scripts/speak.py -l $OSSIAN_LANG -s $DATA_NAME -o ./test/wav/ ${OSSIAN_LANG} _ ${DATA_NAME} _test.wav $RECIPE ./test/txt/test.txt

Onde ./test/wav/${OSSIAN_LANG}_${DATA_NAME}_test.wav sian_lang }_$ {data_name }_test.wav e $RECIPE ./test/txt/test.txt são a onda sintetizada e o texto de entrada.

O uso completo do speak.py é:

usage: speak.py [-h] -s SPEAKER -l LANG [-o OUTPUT] [-t STAGE] [-play] [-lab]
                [-bin CUSTOM_BINDIR]
                config [files [files ...]]

positional arguments:
  config              configuration to use: naive, semi-naive, gold, as
                      defined in < ROOT > /recipes/ < config > -d irectory
  files               text files to speak, reading from stdin by default

optional arguments:
  -h , --help          show this help message and exit
  -s SPEAKER          the name of the speaker: < ROOT > /corpus/ < LANG > / < SPEAKER >
  -l LANG             the language of the speaker: < ROOT > /corpus/ < LANG >
  -o OUTPUT           output audio here
  -t STAGE            defines the current usage stage (definitions of stages
                      should by found in < config > /recipe.cfg
  -play               play audio after synthesis
  -lab                make label file as well as wave in output location
  -bin CUSTOM_BINDIR

Se você deseja exportar seu modelo pre-trained , deve embalar os seguintes arquivos:

voice/
train/cn/speakers/king_cn_corpus/naive_01_nn.cn/questions_dur.hed.cont
train/cn/speakers/king_cn_corpus/naive_01_nn.cn/questions_dur.hed
train//cn/speakers/king_cn_corpus/naive_01_nn.cn/questions_dnn.hed.cont

Então, depois de colocá -los no diretório certo, alguém poderia usar seu modelo para síntese, dado o texto.

Modelo pré-treinado

Aqui, fornecemos um modelo simples pré-treinado para o TTS chinês. Como o modelo é treinado em um pequeno corpus interno limitado para testes, a qualidade da voz sintetizada não é muito boa.

Modelo chinês pré-treinado simples: Ossian_cn_pretringen_model.tar.gz

Algumas amostras geradas a partir deste modelo poderiam ser encontradas aqui: ossian_chinese_samples.zip

Último Repo Merlin

Se você deseja usar o mais recente repo Merlin, é possível agora. No entanto, quando o modelo de exportação, alguns files no exist ocorreria. Você pode copiar manualmente os arquivos correspondentes para a pasta certa para lidar com ela. Esses arquivos existem após o treinamento, mas não no diretório certo. Você pode usar find -name *.dat para descobrir onde eles estão.

Aqui está um exemplo:

 # Duration model
cp ./train/cn/speakers/toy_cn_corpus/naive_01_nn.cn/dnn_training_ACOUST/inter_module/norm_info__mgc_lf0_vuv_bap_187_MVN.dat /root/Ossian/train/cn/speakers/toy_cn_corpus/naive_01_nn.cn//cmp//norm_info_mgc_lf0_vuv_bap_187_MVN.dat

cp ./train/cn/speakers/toy_cn_corpus/naive_01_nn.cn/dnn_training_ACOUST/inter_module/label_norm_HTS_3491.dat /root/Ossian/train/cn/speakers/toy_cn_corpus/naive_01_nn.cn//cmp//label_norm_HTS_3491.dat

cp ./train/cn/speakers/toy_cn_corpus/naive_01_nn.cn/dnn_training_ACOUST/nnets_model/feed_forward_6_tanh.model /root/Ossian/train/cn/speakers/toy_cn_corpus/naive_01_nn.cn//dnn_training_ACOUST//nnets_model/DNN_TANH_TANH_TANH_TANH_TANH_TANH_LINEAR__mgc_lf0_vuv_bap_0_6_1024_1024_1024_1024_1024_1024_3491.187.train.243.0.002000.rnn.model

# Acoustic model
cp ./train/cn/speakers/toy_cn_corpus/naive_01_nn.cn/dnn_training_DUR/inter_module/norm_info__dur_5_MVN.dat /root/Ossian/train/cn/speakers/toy_cn_corpus/naive_01_nn.cn///norm_info_dur_5_MVN.dat

cp ./train/cn/speakers/toy_cn_corpus/naive_01_nn.cn/dnn_training_DUR/inter_module/label_norm_HTS_3482.dat /root/Ossian/train/cn/speakers/toy_cn_corpus/naive_01_nn.cn/
...

Outras receitas

Utilizamos muitas outras receitas com ossianos que serão documentados aqui quando limpos o suficiente para serem úteis para outras pessoas. Isso fornecerá a capacidade de adicionar mais conhecimento às vozes construídas, na forma de léxicos, regras de letra a som etc. e integrar componentes treinados existentes onde estão disponíveis para o idioma de destino. Alguns deles podem ser encontrados aqui: