Vertalingen uit het model genereren

Machine Translation met Keras

Thushan Ganegedara

Data Scientist and Author

Oud model vs. nieuw model

Encoder-decoder herhaalvector

Encoder-decoder welke input

Getraind model

Model getraind met Teacher Forcing

Decoder van het inferentiemodel

Neemt als input
- Een onehot-gecodeerd woord
- Een toestandinput (krijgt de toestand van de vorige timestep)
Produceert
- Een nieuwe toestand
- Een voorspelling (een woord)
Voer het voorspelde woord en de toestand recursief terug als inputs

Volledig inferentiemodel

Inferentiemodel met de recursieve decoder

Encoder recursieve decoder

Inferentiemodel uit het vorige hoofdstuk

Nut van sos- en eos-tokens

sos markeert het begin van een vertaling (bijv. een Franse zin).
- Geef sos als eerste woord aan de decoder en blijf voorspellen
eos markeert het einde van een vertaling.
- Voorspellingen stoppen wanneer het model eos voorspelt
Gebruik als veiligheidsmaatregel een maximale uitvoerlengte voor het model

De generator-encoder definiëren

Lagen en Model importeren

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

Modellagen definiëren

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)

Model-object definiëren

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

De generator-decoder definiëren

Decoder-Input-lagen definiëren

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

Tussentijdse layers van de decoder definiëren

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)

Decoder-Model definiëren

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

Gewichten kopiëren

Haal de gewichten op van laag l1
- w = l1.get_weights()
Stel de gewichten van laag l2 in met w
- l2.set_weights(w)
In ons model hebben drie lagen gewichten
- Encoder GRU, Decoder GRU en Decoder Dense

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

Dit kan ook zo:

en_gru.set_weights(tr_en_gru.get_weights())

Vertalingen genereren

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

De Engelse zin omzetten naar een sequentie

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

De contextvector ophalen

de_s_t = encoder.predict(en_seq)

"sos" (eerste woord voor de decoder) omzetten naar een sequentie

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

Vertalingen genereren

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

Tijd om te vertalen!

Machine Translation met Keras