TF NNLM TK
1.0.0
O TF-NNLM-TK é um kit de ferramentas escrito no Python3 para modelagem de linguagem de rede neural usando o TensorFlow. Inclui modelos básicos como RNNs e LSTMs, além de modelos mais avançados. Ele fornece funcionalidade para pré -processar os dados, treinar os modelos e avaliá -los. O kit de ferramentas é de código aberto sob a licença Apache 2.
Atualmente, os seguintes modelos são suportados:
Primeiro instale o python e o tensorflow. O código é testado com Python 3 e Tensorflow 1.8.
Para este primeiro exemplo, precisamos baixar o kit de ferramentas e alguns dados de treinamento. Usaremos o conjunto de dados PTB fornecido no tutorial de Tomas Mikolov. Para isso, você pode executar o seguinte código em sua linha de comando:
git clone git clone https://github.com/uds-lsv/TF-NNLM-TK.git
cd TF-NNLM-TK
wget http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz
tar -xzf simple-examples.tgzEntão, para treinar e avaliar um primeiro modelo de linguagem neural simples e simples, basta executar o seguinte código
python train_basic_rnn_models.py --save_dir=small_lstm --model=lstm --train_file=simple-examples/data/ptb.train.txt --test_file=simple-examples/data/ptb.test.txt
python test.py --model_file=small_lstm/model.ckpt --test_file=simple-examples/data/ptb.test.txtO treinamento leva cerca de 20 minutos em uma GPU GTX 1050TI.
Os scripts de treinamento já chamam o código de processamento de dados. Se você usar os dados padrão, provavelmente poderá pular esta seção.
O kit de ferramentas inclui um processador de dados, que lê um arquivo de texto e cria duas matrizes (Numpy) que armazenam os lotes das palavras de entrada (história) e palavras -alvo (previsão). O código também fornece algumas ferramentas úteis, como a funcionalidade para criar e salvar o vocabulário, criar contagens ou mapear palavras Oov em arquivos de teste em um determinado token desconhecido.
Esta parte do código não possui uma função principal. Em vez disso, é chamado diretamente no código Python dos scripts de treinamento. Por exemplo, você pode ligar para Python
DataProcessor ( train_file , batch_size , seq_length , True , '<unk>' , history_size = history_size )Este snippet de código pega o Train_File, fará as transformações descritas acima e criará lotes a partir dele usando os parâmetros fornecidos.
O TF-NNLM-TK fornece o código de treinamento para os seguintes modelos de idiomas neurais:
Estes são comumente conhecidos e usados. Em particular, este kit de ferramentas implementa a baunilha-rnn, LSTM, LSTM com projeção e GRU. Esses modelos podem ser treinados usando o script Train_basic_rnn_models.py (veja o exemplo abaixo).
Esses modelos usam mais do que n palavras da história em vez do último. A implementação fornece três modelos: SRNN dependente de palavras (WD-SRNN), SRNN independente de palavras (Wi-srnn) e SRNN do fator esquecedor (ff-srnn). Mais informações sobre esses modelos podem ser encontradas aqui. Esses modelos podem ser treinados usando o script Train_srnn.py
Esses modelos usam dois estados locais e globais separados para aprender dependências de curto e longo alcance separadamente. A implementação segmentar de TF da propagação de volta faz com que esse modelo sofra drasticamente com o gradiente de fuga no estado local, que usa um modelo de baunilha-RNN, assim o último é substituído (temporariamente por um GRU). Mais informações sobre este modelo podem ser encontradas aqui. Este modelo pode ser treinado usando o script Train_lsrc.py
Cada um desses scripts de treinamento (trens_basic_rnn_models.py, trens_srnn.py e trens_lsrc.py) inclui um grande número de parâmetros, cada um deles tem uma descrição anexada a ele. Para obter esta descrição, execute, por exemplo, em sua linha de comando:
python train_basic_rnn_models.py --helpOs parâmetros padrão de todos os modelos tentam corresponder à pequena configuração relatada na receita TensorFlow PTB-LM:
| Config | épocas | trem | válido | teste |
|---|---|---|---|---|
| pequeno | 13 | 37.99 | 121.39 | 115.91 |
| médio | 39 | 48.45 | 86.16 | 82.07 |
| grande | 55 | 37.87 | 82.62 | 78.29 |
Para reproduzir esses números com o modelo LSTM (na verdade, números melhores devido à inicialização do Xavier), execute (ajustando o caminho para os dados para sua configuração):
python train_basic_rnn_models.py --save_dir=small_lstm --model=lstm --train_file=path/to/data/train.txt --test_file=path/to/data/test.txtEsta chamada treinará o modelo LSTM nos dados do PTB usando exatamente a mesma configuração usada na receita do tensorflow. Se você deseja executar o modelo com a configuração média, basta definir os parâmetros para seus valores especificados na configuração média:
python train_basic_rnn_models.py --init_scale=0.05 --seq_length=35 --embed_size=650 --hidden_size=650 --max_epoch=6 --num_epochs=39 --decay_rate=0.8 --batch_size=20 --input_keep_prob=0.5 --output_keep_prob=0.5 --model=lstm --save_dir=medium_lstm --train_file=path/to/data/train.txt --test_file=path/to/data/test.txtA mesma ideia se aplica aos modelos mais avançados, exceto que você precisa chamar os scripts de treinamento correspondentes e que você pode precisar ajustar ligeiramente os parâmetros. Tente, por exemplo:
python train_srnn.py --model=wi-srnn --input_keep_prob=0.6 --save_dir=wisrnn_small_5gram --train_file=path/to/data/train.txt --test_file=path/to/data/test.txt Para treinar o modelo Wisrnn com a configuração padrão, exceto a palavra que incorpora o abandono, que é definido como 0,4 (1-0,6). Isso deve levar a um desempenho de ~ 109,5 no conjunto de dados de exemplo de cima.
Da mesma forma, o modelo LSRC é treinado usando o script correspondente:
python train_lsrc.py --save_dir=lsrc_small --train_file=path/to/data/train.txt --test_file=path/to/data/test.txt O script também permite modificar o treinamento definindo os parâmetros correspondentes. Use -Help para obter mais informações sobre eles.
O script de teste é o mesmo para todos os modelos. Você só precisa especificar o caminho para o modelo que deseja avaliar e o caminho para o seu arquivo de teste. Para avaliar o pequeno modelo LSTM que treinamos acima, só precisamos executar o seguinte comando:
python test.py --model_file=small_lstm/model.ckpt --test_file=path/to/data/test.txt O script também oferece alguns outros parâmetros para controlar a velocidade, caso você esteja testando em um corpus muito grande.
Este kit de ferramentas foi originalmente desenvolvido por Youssef Oualil, durante seu tempo na LSV, Universidade Saarland. Atualmente, é causado no grupo LSV por Michael A. Hedderich com contribuições de Adam Kusmirek. Este trabalho foi financiado em parte pelo SFB 1102.
Este código está licenciado no Apache 2.0. As partes deste código são baseadas na receita TensorFlow PTB-LM licenciada sob a licença Apache, versão 2.0 pelos autores do TensorFlow. Consulte o arquivo de licença para obter detalhes.
Se você usar este kit de ferramentas como parte de uma publicação, considere nos citar:
@inproceedings{oualil-singh-greenberg-klakow:EMNLP2016,
author = {Oualil, Youssef and Singh, Mittul and Greenberg, Clayton and Klakow, Dietrich},
title = {Long-Short Range Context Neural Networks for Language Modeling},
booktitle = {{EMNLP} 2016, Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing},
day = {3},
month = {November},
year = {2016},
address = {Austin, Texas},
publisher = {Association for Computational Linguistics},
pages = {1473--1481},
url = {http://aclweb.org/anthology/D16-1154.pdf},
poster = {http://coli.uni-saarland.de/~claytong/posters/EMNLP16_Poster.pdf}
}
ou
@inproceedings{oualil-greenberg-singh-klakow:2016:IS,
author = {Youssef Oualil and Clayton Greenberg and Mittul Singh and Dietrich Klakow},
title = {Sequential Recurrent Neural Networks for Language Modeling},
day = {12},
month = {September},
year = 2016,
address = {San Francisco, California, USA},
booktitle = {{INTERSPEECH} 2016, Proceedings of the 17th Annual Conference of the International Speech Communication Association},
doi = {10.21437/Interspeech.2016-422},
url = {http://www.isca-speech.org/archive/Interspeech_2016/pdfs/0422.PDF},
pages = {3509--3513},
publisher = {{ISCA}}
}
