[PYTHON] Japanische Vorverarbeitung für maschinelles Lernen

Einführung

Ein Memorandum beim Erstellen eines einfachen neuronalen Netzwerks unter Verwendung von Text als Trainingsdaten, um den Mechanismus von Chatbots mithilfe von maschinellem Lernen zu verstehen.

Zweck

Wenden Sie einen regelbasierten Chatbot, der in englischem Text erstellt wurde, auf japanischen Text an, um ihn zu bedienen. Verarbeiten Sie japanischen Text vor und stellen Sie sicher, dass er über ein neuronales Netzwerk übertragen werden kann. Als Trainingsdaten verwendeten wir eine Web-Scraped-Support-Seite zu Niantics "Pokemon GO".

Niantic Support Page

Verwendete CSV-Datei (GitHub)

Klassifizierung mehrerer Klassen

In Bezug auf den "regelbasierten Typ", der den vorab gemäß der Eingabe vorbereiteten Antworttext zurückgibt, wurde sogar der Teil der Mehrklassenklassifikation gebildet, der "Absichten" (Absicht) identifiziert und vorhersagt.

Da es nicht "generiert" wird, sondern aus Eingabeinformationen verwandte "Häufig gestellte Fragen (FAQ)" vorhersagt, wird das Modell mit einer normalen neuronalen Netzwerkschicht anstelle von "RNN" erstellt.

Umgebung

Erstellen Sie eine virtuelle Umgebung ohne Jupyter-Notebook. − macOS Mojave 10.14.6

• Python 3.6.0
• TensorFlow 1.9.0 --MeCab (japanisches morphologisches Analysetool)

Referenzseite zur MeCab-Installation

Code

Trainingsdaten lesen und japanischen Text vorverarbeiten

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() :
#CSV-Datei lesen
    text_list = []
    with open("pgo_train_texts.csv", "r") as csvfile :
        texts = csv.reader(csvfile)

        for text in texts :
            text_list.append(text)

#Verwenden Sie MeCab, um japanischen Text separat zu schreiben.
        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)

#Finden Sie die Anzahl der Elemente im größten Satz heraus.
#Erstellen Sie eine Liste der Textdaten, die im Tokenizer verwendet werden sollen.
        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))

#Verwenden Sie Tokenizer, um Wörtern Zahlen aus Index 1 zuzuweisen.
#Erstellen Sie auch ein Wörterbuch.
        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)

#Die für das überwachte Lernen verwendeten Etikettendaten werden ebenfalls mit Tokenizer nummeriert.
        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 weist Zahlen ab 1 zu, während das eigentliche Label ab 0 indiziert, also -1.
        label_seq = []
        for label in label_sequences :
            l = label[0] - 1
            label_seq.append(l)

# to_categorical()Werden die tatsächlichen Etikettendaten mit One an das Modell übergeben?-Erstellen Sie einen Hot-Vektor.
        one_hot_y = tf.keras.utils.to_categorical(label_seq)

#Um die Größe der Trainingsdaten zu vereinheitlichen, fügen Sie dem kurzen Text 0 hinzu, um den längsten Textdaten zu entsprechen.
        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

Modellerstellung mit 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

• Verwenden Sie zunächst die Einbettungsebene, damit Sie die Beziehungen zwischen Wörtern als Vektor erfassen können. --Flatten Sie die Einbettungsmatrix so, dass sie mit Flatten () dazwischen an die vollständig verbundene dichte Ebene übergeben werden kann.
• Wenn stattdessen AveragePooling1D () verwendet wird, kann die Anzahl der Parameter des neuronalen Netzwerks reduziert und die Berechnungskosten reduziert werden.
• Da die Anzahl der zu identifizierenden "Absichten" mit dem Etikettentyp übereinstimmt, stimmen Sie sie mit der Anzahl der Elemente am Index 0 des One-Hot-Vektors ab. --Wählen Sie "softmax" für die Aktivierungsfunktion der Ausgabeschicht, die einer Mehrklassenklassifizierung entspricht.
• Legen Sie beim Kompilieren des Modells die Verlustberechnungsmethode für die Klassifizierung mehrerer Klassen fest.
• Verwenden Sie "Adam" als Lernalgorithmus.

Eingabebildschirm erstellen

chat.py

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

#Ordnen Sie den von der Konsole empfangenen Text so an, dass das Modell ihn verarbeiten kann.
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)

Konsolenbildschirm. Wenden Sie den eingegebenen Text auf das trainierte Modell an und sagen Sie voraus, für welche der neun "Absichten" es gilt.

• Arten von Absichten
• Kontaktiere uns --Fehler --Startanleitung --Zubehör
• Schlacht --Veranstaltung
• Partner
• Sicherheit --Geschäft

Lauf

Rufen Sie die definierte Funktion auf und führen Sie sie aus.

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)

Trainingsergebnisse

Die Zahlen in "Ergebnisse:" repräsentieren die entsprechenden Wahrscheinlichkeiten für jede Kategorie.

Sagen Sie eine "Startanleitung" für die Eingabe "Wie man Pokemon fängt" voraus. Als nächstes sagen Sie "Shop" für "Poke Coins and Items" voraus. Beide konnten die entsprechende Kategorie vorhersagen.