Une étude de cas sur l'utilisation du modèle LSTM bidirectionnel pour la classification de texte

Le modèle LSTM bidirectionnel est un réseau de neurones utilisé pour la classification de texte. Vous trouverez ci-dessous un exemple simple montrant comment utiliser le LSTM bidirectionnel pour les tâches de classification de texte.

Tout d'abord, nous devons importer les bibliothèques et modules requis :

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

Ensuite, nous devons préparer l'ensemble de données. Ici, nous supposons que l'ensemble de données existe déjà dans le chemin spécifié et contient trois fichiers : train.txt, dev.txt et test.txt. Chaque fichier contient une séquence de texte et les balises correspondantes. Nous pouvons charger l'ensemble de données en utilisant le code suivant :

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

Après avoir chargé l'ensemble de données, nous pouvons prétraiter et sérialiser le texte. Ici, nous utilisons Tokenizer pour la segmentation de texte, puis complétons la séquence d'index de chaque mot à la même longueur afin qu'elle puisse être appliquée au modèle LSTM.

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)

Ensuite, nous pouvons construire un modèle LSTM bidirectionnel. Dans ce modèle, nous utilisons deux couches LSTM, une pour transmettre les informations vers l'avant et une pour transmettre les informations vers l'arrière. Les sorties de ces deux couches LSTM sont concaténées pour former un vecteur plus puissant représentant le texte. Enfin, nous utilisons une couche entièrement connectée pour la classification.

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'])

Maintenant, nous pouvons entraîner le modèle. Nous utiliserons l'ensemble de données de développement comme données de validation pour nous assurer de ne pas surajuster pendant la formation.

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

Une fois la formation terminée, nous pouvons évaluer les performances du modèle sur l'ensemble de test.

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

Ce qui précède est un exemple de classification de texte utilisant un simple modèle LSTM bidirectionnel. Vous pouvez également essayer d'ajuster les paramètres du modèle, tels que le nombre de couches, le nombre de neurones, les optimiseurs, etc., pour obtenir de meilleures performances. Vous pouvez également utiliser des intégrations de mots pré-entraînées (telles que Word2Vec ou GloVe) pour remplacer la couche d'intégration afin de capturer davantage d'informations sémantiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!