Neural Machine Translation

Réseaux de neurones récurrents (RNN) pour la modélisation du langage avec Keras

David Cecchini

Data Scientist

Encodeurs et décodeurs

Architecture de Neural Machine Translation. Cette architecture se divise en un encodeur pour la langue d'entrée et un décodeur pour la langue de sortie. L'encodeur apprend un modèle de langue pour l'entrée et le décodeur pour la sortie. L'état final de l'encodeur est transmis au décodeur, qui n'a pas d'autre entrée.

Exemple d'encodeur

# Instantiate the model
model = Sequential()

# Embeding layer for input language
model.add(Embedding(input_language_size, input_wordvec_dim, 
                    input_length=input_language_len, mask_zero=True))

# Add LSTM layer
model.add(LSTM(128))

# Repeat the last vector
model.add(RepeatVector(output_language_len))

Exemple de décodeur

# Right after the encoder
model.add(LSTM(128, return_sequences=True))

# Add Time Distributed
model.add(TimeDistributed(Dense(eng_vocab_size, activation='softmax')))

Préparation des données

Préparation de texte pour l'encodeur et le décodeur. Côté encodeur, on transforme la langue d'entrée en une séquence d'index numériques ; côté décodeur, on fait de même pour la langue de sortie et on effectue aussi un codage one‑hot de chaque index.

Préparer la langue d'entrée

# Import modules
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Use the Tokenizer class
tokenizer = Tokenizer()
tokenizer.fit_on_texts(input_texts_list)

# Text to sequence of numerical indexes
X = tokenizer.texts_to_sequences(input_texts_list)

# Pad sequences
X = pad_sequences(X, maxlen=length, padding='post')

Tokeniser la langue de sortie

# Use the Tokenizer class
tokenizer = Tokenizer()
tokenizer.fit_on_texts(output_texts_list)

# Text to sequence of numerical indexes
Y = tokenizer.texts_to_sequences(output_texts_list)

# Pad sequences
Y = pad_sequences(Y, maxlen=length, padding='post')

Coder en one‑hot la langue de sortie

# Instantiate a temporary variable
ylist = list()

# Loop over the sequence of numerical indexes
for sequence in Y:

    # One=hot encode each index on current sentence
    encoded = to_categorical(sequence, num_classes=vocab_size)

    # Append one-hot encoded values to the list
    ylist.append(encoded)

# Transform to np.array and reshape
Y = np.array(ylist).reshape(Y.shape[0], Y.shape[1], vocab_size)

Remarque sur l'entraînement et l'évaluation

Entraîner le modèle :

model.fit(X, Y, epochs=N)

Évaluation :

Utiliser BLEU
- nltk.translate.bleu_score

Passons à la pratique !

Réseaux de neurones récurrents (RNN) pour la modélisation du langage avec Keras