char rnn chinese
1.0.0
Baseado no código de Andrej Karpathy https://github.com/karpathy/char-rnn e o papel de Samy Bengo http://arxiv.org/abs/1506.03099
Faça o código pode processar caracteres em inglês e chinês. Este é o meu primeiro toque de lua, então o processo de string parece bobo, mas funciona bem.
Eu também adiciono uma opção chamada 'min_freq' porque o tamanho do vocabulário em chinês é muito grande, o que torna o número do parâmetro aumentar muito. Portanto, exclua algum caráter raro pode ajudar.
O artigo de Samy Bengio, amostragem programada para previsão de sequência, com redes neurais recorrentes no NIPS15, propõem um método simples, mas de potência, para implicar o RNN.
No meu experimento, acho que ajuda muito a evitar o excesso de ajuste e tornar a perda de teste mais profunda. Eu só uso decaimento linear.
Use -use_ss para ativar ou desativar a amostragem programada, o padrão está ligado. -start_ss é o início dos dados reais, sugiro usar 1 porque nosso modelo deve aprender dados sem ruído no início. -min_ss também é muito importante, pois muito ruído prejudicará o desempenho. Finalmente, -decay_ss é a taxa de decaimento linear.
Adicionei um script para converter um arquivo de modelo treinado pela GPU em modelo de CPU. Você pode tentar o seguinte:
$ th convert.lua gpu_model cpu_modelUma demonstração da web é adicionada para que outros testem o modelo facilmente, com base no sub/pub de redis. Eu uso o Redis porque não consigo encontrar um bom RPC ou servidor da web, bem integrado à tocha. Você deve notar que a demonstração é assíncroada pelo Ajax. Para configurar a demonstração no Ubuntu: instale o Redis e inicie -o
$ wget http://download.redis.io/releases/redis-3.0.3.tar.gz
$ tar xzf redis-3.0.3.tar.gz
$ cd redis-3.0.3
$ make
$ sudo make install
$ redis-server &Em seguida, instale o frasco e o plug -in Redis:
$ sudo pip install flask
$ sudo pip install redis
$ luarocks install redis-luaColoque seu arquivo modelado em online_model, renomeie -o como 'Model.t7', o script de back -end e fontend:
$ nohup th web_backend.lua &
$ nohup python web_server.py & Siga isso para configurar seu experimento.
Este código implementa a rede neural recorrente de várias camadas (RNN, LSTM e GRU) para treinamento/amostragem a partir de modelos de idiomas no nível do caractere. O modelo aprende a prever a probabilidade do próximo caractere em uma sequência. Em outras palavras, a entrada é um único arquivo de texto e o modelo aprende a gerar texto como esse.
O contexto desta base de código é descrito em detalhes na minha postagem no blog. A página do projeto que tem alguns ponteiros para alguns conjuntos de dados.
Este código foi originalmente baseado na aula de aprendizado de máquina da Universidade de Oxford Practical 6, que, por sua vez, baseia -se no aprendizado de executar o código da Wojciech Zaremba. Os pedaços disso também foram desenvolvidos em colaboração com meu colega de laboratório Justin Johnson.
Este código é escrito em Lua e requer tocha. Além disso, você precisa instalar os pacotes nngraph e optim usando Luarocks que você poderá fazer após a instalação da tocha:
$ luarocks install nngraph
$ luarocks install optim Se você quiser usar a computação da GPU da CUDA, primeiro precisará instalar o kit de ferramentas CUDA, depois os pacotes cutorch e cunn :
$ luarocks install cutorch
$ luarocks install cunn Se você quiser usar a computação da OpenCL GPU, primeiro precisará instalar os pacotes cltorch e clnn e depois usar a opção -opencl 1 durante o treinamento:
$ luarocks install cltorch
$ luarocks install clnn Todos os dados de entrada são armazenados dentro dos data/ diretórios. Você notará que existe um exemplo de conjunto de dados incluído no repo (na pasta data/tinyshakespeare ), que consiste em um subconjunto de obras de Shakespeare. Estou fornecendo mais alguns conjuntos de dados na página do projeto.
Seus próprios dados : se você quiser usar seus próprios dados, crie um único arquivo input.txt e coloque -os em uma pasta em data/ . Por exemplo, data/some_folder/input.txt . Na primeira vez em que você executa o script de treinamento, ele escreverá mais dois arquivos de conveniência em data/some_folder .
Observe que se seus dados forem muito pequenos (1MB já for considerado muito pequeno), o RNN não aprenderá de maneira muito eficaz. Lembre -se de que ele precisa aprender tudo completamente do zero.
Por outro lado, se seus dados forem grandes (mais de cerca de 2 MB), sinta -se confiante em aumentar rnn_size e treinar um modelo maior (consulte os detalhes do treinamento abaixo). Funcionará significativamente melhor . Por exemplo, com 6 MB, você pode facilmente subir para rnn_size 300 ou mais. O maior que se encaixa na minha GPU e que eu treinei com este código é rnn_size 700 com num_layers 3 (2 é padrão).
Comece a treinar o modelo usando train.lua , por exemplo:
$ th train.lua -data_dir data/some_folder -gpuid -1
O sinalizador -data_dir é mais importante, pois especifica o conjunto de dados a ser usado. Observe que, neste exemplo, também estamos definindo gpuid para -1, que informa ao código para treinar usando a CPU, caso contrário, o padrão é a GPU 0. Existem muitos outros sinalizadores para várias opções. Consulte $ th train.lua -help Aqui está outro exemplo:
$ th train.lua -data_dir data/some_folder -rnn_size 512 -num_layers 2 -dropout 0.5
Enquanto o modelo estiver treinando, ele gravará periodicamente os arquivos do ponto de verificação na pasta cv . A frequência com que esses pontos de verificação são gravados é controlada com o número de iterações, conforme especificado com a opção de eval_val_every (por exemplo, se for 1, então um ponto de verificação será gravado a cada iteração). O nome do arquivo desses pontos de verificação contém um número muito importante: a perda . Por exemplo, um ponto de verificação com o nome do arquivo lm_lstm_epoch0.95_2.0681.t7 indica que, nesse ponto, o modelo estava na época 0,95 (ou seja, quase fez um passe completo sobre os dados de treinamento) e a perda nos dados de validação foi de 2.0681. Esse número é muito importante porque, quanto menor, melhor o ponto de verificação funciona. Depois de começar a gerar dados (discutidos abaixo), convém usar o ponto de verificação do modelo que tem a menor perda de validação. Observe que este pode não ser necessariamente o último ponto de verificação no final do treinamento (devido ao possível ajuste excessivo).
Outras quantidades importantes a serem cientes são batch_size (ligue para B), seq_length (LIGUE S) e as configurações de train_frac e val_frac . O tamanho do lote especifica quantos fluxos de dados são processados em paralelo ao mesmo tempo. O comprimento da sequência especifica o comprimento de cada pedaço, que também é o limite no qual os gradientes são cortados. Por exemplo, se seq_length for 20, o sinal de gradiente nunca será de volta mais de 20 etapas de tempo, e o modelo pode não encontrar dependências mais longas do que esse comprimento no número de caracteres. Em tempo de execução, seu arquivo de texto de entrada possui n caracteres, todos eles são divididos em pedaços de tamanho BXS. Esses pedaços são alocados a três divisões: trem/val/teste de acordo com as configurações frac . Se seus dados forem pequenos, é possível que, com as configurações padrão, você terá apenas muito poucos pedaços no total (por exemplo 100). Isso é ruim: nesses casos, você pode diminuir o tamanho do lote ou o comprimento da sequência.
Você também pode iniciar parâmetros de um ponto de verificação salvo anteriormente usando init_from .
Podemos usar esses pontos de verificação para gerar texto (discutido a seguir).
Dado um arquivo de ponto de verificação (como os gravados no cv ), podemos gerar um novo texto. Por exemplo:
$ th sample.lua cv/some_checkpoint.t7 -gpuid -1
Certifique -se de que, se o seu ponto de verificação foi treinado com a GPU, ele também é amostrado com a GPU ou vice -versa. Caso contrário, o código (atualmente) se queixará. Como no script de trem, consulte $ th sample.lua -help para obter opções completas. Um importante é (por exemplo) -length 10000 , que geraria 10.000 caracteres (padrão = 2000).
Temperatura . Um parâmetro importante que você pode querer brincar com muito é -temperature , que leva um número no intervalo [0, 1] (aviso 0 não incluído), padrão = 1. A temperatura está dividindo as probabilidades de log previstas antes da max softmax; portanto, a temperatura mais baixa fará com que o modelo torne mais provável, mas também mais chatas e previsões conservadoras. Temperaturas mais altas fazem com que o modelo tenha mais chances e aumente a diversidade de resultados, mas a um custo de mais erros.
Priming . Também é possível preparar o modelo com algum texto inicial usando -primetext . Isso inicia o RNN com alguns caracteres codificados para aquecê -lo com algum contexto antes de começar a gerar texto.
Feliz amostragem!
Se você é um pouco novo nas redes de aprendizado de máquina ou neurais, pode ser necessário um pouco de experiência para obter bons modelos. A quantidade mais importante a ser acompanhada é a diferença entre sua perda de treinamento (impressa durante o treinamento) e a perda de validação (impressa de vez em quando quando o RNN é executado nos dados de validação (por padrão a cada 1000 iterações)). Em particular:
Os dois parâmetros mais importantes que controlam o modelo são rnn_size e num_layers . Eu recomendaria que você sempre use num_layers de 2/3. O rnn_size pode ser ajustado com base na quantidade de dados que você possui. As duas quantidades importantes para acompanhar aqui são:
Esses dois devem ser aproximadamente a mesma ordem de magnitude. É um pouco complicado dizer. Aqui estão alguns exemplos:
rnn_size .A estratégia vencedora para obter modelos muito bons (se você tiver o tempo de computação) é sempre errar ao aumentar a rede (tão grande quanto você estiver disposto a esperar para calcular) e, em seguida, experimentar diferentes valores de abandono (entre 0,1). Qualquer que seja o modelo que tenha o melhor desempenho de validação (a perda, escrita no nome do arquivo de controle, Low é bom) é o que você deve usar no final.
É muito comum no aprendizado profundo de executar muitos modelos diferentes com muitas configurações diferentes de hiperparâmetro e, no final, tomar qualquer ponto de verificação que tenha o melhor desempenho de validação.
A propósito, o tamanho de suas divisões de treinamento e validação também são parâmetros. Verifique se você tem uma quantidade decente de dados em seu conjunto de validação ou, de outra forma, o desempenho da validação será barulhento e não muito informativo.
Mit
