Generare traduzioni dal modello

Traduzione automatica con Keras

Thushan Ganegedara

Data Scientist and Author

Modello precedente vs nuovo modello

Encoder decoder con repeat vector

Encoder-decoder: quale input

Modello addestrato

Modello addestrato con Teacher Forcing

Decoder del modello di inferenza

Input
- Una parola one-hot
- Uno stato in input (dallo step precedente)
Output
- Un nuovo stato
- Una predizione (cioè una parola)
Re-inserisci ricorsivamente parola predetta e stato come input del modello

Modello di inferenza completo

Modello di inferenza con decoder ricorsivo

Encoder con decoder ricorsivo

Modello di inferenza del capitolo precedente

Valore dei token sos ed eos

sos indica l'inizio della traduzione (es. una frase in francese).
- Fornisci sos come prima parola al decoder e continua a predire
eos indica la fine della traduzione.
- Le predizioni si fermano quando il modello predice eos
Per sicurezza usa una lunghezza massima che il modello può predire

Definire l'encoder del generatore

Importare layers e Model

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

Definire i layer del modello

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)

Definire l'oggetto Model

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

Definire il decoder del generatore

Definire gli strati Input del decoder

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

Definire i layers intermedi del decoder

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)

Definire il Model del decoder

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

Copiare i pesi

Ottieni i pesi del layer l1
- w = l1.get_weights()
Imposta i pesi del layer l2 con w
- l2.set_weights(w)
Nel nostro modello ci sono tre layer con pesi
- Encoder GRU, Decoder GRU e Decoder Dense

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

Oppure,

en_gru.set_weights(tr_en_gru.get_weights())

Generare traduzioni

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

Convertire la frase inglese in una sequenza

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

Ottenere il vettore di contesto

de_s_t = encoder.predict(en_seq)

Convertire "sos" (parola iniziale per il decoder) in una sequenza

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

Generare traduzioni

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 + ' '

È il momento di tradurre!

Traduzione automatica con Keras