[PYTHON] Prétraitement japonais pour l'apprentissage automatique

introduction

Un mémorandum lors de la création d'un simple réseau de neurones utilisant du texte comme données d'entraînement afin de comprendre le mécanisme des chatbots utilisant l'apprentissage automatique.

Objectif

Appliquez un chatbot basé sur des règles créé en texte anglais au texte japonais pour le faire fonctionner. Prétraitez le texte japonais et assurez-vous qu'il peut passer par un réseau neuronal. En tant que données de formation, nous avons utilisé une page de support Web sur "Pokemon GO" de Niantic.

Page d'assistance Niantic

Fichier CSV utilisé (GitHub)

Classification multi-classes

En référence au «type basé sur des règles» qui renvoie le texte de réponse préparé à l'avance en fonction de l'entrée, même la partie de la classification multi-classe qui identifie et prédit les «intentions» (intention) a été formée.

Puisqu'il n'est pas "généré" mais prédit des "Foire Aux Questions (FAQ)" associées à partir des informations d'entrée, le modèle est créé avec une couche de réseau neuronal normal au lieu de "RNN".

environnement

Créez un environnement virtuel sans utiliser le notebook Jupyter. − macOS Mojave 10.14.6

• Python 3.6.0
• TensorFlow 1.9.0 --MeCab (outil d'analyse morphologique japonais)

Page de référence d'installation de MeCab

code

Lecture des données d'entraînement et prétraitement du texte japonais

wakatigaki.py

import MeCab
import csv
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.sequence import pad_sequences

def create_tokenizer() :
#Lire le fichier CSV
    text_list = []
    with open("pgo_train_texts.csv", "r") as csvfile :
        texts = csv.reader(csvfile)

        for text in texts :
            text_list.append(text)

#Utilisez MeCab pour écrire du texte japonais séparément.
        wakati_list = []
        label_list = []
        for label, text in text_list :
            text = text.lower()

            wakati = MeCab.Tagger("-O wakati")
            text_wakati = wakati.parse(text).strip()
            wakati_list.append(text_wakati)
            label_list.append(label)

#Découvrez le nombre d'éléments dans la plus grande phrase.
#Créez une liste de données texte à utiliser dans le tokenizer.
        max_len = -1
        split_list = []
        sentences = []
        for text in wakati_list :
            text = text.split()
            split_list.extend(text)
            sentences.append(text)

            if len(text) > max_len :
                max_len = len(text)
        print("Max length of texts: ", max_len)
        vocab_size = len(set(split_list))
        print("Vocabularay size: ", vocab_size)
        label_size = len(set(label_list))

#Utilisez Tokenizer pour attribuer des nombres de l'index 1 aux mots.
#Créez également un dictionnaire.
        tokenizer = tf.keras.preprocessing.text.Tokenizer(oov_token="<oov>")
        tokenizer.fit_on_texts(split_list)
        word_index = tokenizer.word_index
        print("Dictionary size: ", len(word_index))
        sequences = tokenizer.texts_to_sequences(sentences)

#Les données d'étiquette utilisées pour l'apprentissage supervisé sont également numérotées à l'aide de Tokenizer.
        label_tokenizer = tf.keras.preprocessing.text.Tokenizer()
        label_tokenizer.fit_on_texts(label_list)
        label_index = label_tokenizer.word_index
        label_sequences = label_tokenizer.texts_to_sequences(label_list)

#Tokenizer attribue des nombres à partir de 1, tandis que l'étiquette réelle commence à indexer à partir de 0, donc c'est -1.
        label_seq = []
        for label in label_sequences :
            l = label[0] - 1
            label_seq.append(l)

# to_categorical()Les données d'étiquette réelles sont-elles transmises au modèle à l'aide de One-Créez un vecteur chaud.
        one_hot_y = tf.keras.utils.to_categorical(label_seq)

#Pour uniformiser la taille des données d'entraînement, ajoutez 0 au texte court pour qu'il corresponde aux données de texte les plus longues.
        padded = pad_sequences(sequences, maxlen=max_len, padding="post", truncating="post")
        print("padded sequences: ", padded)

        reverse_index = dict()
        for intent, i in label_index.items() :
            reverse_index[i] = intent

    return padded, one_hot_y, word_index, reverse_index, tokenizer, max_len, vocab_size

Création de modèle à l'aide de TensorFlow

model.py

import tensorflow as tf

def model(training, label, vocab_size) :
    model = tf.keras.models.Sequential([
        tf.keras.layers.Embedding(input_dim=vocab_size, output_dim=16, input_length=len(training[0])),
        tf.keras.layers.Flatten(),
        tf.keras.layers.Dense(30, activation="relu"),
        tf.keras.layers.Dense(len(label[0]), activation="softmax")
    ])

    model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
    model.fit(x=training, y=label, epochs=100)

    model.summary()

    return model

• Premièrement, utilisez le calque Incorporation afin de pouvoir capturer les relations entre les mots sous forme de vecteur. --Aplatissez la matrice d'incorporation afin qu'elle puisse être transmise à la couche Dense entièrement connectée avec Flatten () entre les deux. --Si AveragePooling1D () est utilisé à la place, le nombre de paramètres du réseau neuronal peut être réduit et le coût de calcul peut être réduit.
• Puisque le nombre de "Intentions" que vous souhaitez identifier est le même que le type d'étiquette, faites-le correspondre avec le nombre d'éléments à l'index 0 du vecteur One-Hot. --Sélectionnez "softmax" pour la fonction d'activation de la couche de sortie, qui correspond à la classification multi-classes.
• Lors de la compilation du modèle, définissez la méthode de calcul des pertes pour la classification multi-classes. --Utilisez "Adam" comme algorithme d'apprentissage.

Créer un écran de saisie

chat.py

import MeCab
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.sequence import pad_sequences

#Organisez le texte reçu par la console pour que le modèle puisse le traiter.
def prepro_wakati(input, tokenizer, max_len) :
    sentence = []

    input = input.lower()
    wakati = MeCab.Tagger("-O wakati")
    text_wakati = wakati.parse(input).strip()
    sentence.append(text_wakati)
    print(sentence)

    seq = tokenizer.texts_to_sequences(sentence)
    seq = list(seq)
    padded = pad_sequences(seq, maxlen=max_len, padding="post", truncating="post")
    print(padded)

    return padded

def chat(model, tokenizer, label_index, max_len) :
    print("Start talking with the bot (type quit to stop): ")
    while True :
        input_text = input("You: ")
        if input_text.lower() == "quit" :
            break

        x = prepro_wakati(input_text, tokenizer, max_len)
        results = model.predict(x, batch_size=1)
        print("results: ", results)
        results_index = np.argmax(results)
        print("Predicted index: ", results_index)

        intent = label_index[results_index + 1]

        print("Type of intent: ", intent)

Écran de la console. Appliquez le texte saisi au modèle entraîné et prédisez à laquelle des neuf «intentions» il s'applique.

--Types d'intentions

• Nous contacter --Punaise
• Guide de démarrage --Accessoires
• bataille --Un événement
• Partenaire
• Sécurité --Boutique

Courir

Appelez et exécutez la fonction définie.

ex.py

import wakatigaki
import model
import chat

padded, one_hot_y, word_index, label_index, tokenizer, max_len, vocab_size = wakatigaki.create_tokenizer()

model = model.model(padded, one_hot_y, vocab_size)

chat.chat(model, tokenizer, label_index, max_len)

Résultats de la formation

Les nombres dans "résultats:" représentent les probabilités correspondantes pour chaque catégorie.

Prédisez un "guide de démarrage" pour l'entrée "comment attraper Pokemon". Ensuite, prédisez «acheter» pour «piquer des pièces et des objets». Les deux ont pu prédire la catégorie appropriée.