Modelos de sequência-sequência-parte 1

Bom dia a todos!

E novamente abrimos um novo fluxo para o curso Data Scientist revisado: outro excelente professor , um programa ligeiramente refinado com base em atualizações. Bem, como sempre, lições abertas interessantes e coleções de materiais interessantes. Hoje começaremos a análise dos modelos seq2seq do Tensor Flow.

Vamos lá

Como já discutido no tutorial da RNN (recomendamos que você se familiarize com ele antes de ler este artigo), redes neurais recorrentes podem ser ensinadas a modelar o idioma. E surge uma pergunta interessante: é possível treinar a rede em determinados dados para gerar uma resposta significativa? Por exemplo, podemos ensinar uma rede neural a traduzir do inglês para o francês? Acontece que nós podemos.

Este guia mostra como criar e treinar um sistema de ponta a ponta. Copie o repositório principal do Tensor Flow e o repositório do modelo TensorFlow do GitHub . Em seguida, você pode começar iniciando o programa de tradução:

cd models/tutorials/rnn/translate python translate.py --data_dir [your_data_directory] 

Ela fará o download dos dados para tradução do inglês para o francês no site do WMT'15 , preparará-os para treinamento e treinamento. Isso exigirá cerca de 20 GB no disco rígido e muito tempo para baixar e preparar, para que você possa iniciar o processo agora e continuar lendo este tutorial.

O manual acessará os seguintes arquivos:

Ficheiro	O que há nele?
tensorflow / tensorflow / python / ops / seq2seq.py	Biblioteca para criar modelos de sequência para sequência
modelos / tutoriais / rnn / translate / seq2seq_model.py	Modelos de tradução neural sequência a sequência
modelos / tutoriais / rnn / translate / data_utils.py	Funções auxiliares para preparar dados de tradução
modelos / tutoriais / rnn / translate / translate.py	O binário que treina e executa o modelo de conversão

Noções básicas de sequência a sequência

O modelo básico de sequência a sequência, conforme apresentado por Cho et al., 2014 ( pdf ), consiste em duas redes neurais recorrentes (RNNs): um codificador (codificador) que processa os dados de entrada e um decodificador (decodificador) que gera os dados saída. A arquitetura básica é mostrada abaixo:



Cada retângulo na figura acima representa uma célula no RNN, geralmente uma célula GRU - um bloco de recorrência controlado ou uma célula LSTM - memória de curto prazo de longo prazo (leia o tutorial do RNN para saber mais sobre eles). Codificadores e decodificadores podem ter pesos comuns ou, mais frequentemente, usar diferentes conjuntos de parâmetros. Células multicamadas foram usadas com sucesso em modelos de sequência a sequência, por exemplo, para traduzir Sutskever et al., 2014 ( pdf ).

No modelo básico descrito acima, cada entrada deve ser codificada em um vetor de estado de tamanho fixo, pois essa é a única coisa que é transmitida ao decodificador. Para dar ao decodificador acesso mais direto aos dados de entrada, um mecanismo de atenção foi introduzido em Bahdanau et al., 2014 ( pdf ). Não entraremos em detalhes do mecanismo de atenção (para isso você pode se familiarizar com o trabalho aqui); basta dizer que permite que o decodificador analise os dados de entrada em cada etapa de decodificação. Uma rede sequência a sequência multicamada com células LSTM e o mecanismo de atenção no decodificador são os seguintes:



Biblioteca TensorFlow seq2seq

Como você pode ver acima, existem diferentes modelos de sequência para sequência. Todos eles podem usar células RNN diferentes, mas todos aceitam dados de entrada do codificador e dados de entrada do decodificador. Essa é a base da interface da biblioteca TensorFlow seq2seq (tensorflow / tensorflow / python / ops / seq2seq.py). Esse modelo básico de RNN, codec, sequência a sequência funciona da seguinte maneira.

 outputs, states = basic_rnn_seq2seq(encoder_inputs, decoder_inputs, cell) 

