Aufbau eines eigenen Tools zur Sentimentanalyse mit LLM

Einführung

Die Sentimentanalyse ist ein Prozess zur Bestimmung des emotionalen Tons eines Textes, der in vielen Bereichen wie Marketing, Kundenservice oder Meinungsforschung angewendet werden kann. In diesem Artikel zeigen wir, wie man ein eigenes Tool zur Sentimentanalyse unter Verwendung großer Sprachmodelle (LLM) erstellt.

Modellauswahl

Der erste Schritt besteht in der Auswahl eines geeigneten Sprachmodells. Wir können zwischen folgenden Optionen wählen:

Vortrainierte Modelle (z. B. BERT, RoBERTa, DistilBERT) – bereit zur Verwendung, aber anpassbar.
Spezialisierte Modelle (z. B. VADER, TextBlob) – speziell für die Sentimentanalyse entwickelt.
Eigene Modelle – auf spezifischen Daten für unsere Domäne trainiert.

Für unser Beispiel verwenden wir Hugging Face Transformers mit dem Modell DistilBERT, das eine leichtere Version von BERT ist und sich gut für Aufgaben der Sentimentanalyse eignet.

Installation der erforderlichen Bibliotheken

Um zu beginnen, installieren wir die notwendigen Bibliotheken:

pip install transformers torch pandas

Laden des Modells und Tokenizers

Als Nächstes laden wir das Modell und den Tokenizer:

from transformers import pipeline

# Laden des fertigen Tools zur Sentimentanalyse
sentiment_pipeline = pipeline("sentiment-analysis")

Vorbereitung der Daten

Bereiten wir einen Datensatz zum Testen vor. Wir können ein einfaches Beispiel verwenden:

texts = [
    "Ich liebe dieses Produkt, es ist fantastisch!",
    "Ich empfehle es nicht, sehr enttäuscht.",
    "Durchschnittliches Produkt, nichts Besonderes.",
    "Die Wirkung ist zufriedenstellend, aber der Preis ist zu hoch."
]

Sentimentanalyse

Jetzt können wir die Sentimentanalyse für unsere Texte durchführen:

results = sentiment_pipeline(texts)

for text, result in zip(texts, results):
    print(f"Text: {text}")
    print(f"Sentiment: {result['label']} (Sicherheit: {result['score']:.2f})")
    print("---")

Anpassung des Modells

Wenn wir das Modell an unsere spezifischen Daten anpassen möchten, können wir die Bibliothek Hugging Face Transformers zum Trainieren des Modells an unserem Datensatz verwenden.

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import Trainer, TrainingArguments
import pandas as pd
from sklearn.model_selection import train_test_split

# Beispiel-Datensatz
data = pd.DataFrame({
    "text": ["Ich liebe dieses Produkt", "Ich empfehle es nicht", "Durchschnittliches Produkt"],
    "label": [1, 0, 0]  # 1 - positiv, 0 - negativ
})

# Aufteilung der Daten in Trainings- und Testdatensatz
train_texts, test_texts, train_labels, test_labels = train_test_split(
    data["text"], data["label"], test_size=0.2
)

# Laden des Tokenizers und Modells
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Tokenisierung der Daten
train_encodings = tokenizer(list(train_texts), truncation=True, padding=True)
test_encodings = tokenizer(list(test_texts), truncation=True, padding=True)

# Klasse zur Datenverarbeitung
class SentimentDataset(torch.utils.data.Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings
        self.labels = labels

    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        item["labels"] = torch.tensor(self.labels[idx])
        return item

    def __len__(self):
        return len(self.labels)

train_dataset = SentimentDataset(train_encodings, train_labels)
test_dataset = SentimentDataset(test_encodings, test_labels)

# Trainingsparameter
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
)

# Trainieren des Modells
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset
)

trainer.train()

Bereitstellung des Modells

Nach dem Training des Modells können wir es speichern und zur Sentimentanalyse verwenden:

model.save_pretrained("./custom_sentiment_model")
tokenizer.save_pretrained("./custom_sentiment_model")

# Laden des angepassten Modells
custom_model = AutoModelForSequenceClassification.from_pretrained("./custom_sentiment_model")
custom_tokenizer = AutoTokenizer.from_pretrained("./custom_sentiment_model")

# Beispielanalyse
custom_pipeline = pipeline("sentiment-analysis", model=custom_model, tokenizer=custom_tokenizer)
print(custom_pipeline("Dieses Produkt ist großartig!"))

Zusammenfassung

In diesem Artikel haben wir gezeigt, wie man ein eigenes Tool zur Sentimentanalyse unter Verwendung großer Sprachmodelle erstellt. Schritt für Schritt haben wir die Modellauswahl, Datenvorbereitung, Sentimentanalyse und Anpassung des Modells an unsere Bedürfnisse besprochen. Mit diesem Tool können wir den emotionalen Ton von Texten in verschiedenen Bereichen effektiv analysieren.