O modelo codificador-decodificador fornece um padrão para o uso de redes neurais recorrentes para resolver problemas desafiadores de predição de sequência a sequência, como tradução automática.
Modelos codificadores-decodificadores podem ser desenvolvidos na biblioteca de aprendizado profundo Keras Python e um exemplo de sistema de tradução automática neural desenvolvido com este modelo foi descrito no blog Keras, com código de amostra distribuído com o projeto Keras.
Este exemplo pode fornecer a base para o desenvolvimento de modelos LSTM de codificador-decodificador para seus próprios problemas de predição de sequência para sequência.
Neste tutorial, você descobrirá como desenvolver uma rede neural recorrente de codificador-decodificador sofisticada para problemas de predição de sequência a sequência com Keras.
Depois de concluir este tutorial, você saberá:
- Como definir corretamente um modelo sofisticado de codificador-decodificador no Keras para previsão de sequência a sequência.
- Como definir um problema de predição sequência a sequência planejado, mas escalonável, que pode ser usado para avaliar o modelo LSTM de codificador-decodificador.
- Como aplicar o modelo LSTM de codificador-decodificador em Keras para resolver o problema de predição de sequência a sequência de inteiro escalável.
Comece seu projeto com meu novo livro Long Short-Term Memory Networks With Python, incluindo tutoriais passo a passo e a Código-fonte Python arquivos para todos os exemplos.
Vamos começar.
- Atualização janeiro / 2020: API atualizada para Keras 2.3 e TensorFlow 2.0.
Como desenvolver um modelo codificador-decodificador para predição sequência a sequência em Keras
Foto de Björn Groß, alguns direitos reservados.
Visão geral do tutorial
Este tutorial é dividido em 3 partes; eles estão:
- Modelo codificador-decodificador em Keras
- Problema escalonável de sequência a sequência
- Codificador-decodificador LSTM para predição de sequência
Ambiente Python
Este tutorial presume que você tenha um ambiente Python SciPy instalado. Você pode usar o Python 2 ou 3 com este tutorial.
Você deve ter o Keras (2.0 ou superior) instalado com o back-end TensorFlow ou Theano.
O tutorial também supõe que você tenha o scikit-learn, Pandas, NumPy e Matplotlib instalados.
Se precisar de ajuda com seu ambiente, veja esta postagem:
Modelo codificador-decodificador em Keras
O modelo codificador-decodificador é uma forma de organizar redes neurais recorrentes para problemas de predição sequência a sequência.
Ele foi originalmente desenvolvido para problemas de tradução automática, embora tenha se mostrado bem-sucedido em problemas relacionados de previsão de sequência a sequência, como resumo de texto e resposta a perguntas.
A abordagem envolve duas redes neurais recorrentes, uma para codificar a sequência de origem, chamada de codificador, e a segunda para decodificar a sequência de origem codificada na sequência de destino, chamada de decodificador.
A biblioteca Python de aprendizado profundo Keras fornece um exemplo de como implementar o modelo codificador-decodificador para tradução automática (lstm_seq2seq.py) descrito pelo criador das bibliotecas na postagem: “Uma introdução de dez minutos ao aprendizado de sequência a sequência em Keras . ”
Para uma análise detalhada deste modelo, consulte a postagem:
Para obter mais informações sobre o uso de return_state, o que pode ser novo para você, consulte a postagem:
Para obter mais ajuda para começar a usar a API Keras Functional, consulte a postagem:
Usando o código daquele exemplo como ponto de partida, podemos desenvolver uma função genérica para definir uma rede neural recorrente codificador-decodificador. Abaixo está esta função chamada define_models ().
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
# retorna os modelos train, inference_encoder e inference_decoder def define_models(n_input, n_output, n_units): # define codificador de treinamento encoder_inputs = Entrada(forma=(Nenhum, n_input)) codificador = LSTM(n_units, return_state=Verdade) encoder_outputs, estado_h, estado_c = codificador(encoder_inputs) encoder_states = [state_h, state_c] # define decodificador de treinamento decoder_inputs = Entrada(forma=(Nenhum, n_output)) decoder_lstm = LSTM(n_units, return_sequences=Verdade, return_state=Verdade) decoder_outputs, _, _ = decoder_lstm(decoder_inputs, Estado inicial=encoder_states) decoder_dense = Denso(n_output, ativação='softmax') decoder_outputs = decoder_dense(decoder_outputs) modelo = Modelo([encoder_inputs, decoder_inputs], decoder_outputs) # define codificador de inferência encoder_model = Modelo(encoder_inputs, encoder_states) # define decodificador de inferência decoder_state_input_h = Entrada(forma=(n_units,)) decoder_state_input_c = Entrada(forma=(n_units,)) decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c] decoder_outputs, estado_h, estado_c = decoder_lstm(decoder_inputs, Estado inicial=decoder_states_inputs) decoder_states = [state_h, state_c] decoder_outputs = decoder_dense(decoder_outputs) decoder_model = Modelo([decoder_inputs] + decoder_states_inputs, [decoder_outputs] + decoder_states) # devolver todos os modelos Retorna modelo, encoder_model, decoder_model |
A função leva 3 argumentos, da seguinte maneira:
- n_input: A cardinalidade da sequência de entrada, por exemplo, número de recursos, palavras ou caracteres para cada intervalo de tempo.
- n_output: A cardinalidade da sequência de saída, por exemplo, número de recursos, palavras ou caracteres para cada intervalo de tempo.
- n_units: O número de células a serem criadas nos modelos de codificador e decodificador, por exemplo, 128 ou 256.
A função então cria e retorna 3 modelos, da seguinte maneira:
- Comboio: Modelo que pode ser treinado com base nas sequências de origem, destino e destino alterado.
- inference_encoder: Modelo de codificador usado ao fazer uma previsão para uma nova sequência de origem.
- inference_decoder Uso do modelo de decodificador ao fazer uma previsão para uma nova sequência de origem.
O modelo é treinado com base nas sequências de origem e destino, em que o modelo usa a origem e uma versão deslocada da sequência de destino como entrada e prevê toda a sequência de destino.
Por exemplo, uma sequência fonte pode ser [1,2,3] e a sequência alvo [4,5,6]. As entradas e saídas para o modelo durante o treinamento seriam:
Input1: ['1', '2', '3'] Input2: ['_', '4', '5'] Resultado: ['4', '5', '6'] |
O modelo deve ser chamado recursivamente ao gerar sequências de destino para novas sequências de origem.
A sequência de origem é codificada e a sequência de destino é gerada um elemento por vez, usando um caractere de “início de sequência” como '_' para iniciar o processo. Portanto, no caso acima, os seguintes pares de entrada-saída ocorreriam durante o treinamento:
t, Entrada1, Entrada2, Saída 1, ['1', '2', '3'], '_', '4' 2, ['1', '2', '3'], '4', '5' 3, ['1', '2', '3'], '5', '6' |
Aqui você pode ver como o uso recursivo do modelo pode ser usado para construir sequências de saída.
Durante a previsão, o inference_encoder modelo é usado para codificar a sequência de entrada uma vez que retorna estados que são usados para inicializar o inference_decoder modelo. A partir desse ponto, o inference_decoder modelo é usado para gerar previsões passo a passo.
A função abaixo nomeada Predict_sequence () pode ser usado após o modelo ser treinado para gerar uma sequência de destino dada uma sequência de origem.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
# gerar destino dada sequência de origem def predizer_sequência(Infenc, infdec, fonte, n_steps, cardinalidade): # codificar Estado = Infenc.prever(fonte) # início da sequência de entrada target_seq = variedade([0.0 for _ in range(cardinality)]).remodelar(1, 1, cardinalidade) # coletar previsões resultado = Lista() pra t no faixa(n_steps): # prever próximo caractere yhat, h, c = infdec.prever([target_seq] + Estado) # previsão da loja resultado.acrescentar(yhat[0,0,:]) # estado de atualização Estado = [h, c] # atualizar sequência de destino target_seq = yhat Retorna variedade(resultado) |
Esta função leva 5 argumentos da seguinte maneira:
- Infenc: Modelo de codificador usado ao fazer uma previsão para uma nova sequência de origem.
- infdec: Uso do modelo do decodificador ao fazer uma previsão para uma nova sequência de origem.
- fonte: Sequência de origem codificada.
- n_steps: Número de intervalos de tempo na sequência de destino.
- cardinalidade: A cardinalidade da sequência de saída, por exemplo, o número de recursos, palavras ou caracteres para cada intervalo de tempo.
A função então retorna uma lista contendo a sequência de destino.
Problema escalonável de sequência a sequência
Nesta seção, definimos um problema de predição sequência a sequência planejado e escalonável.
A sequência de origem é uma série de valores inteiros gerados aleatoriamente, como [20, 36, 40, 10, 34, 28], e a sequência alvo é um subconjunto pré-definido reverso da sequência de entrada, como os 3 primeiros elementos na ordem reversa [40, 36, 20].
O comprimento da sequência de origem é configurável; o mesmo ocorre com a cardinalidade da sequência de entrada e saída e o comprimento da sequência de destino.
Usaremos sequências de origem de 6 elementos, cardinalidade de 50 e sequências de destino de 3 elementos.
Abaixo estão mais alguns exemplos para tornar isso concreto.
Fonte, Alvo [13, 28, 18, 7, 9, 5] [18, 28, 13] [29, 44, 38, 15, 26, 22] [38, 44, 29] [27, 40, 31, 29, 32, 1] [31, 40, 27] ... |
Você é encorajado a explorar variações maiores e mais complexas. Publique suas descobertas nos comentários abaixo.
Vamos começar definindo uma função para gerar uma sequência de inteiros aleatórios.
Usaremos o valor 0 como preenchimento ou início do caractere de sequência, portanto, é ...
