download word language model - download do código fonte word language model

word language model

Código-Fonte de IA

1.0.0

Baixar

Modelagem de idiomas no nível da palavra rnn

Este exemplo treina um RNN de várias camadas (Elman, GRU ou LSTM) em uma tarefa de modelagem de idiomas. Por padrão, o script de treinamento usa o conjunto de dados PTB, fornecido. O modelo treinado pode ser usado pelo script gerar para gerar novo texto. Esta é uma porção de pytorch/exemplos/word_language_model, tornando -o usável no Floydhub.

Uso

O script main.py aceita os seguintes argumentos:

optional arguments:
  -h, --help         show this help message and exit
  --data DATA        location of the data corpus
  --model MODEL      type of recurrent net (RNN_TANH, RNN_RELU, LSTM, GRU)
  --emsize EMSIZE    size of word embeddings
  --nhid NHID        number of hidden units per layer
  --nlayers NLAYERS  number of layers
  --lr LR            initial learning rate
  --clip CLIP        gradient clipping
  --epochs EPOCHS    upper epoch limit
  --batch-size N     batch size
  --bptt BPTT        sequence length
  --dropout DROPOUT  dropout applied to layers (0 = no dropout)
  --decay DECAY      learning rate decay per epoch
  --tied             tie the word embedding and softmax weights
  --seed SEED        random seed
  --cuda             use CUDA
  --log-interval N   report interval
  --save SAVE        path to save the final model

Com esses argumentos, uma variedade de modelos pode ser testada. Como exemplo, os argumentos a seguir produzem modelos mais lentos, mas melhores:

python main.py --cuda --emsize 650 --nhid 650 --dropout 0.5 --epochs 40           # Test perplexity of 80.97
python main.py --cuda --emsize 650 --nhid 650 --dropout 0.5 --epochs 40 --tied    # Test perplexity of 75.96
python main.py --cuda --emsize 1500 --nhid 1500 --dropout 0.65 --epochs 40        # Test perplexity of 77.42
python main.py --cuda --emsize 1500 --nhid 1500 --dropout 0.65 --epochs 40 --tied # Test perplexity of 72.30

Essas perplexidades são iguais ou melhores que a regularização da rede neural recorrente (Zaremba et al. 2014) e são semelhantes ao uso da saída de saída para melhorar os modelos de linguagem (Press & Wolf 2016 e vincular vetores de palavras e classificadores de palavras: uma estrutura de perda para modelagem de idiomas (Inan et al. 2016), embora ambos os papéis tenham uma impressão de que as periferia.

Arquitetura

Breve.

Corra no Floydhub

Aqui estão os comandos para o treinamento, avaliando e servindo sua tarefa de modelagem de idiomas no Floydhub.

Configuração do projeto

Antes de começar, faça login no Floydhub com o comando Floyd Login, depois bifurque e iniciá o projeto:

$ git clone https://github.com/floydhub/word-language-model.git
$ cd word-language-model
$ floyd init word-language-model

Treinamento

Antes de começar, você precisa fazer upload do conjunto de dados Penn Treebank-3 como um conjunto de dados Floydhub seguindo este guia: Crie e envie um conjunto de dados. Então você estará pronto para brincar com diferentes modelos de idiomas.

 # Train a LSTM on PTB with CUDA, reaching perplexity of 114.22
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input " python main.py --cuda --epochs 7 "

# Train a tied LSTM on PTB with CUDA, reaching perplexity of 110.44
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input " python main.py --cuda --epochs 7 --tied "

# Train a tied LSTM on PTB with CUDA for 40 epochs, reaching perplexity of 87.17
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input " python main.py --cuda --tied "

Observação:

--gpu Execute seu trabalho em uma instância do Floydhub GPU.
--env pytorch-0.2 Prepara um ambiente de pytorch para Python 3.
--data <USERNAME>/dataset/<PENN-TB3>/<VERSION>:input monta o conjunto de dados Penn Treebank-3 do Previus na pasta /input dentro do contêiner para o nosso trabalho.

O modelo usa o módulo nn.RNN (e seus módulos irmãos nn.GRU e nn.LSTM ) que usarão automaticamente o back -end do CUDNN se executados no CUDA com o CUDNN instalado.

Durante o treinamento, se uma interrupção do teclado (CTRL-C) for recebida, o treinamento será interrompido e o modelo atual será avaliado no conjunto de dados de teste.

Você pode seguir o progresso usando o comando logs. Os 2 primeiros exemplos de treinamento devem ser concluídos em cerca de 5 minutos em uma instância da GPU e 40 'em uma CPU. O último exemplo deve levar cerca de 30 'em uma instância da GPU e acima de 3 horas em um Instace da CPU.

Avaliação

É hora de avaliar nosso modelo gerando algum texto:

 # Generate samples from the trained LSTM model.
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input --data < REPLACE_WITH_JOB_OUTPUT_NAME > :model " python generate.py --cuda "

Experimente nosso modelo pré-treinado

Fornecemos a você um modelo pré-treinado treinado para 40 épocas que atingem a perplexidade de 87.17:

 # Generate samples from the trained LSTM model.
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input --data < REPLACE_WITH_JOB_OUTPUT_NAME > :model " python generate.py --cuda "

Servir o modelo através da API REST

O Floydhub suporta o modo de seving para demonstração e fins de teste. Antes de servir seu modelo através da API REST, você precisa criar um floyd_requirements.txt e declarar o requisito de frasco. Se você executar um emprego com --mode serve Flag, o Floydhub executará o arquivo app.py em seu projeto e o anexará a um terminal de serviço dinâmico:

floyd run --gpu --mode serve --env pytorch-0.2  --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input --data < REPLACE_WITH_JOB_OUTPUT_NAME > :model

O comando acima imprimirá um terminal de serviço para este trabalho no seu console de terminal.

O endpoint de serviço levará alguns minutos para se preparar. Depois de terminar, você pode interagir com o modelo enviando uma solicitação de postagem com o número de palavras e a temperatura que o modelo usará para gerar texto:

 # Template
# curl -X POST -o <NAME_&_PATH_DOWNLOADED_GENERATED_TEXT> -F "words=<NUMBER_OF_WORDS_TO_GENERATE>" -F "temperature=<TEMPERATURE>" <SERVICE_ENDPOINT>

curl -X POST -o generated.txt -F " words=100 " -F " temperature=3 " https://www.floydlabs.com/expose/vk47ixT8NeYBTFeMavbWta

Qualquer trabalho em execução no modo de servir permanecerá até chegar ao máximo tempo de execução. Então, depois de terminar de testar, lembre -se de desligar o trabalho!

Observe que esse recurso está no modo de visualização e ainda não está pronto para a produção