Générer des traductions à partir du modèle

Traduction automatique avec Keras

Thushan Ganegedara

Data Scientist and Author

Ancien modèle vs nouveau modèle

Encodeur-décodeur avec vecteur de répétition

Encodeur-décodeur : quelle entrée

Modèle entraîné

Modèle entraîné avec Teacher Forcing

Décodeur du modèle d'inférence

Reçoit
- Un mot en codage one-hot
- Un état d'entrée (provenant de l'étape précédente)
Produit
- Un nouvel état
- Une prédiction (p. ex. un mot)
Rétroalimentez récursivement le mot prédit et l'état dans le modèle comme entrées

Modèle d'inférence complet

Modèle d'inférence avec décodeur récursif

Encodeur et décodeur récursif

Modèle d'inférence du chapitre précédent

Valeur des jetons sos et eos

sos marque le début d'une traduction (p. ex. une phrase en français).
- Donnez sos comme premier mot au décodeur et poursuivez les prédictions
eos marque la fin d'une traduction.
- Les prédictions s'arrêtent quand le mot prédit par le modèle est eos
Par sécurité, fixez une longueur maximale que le modèle peut prédire

Définir l'encodeur générateur

Importer les couches et Model

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

Définir les couches du modèle

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)

Définir l'objet Model

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

Définir le décodeur générateur

Définir les couches Input du décodeur

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

Définir les layers intermédiaires du décodeur

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)

Définir le Model du décodeur

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

Copier les poids

Obtenir les poids de la couche l1
- w = l1.get_weights()
Affecter les poids w à la couche l2
- l2.set_weights(w)
Dans notre modèle, trois couches ont des poids
- Encodeur GRU, Décodeur GRU et Décodeur Dense

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

Ce qui peut aussi s'écrire :

en_gru.set_weights(tr_en_gru.get_weights())

Générer des traductions

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

Convertir la phrase anglaise en séquence

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

Obtenir le vecteur de contexte

de_s_t = encoder.predict(en_seq)

Convertir « sos » (premier mot du décodeur) en séquence

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

Générer des traductions

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

À vous de traduire !

Traduction automatique avec Keras