[PYTHON] Pré-traitement pour construire un modèle seq2seq à l'aide de l'API fonctionnelle de Keras

Quel genre d'article?

Pour ceux qui veulent essayer ceci ou cela pour la modélisation du deep learning mais ne savent pas comment l'implémenter Utiliser l'API fonctionnelle de Keras comme un framework relativement flexible et raisonnablement abstrait Essayez d'implémenter seq2seq, ce qui est difficile avec séquentiel, aussi simplement que possible

table des matières

0. Présentation
1. Prétraitement (Imakoko)
2. Construction et apprentissage de modèles
3. Inférence
4. Amélioration du modèle (pas encore réalisée)

Motivation pour cet article

Il s'avère que les keras peuvent être utilisés pour mettre en œuvre un apprentissage en profondeur. Je comprends qu'il y a un prétraitement dans l'apprentissage en profondeur. Alors, comment puis-je convertir les données dans un format qui peut utiliser la fonction d'apprentissage en profondeur de keras? La réponse principale est que.

Ce dont vous avez besoin pour le prétraitement

Octroi de jetons de début / fin

Lorsque le modèle de traduction déduit le premier mot d'une phrase, il prend le jeton de début de mot virtuel \ comme entrée. De même, si le modèle de traduction estime que le mot suivant est le jeton de fin, donnez le jeton de fin \ afin que la phrase puisse se terminer là.

Numérisation des chaînes de mots

Pour entrer dans le modèle d'apprentissage automatique, il est nécessaire de quantifier les données de chaîne de caractères chargées d'une manière ou d'une autre. Le sac de mots et l'encodage à chaud de chaque mot sont des méthodes célèbres. Cette fois, je veux utiliser la couche d'intégration de keras au début du réseau, donc j'attribue un identifiant de mot au mot et le convertis en une colonne d'identifiant de mot.

Couche d'intégration https://keras.io/ja/layers/embeddings/

Unification de la longueur de la chaîne de mots

Si possible, unifiez la longueur de la chaîne de mots dans l'ensemble de données pour faciliter l'entrée dans le dernier LSTM. Cette fois, la longueur de la chaîne de mots est ajustée par remplissage pour correspondre à la longueur maximale de l'ensemble de données.

Traitement pour le forçage des enseignants

Il existe une technique de forçage par l'enseignant lors de l'apprentissage du modèle seq2seq. À l'origine, le décodeur utilise le résultat de l'estimation du mot précédent pour estimer le mot suivant. Puisque les données de réponse correcte peuvent être utilisées pendant l'apprentissage, le mot suivant est estimé en utilisant le mot de réponse correcte précédent au lieu du résultat de l'estimation précédente. Dans la figure, le flux est le suivant. Même si les inférences de «cela» et «ceci» et «stylo» et «crayon» sont incorrectes, l'entrée suivante sera corrigée en données de réponse correctes. Pour ce faire, préparez une chaîne de mots avec un seul mot décalé de la chaîne de mots cible comme entrée du décodeur.

Exemple Si la cible d'estimation est "Ceci est un stylo. \ " Préparez la chaîne de mots "\ Ceci est un stylo" comme entrée du décodeur

Résumé du flux de traitement

Le flux ci-dessus peut être résumé comme suit.

1. Ajoutez les mots spéciaux \ et \ au début et à la fin, respectivement, afin que le modèle puisse déterminer le début et la fin de la phrase.
2. Définissez une règle de conversion qui convertit un mot en un ID ayant une correspondance biunivoque avec le mot et convertissez la chaîne de mots en une chaîne d'ID de mot.
3. Faites correspondre la longueur de la chaîne de mots à la longueur maximale de l'ensemble de données avec un remplissage nul.
4. Puisque l'entrée du décodeur utilise une technique d'apprentissage appelée forçage de l'enseignant, la position est décalée par rapport aux données de réponse correctes de la sortie du décodeur.

Lorsque le traitement ci-dessus est effectué, par exemple, une conversion comme celle-ci sera effectuée. Chaîne de mots de l'ensemble de données <start> i can 't tell who will arrive first . <end> ↓ Colonne d'ID de mot \ [2, 6, 42, 20, 151, 137, 30, 727, 234, 4, 3, 0, 0, 0, 0, 0, 0, 0](18 éléments)

Implémentation de prétraitement

Octroi de jetons de début / fin

Définissez les deux fonctions suivantes, lisez les données de l'ensemble de données pour chaque ligne et attribuez des jetons de début / fin.

def preprocess_sentence(w):
    w = w.rstrip().strip()

    #Ajouter des jetons de début et de fin d'instruction
    #Pour indiquer au modèle quand démarrer et terminer la prédiction
    w = '<start> ' + w + ' <end>'
    return w

def create_dataset(path, num_examples):
    with open(path) as f:
        word_pairs = f.readlines()
    word_pairs = [preprocess_sentence(sentence) for sentence in word_pairs]

    return word_pairs[:num_examples]

Bien qu'il soit appelé preprocess_sentence, il ne donne que des jetons de début / fin, ce qui n'est pas un très bon nom pour une fonction. La variable dans create_dataset est word_pairs car l'exemple de code de TensorFlow auquel j'ai fait référence est toujours là. Ce n'est pas du tout des paires, il renvoie des chaînes de mots num_examples avec des jetons de début / fin.

Définir la règle de conversion en ID de mot

Convertir en une colonne d'identifiants de mots

Ici, le keras.preprocessing.text.Tokenizer de keras est très pratique et vous pouvez faire une pause.

def tokenize(lang):
    lang_tokenizer = keras.preprocessing.text.Tokenizer(filters='', oov_token='<unk>')
    lang_tokenizer.fit_on_texts(lang)

    tensor = lang_tokenizer.texts_to_sequences(lang)

    tensor = keras.preprocessing.sequence.pad_sequences(tensor, padding='post')

    return tensor, lang_tokenizer

Déterminez la règle de conversion entre les mots et les identifiants de mot à partir de la liste des chaînes de mots saisies par la méthode fit_on_texts. Vous pouvez utiliser la méthode text_to_sequences pour convertir la liste des chaînes de mots saisies en une liste de chaînes d'ID de mots. 0 le remplissage est également effectué avec keras.preprocessing.sequence.pad_sequences.

Traitement pour le forçage des enseignants

Chaîne d'ID de mot d'entrée obtenue en traitant ʻinput_tensorpar la méthode décrite ci-dessus. Traiteztarget_tensor` comme la chaîne d'ID de mot correcte traitée par la méthode ci-dessus comme suit.

encoder_input_tensor = input_tensor
decoder_input_tensor = target_tensor[:,:-1]
decoder_target_tensor = target_tensor[:,1:] #Cela réalise que l'enseignant force

Vous disposez maintenant des données à utiliser dans le modèle seq2seq. Nous ferons de la modélisation et de l'apprentissage dans le prochain article.

référence

La partie prétraitement est la suivante Traduction automatique neuronale avec attention https://www.tensorflow.org/tutorials/text/nmt_with_attention

La base de code pour la partie apprentissage / inférence est la suivante Sequence to sequence example in Keras (character-level). https://keras.io/examples/lstm_seq2seq/

Les données utilisées pour l'apprentissage sont les suivantes https://github.com/odashi/small_parallel_enja

Le référentiel contenant le code de cet article https://github.com/nagiton/simple_NMT