Na chamada indicada acima, encoder_inputs é uma lista de tensores que representam os dados de entrada do codificador, correspondendo às letras A, B, C da figura acima. Da mesma forma, decoder_inputs são tensores que representam dados de entrada do decodificador. GO, W, X, Y, Z da primeira foto.

O argumento cell é uma instância da classe tf.contrib.rnn.RNNCell que determina qual célula será usada no modelo. Você pode usar células existentes, por exemplo, GRUCell ou LSTMCell , ou pode escrever suas próprias. Além disso, o tf.contrib.rnn fornece shells para criar células de tf.contrib.rnn camadas, adicionando exceções à entrada e saída de células ou outras transformações. Confira o Tutorial da RNN para obter exemplos.

A chamada basic_rnn_seq2seq retorna dois argumentos: outputs e states . Ambos representam uma lista de tensores do mesmo comprimento que decoder_inputs . outputs correspondem aos dados de saída do decodificador a cada passo, na primeira imagem são W, X, Y, Z, EOS. Os states retornados representam o estado interno do decodificador em cada etapa do tempo.

Em muitas aplicações que usam o modelo de sequência a sequência, a saída do decodificador no tempo t é retornada à entrada do decodificador no tempo t + 1. Durante o teste, durante a decodificação de sequência, é assim que uma nova é construída. Por outro lado, durante o treinamento, é habitual transmitir ao decodificador os dados de entrada corretos a cada passo, mesmo que o decodificador tenha sido previamente confundido. As funções no seq2seq.py suportam os dois modos com o argumento feed_previous . Por exemplo, considere o uso a seguir de um modelo RNN aninhado.

 outputs, states = embedding_rnn_seq2seq( encoder_inputs, decoder_inputs, cell, num_encoder_symbols, num_decoder_symbols, embedding_size, output_projection=None, feed_previous=False) 

No modelo embedding_rnn_seq2seq , todos os dados de entrada ( encoder_inputs e decoder_inputs ) são tensores inteiros que refletem valores discretos. Eles serão aninhados em uma representação restrita (para obter detalhes sobre o anexo, consulte o Vector Views Guide ), mas para criar esses anexos, é necessário especificar o número máximo de caracteres discretos: num_encoder_symbols no lado do codificador e num_decoder_symbols no lado do decodificador.

Na chamada acima, definimos feed_previous como False. Isso significa que o decodificador usará os tensores decoder_inputs na forma em que são fornecidos. Se feed_previous como True, o decodificador usará apenas o primeiro elemento decoder_inputs . Todos os outros tensores da lista serão ignorados e o valor anterior da saída do decodificador será usado. Isso é usado para decodificar traduções em nosso modelo de tradução, mas também pode ser usado durante o treinamento, para melhorar a estabilidade do modelo a seus erros. Aproximadamente como em Bengio et al., 2015 ( pdf ).

Outro argumento importante usado acima é output_projection . Sem esclarecimentos, as conclusões do modelo incorporado serão tensores da forma o número de amostras de treinamento por num_decoder_symbols , uma vez que representam os logotipos de cada símbolo gerado. Ao treinar modelos com dicionários de saída grandes, por exemplo, com num_decoder_symbols grande, o armazenamento desses tensores grandes se torna impraticável. Em vez disso, é melhor retornar tensores menores, que serão projetados posteriormente no tensor grande usando a output_projection . Isso nos permite usar nossos modelos seq2seq com perdas de softmax amostradas, conforme descrito por Jean et. al., 2014 ( pdf ).

Além de basic_rnn_seq2seq e embedding_rnn_seq2seq , existem vários modelos de sequência a sequência no seq2seq.py . Preste atenção neles. Todos eles têm uma interface semelhante, por isso não vamos nos aprofundar em seus detalhes. Para o nosso modelo de tradução abaixo, use embedding_attention_seq2seq .

Para ser continuado.