PyTorch-Beispiel - Projekt zur Textsentimentanalyse

Die Textsentimentanalyse ist eine grundlegende Aufgabe der Verarbeitung natürlicher Sprache (NLP), die darauf abzielt, die in einem Textstück ausgedrückte Sentimentausrichtung (positiv/negativ) zu bestimmen. Dieses Projekt verwendet PyTorch, um ein Deep-Learning-Modell zu erstellen, um die Sentimentklassifizierung von Filmkritiken zu erreichen.

Anwendungsszenarien der Sentimentanalyse

  • Produktbewertungsanalyse
  • Überwachung der öffentlichen Meinung in sozialen Medien
  • Kundenservice-Feedback-Klassifizierung
  • Markttrend

Umgebungsvorbereitung

Erforderliche Tools und Bibliotheken

Beispiel

import torch
import torch.nn as nn
import torch.optim as optim
from torch.data import Field, TabularDataset, BucketIterator
import spacy
import numpy as np

Abhängigkeiten installieren

pip install torch torchtext spacy
python -m spacy download en_core_web_sm

Datenvorbereitung

Einführung in den Datensatz

Der IMDB-Filmkritiken-Datensatz, der 50,000 Rezensionen mit Sentiment-Labels (positiv/negativ) enthält.

Datenvorverarbeitung

Beispiel

# Feld definieren
TEXT = Field(tokenize='spacy',
            tokenizer_language='en_core_web_sm',
            include_lengths=True)
LABEL = Field(sequential=False, use_vocab=False)

# Datensatz laden
train_data, test_data = TabularDataset.splits(
    path='./data',
    train='train.csv',
    test='test.csv',
    format='csv',
    fields=[('text', TEXT), ('label', LABEL)]
)

# Vokabular erstellen
TEXT.build_vocab(train_data,
                max_size=25000,
                vectors="glove.6B.100d")

Modellerstellung

LSTM-Modellarchitektur

4.2 Modellimplementierungscode

Beispiel

class SentimentLSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim,
                           hidden_dim,
                           num_layers=n_layers,
                           bidirectional=True)
        self.fc = nn.Linear(hidden_dim * 2, output_dim)
        self.dropout = nn.Dropout(0.5)
       
    def forward(self, text, text_lengths):
        embedded = self.dropout(self.embedding(text))
        packed_embedded = nn.utils.rnn.pack_padded_sequence(
            embedded, text_lengths.to('cpu'))
        packed_output, (hidden, cell) = self.lstm(packed_embedded)
        hidden = self.dropout(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1))
        return self.fc(hidden)

Modelltraining

Trainingsparameter-Einstellungen

Beispiel

# Modellparameter
INPUT_DIM = len(TEXT.vocab)
EMBEDDING_DIM = 100
HIDDEN_DIM = 256
OUTPUT_DIM = 1
N_LAYERS = 2

# Modell initialisieren
model = SentimentLSTM(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, N_LAYERS)

# Optimierer und Verlustfunktion
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()

Trainingsschleife

Beispiel

def train(model, iterator, optimizer, criterion):
    epoch_loss = 0
    epoch_acc = 0
   
    model.train()
   
    for batch in iterator:
        text, text_lengths = batch.text
        predictions = model(text, text_lengths).squeeze(1)
        loss = criterion(predictions, batch.label)
       
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
       
        epoch_loss += loss.item()
        epoch_acc += accuracy(predictions, batch.label)
       
    return epoch_loss / len(iterator), epoch_acc / len(Iterator)

Modellbewertung

Evaluierungsfunktion

Beispiel

def evaluate(model, iterator, criterion):
    epoch_loss = 0
    epoch_acc = 0
   
    model.eval()
   
    with torch.no_grad():
        for batch in iterator:
            text, text_lengths = batch.text
            predictions = model(text, text_lengths).squeeze(1)
            loss = criterion(predictions, batch.label)
            epoch_loss += loss.item()
            epoch_acc += accuracy(predictions, batch.label)
           
    return epoch_loss / len(iterator), epoch_acc / len(Iterator)

Genauigkeitsberechnung

Beispiel

def accuracy(preds, y):
    rounded_preds = torch.round(torch.sigmoid(preds))
    correct = (rounded_preds == y).float()
    acc = correct.sum() / len(correct)
    return acc

Modellanwendung

Neuen Text vorhersagen

Beispiel

def predict_sentiment(model, sentence):
    tokenized = [tok.text for tok in nlp.tokenizer(sentence)]
    indexed = [TEXT.vocab.stoi[t] for t in tokenized]
    length = [len(indexed)]
    tensor = torch.LongTensor(indexed).to(device)
    tensor = tensor.unsqueeze(1)
    length_tensor = torch.LongTensor(length)
    prediction = torch.sigmoid(model(tensor, length_tensor))
    return prediction.item()

Beispielvorhersage

Beispiel

positive_review = "Dieser Film war fantastisch! Ich habe ihn wirklich genossen."
negative_review = "Der Film war schrecklich und langweilig."

print(f"Positiver Bewertungswert: {predict_sentiment(model, positive_review):.4f}")
print(f"Negativer Bewertungswert: {predict_sentiment(model, negative_review):.4f}")
Andere Erweiterungen