Eine Fallstudie zur Verwendung des bidirektionalen LSTM-Modells zur Textklassifizierung

Das bidirektionale LSTM-Modell ist ein neuronales Netzwerk, das zur Textklassifizierung verwendet wird. Unten finden Sie ein einfaches Beispiel, das zeigt, wie bidirektionales LSTM für Textklassifizierungsaufgaben verwendet wird.

Zuerst müssen wir die erforderlichen Bibliotheken und Module importieren:

import os  
import numpy as np  
from keras.preprocessing.text import Tokenizer  
from keras.preprocessing.sequence import pad_sequences  
from keras.models import Sequential  
from keras.layers import Dense, Embedding, Bidirectional, LSTM  
from sklearn.model_selection import train_test_split

Als nächstes müssen wir den Datensatz vorbereiten. Hier gehen wir davon aus, dass der Datensatz bereits im angegebenen Pfad vorhanden ist und drei Dateien enthält: train.txt, dev.txt und test.txt. Jede Datei enthält eine Textsequenz und entsprechende Tags. Wir können den Datensatz mit dem folgenden Code laden:

def load_imdb_data(path):  
    assert os.path.exists(path)  
    trainset, devset, testset = [], [], []  
    with open(os.path.join(path, "train.txt"), "r") as fr:  
        for line in fr:  
            sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)  
            trainset.append((sentence, sentence_label))  
    with open(os.path.join(path, "dev.txt"), "r") as fr:  
        for line in fr:  
            sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)  
            devset.append((sentence, sentence_label))  
    with open(os.path.join(path, "test.txt"), "r") as fr:  
        for line in fr:  
            sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)  
            testset.append((sentence, sentence_label))  
    return trainset, devset, testset

Nach dem Laden des Datensatzes können wir den Text vorverarbeiten und serialisieren. Hier verwenden wir Tokenizer zur Textsegmentierung und füllen dann die Indexsequenz jedes Wortes auf die gleiche Länge auf, damit sie auf das LSTM-Modell angewendet werden kann.

max_features = 20000  
maxlen = 80  # cut texts after this number of words (among top max_features most common words)  
batch_size = 32  
  
print('Pad & split data into training set and dev set')  
x_train, y_train = [], []  
for sent, label in trainset:  
    x_train.append(sent)  
    y_train.append(label)  
x_train, y_train = pad_sequences(x_train, maxlen=maxlen), np.array(y_train)  
x_train, y_train = np.array(x_train), np.array(y_train)  
x_dev, y_dev = [], []  
for sent, label in devset:  
    x_dev.append(sent)  
    y_dev.append(label)  
x_dev, y_dev = pad_sequences(x_dev, maxlen=maxlen), np.array(y_dev)  
x_dev, y_dev = np.array(x_dev), np.array(y_dev)

Als nächstes können wir ein bidirektionales LSTM-Modell erstellen. In diesem Modell verwenden wir zwei LSTM-Schichten, eine für die Weiterleitung von Informationen und eine für die Rückwärtsweitergabe von Informationen. Die Ausgaben dieser beiden LSTM-Ebenen werden verkettet, um einen leistungsfähigeren Vektor zu bilden, der den Text darstellt. Schließlich verwenden wir eine vollständig verbundene Schicht zur Klassifizierung.

print('Build model...')  
model = Sequential()  
model.add(Embedding(max_features, 128, input_length=maxlen))  
model.add(Bidirectional(LSTM(64)))  
model.add(LSTM(64))  
model.add(Dense(1, activation='sigmoid'))  
  
print('Compile model...')  
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

Jetzt können wir das Modell trainieren. Wir werden den Entwicklungsdatensatz als Validierungsdaten verwenden, um sicherzustellen, dass wir während des Trainings nicht überpassen.

epochs = 10  
batch_size = 64  
  
history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_dev, y_dev))

Nachdem das Training abgeschlossen ist, können wir die Leistung des Modells am Testsatz bewerten.

test_loss, test_acc = model.evaluate(x_test, y_test)  
print('Test accuracy:', test_acc)

Das Obige ist ein Beispiel für die Textklassifizierung mithilfe eines einfachen bidirektionalen LSTM-Modells. Sie können auch versuchen, die Parameter des Modells anzupassen, z. B. die Anzahl der Schichten, die Anzahl der Neuronen, Optimierer usw., um eine bessere Leistung zu erzielen. Oder verwenden Sie vorab trainierte Worteinbettungen (wie Word2Vec oder GloVe), um die Einbettungsebene zu ersetzen und mehr semantische Informationen zu erfassen.

Das obige ist der detaillierte Inhalt vonEine Fallstudie zur Verwendung des bidirektionalen LSTM-Modells zur Textklassifizierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!