Gerando traduções a partir do modelo

Machine Translation with Keras

Thushan Ganegedara

Data Scientist and Author

Modelo anterior vs novo modelo

Repetição de vetor no codificador-decodificador

Codificador-decodificador: qual entrada

Modelo treinado

Modelo treinado com Teacher Forcing

Decodificador do modelo de inferência

Recebe
- Uma palavra one-hot
- Um estado de entrada (do passo de tempo anterior)
Produz
- Um novo estado
- Uma predição (ou seja, uma palavra)
Realimenta recursivamente a palavra prevista e o estado como entradas do modelo

Modelo completo de inferência

Modelo de inferência com decodificador recursivo

Codificador com decodificador recursivo

Modelo de inferência do capítulo anterior

Valor dos tokens sos e eos

sos marca o início da tradução (ex.: uma frase em francês).
- Alimente sos como primeira palavra do decodificador e continue prevendo
eos marca o fim da tradução.
- As predições param quando a palavra prevista for eos
Por segurança, defina um comprimento máximo para a predição

Definindo o codificador gerador

Importando camadas e Model

# Import Keras layers
import tensorflow.keras.layers as layers
from tensorflow.keras.models import Model

Definindo as camadas do modelo

en_inputs = layers.Input(shape=(en_len,en_vocab))
en_gru = layers.GRU(hsize, return_state=True)
en_out, en_state = en_gru(en_inputs)

Definindo o objeto Model

encoder = Model(inputs=en_inputs, outputs=en_state)

Definindo o decodificador gerador

Definindo as camadas Input do decodificador

de_inputs = layers.Input(shape=(1, fr_vocab))
de_state_in = layers.Input(shape=(hsize,))

Definindo as layers intermediárias do decodificador

de_gru = layers.GRU(hsize, return_state=True)
de_out, de_state_out = de_gru(de_inputs, initial_state=de_state_in)

de_dense = layers.Dense(fr_vocab, activation='softmax')
de_pred = de_dense(de_out)

Definindo o Model do decodificador

decoder = Model(inputs=[de_inputs, de_state_in], outputs=[de_pred, de_state_out])

Copiando os pesos

Obter os pesos da camada l1
- w = l1.get_weights()
Definir os pesos da camada l2 com w
- l2.set_weights(w)
No nosso modelo, há três camadas com pesos
- Codificador GRU, Decodificador GRU e Decodificador Dense

en_gru_w = tr_en_gru.get_weights()
en_gru.set_weights(en_gru_w)

Também pode ser escrito assim,

en_gru.set_weights(tr_en_gru.get_weights())

Gerando traduções

en_sent = ['the united states is sometimes chilly during 
           december , but it is sometimes freezing in june .']

Convertendo a frase em inglês para sequência

en_seq = sents2seqs('source', en_st, onehot=True, reverse=True)

Obtendo o vetor de contexto

de_s_t = encoder.predict(en_seq)

Convertendo "sos" (palavra inicial do decodificador) em sequência

de_seq = word2onehot(fr_tok, 'sos', fr_vocab)

Gerando traduções

fr_sent = ''

for _ in range(fr_len):      
  de_prob, de_s_t = decoder.predict([de_seq,de_s_t])

  de_w = probs2word(de_prob, fr_tok)

  de_seq = word2onehot(fr_tok, de_w, fr_vocab)

  if de_w == 'eos': break
  fr_sent += de_w + ' '

Hora de traduzir!

Machine Translation with Keras