Budowanie własnego narzędzia do analizy sentymentu z użyciem LLM

Wstęp

Analiza sentymentu to proces określenia emocjonalnego tonu tekstu, który może być stosowany w wielu dziedzinach, takich jak marketing, obsługa klienta czy badania opinii publicznej. W tym artykule przedstawimy, jak zbudować własne narzędzie do analizy sentymentu wykorzystujące duże modele językowe (LLM).

Wybór modelu

Pierwszym krokiem jest wybór odpowiedniego modelu językowego. Możemy wybrać między:

• Przedtrenowanymi modelami (np. BERT, RoBERTa, DistilBERT) – gotowe do użycia, ale wymagające dostosowania.
• Modelami specjalistycznymi (np. VADER, TextBlob) – zaprojektowanymi specjalnie do analizy sentymentu.
• Własnymi modelami – trenowanymi na danych specyficznych dla naszej dziedziny.

Dla naszego przykładu użyjemy Hugging Face Transformers z modelem DistilBERT, który jest lżejszą wersją BERT i dobrze nadaje się do zadań analizy sentymentu.

Instalacja wymaganych bibliotek

Aby rozpocząć, zainstalujmy niezbędne biblioteki:

pip install transformers torch pandas

Ładowanie modelu i tokenizera

Następnie załadowanie modelu i tokenizera:

from transformers import pipeline

# Ładowanie gotowego narzędzia do analizy sentymentu
sentiment_pipeline = pipeline("sentiment-analysis")

Przygotowanie danych

Przygotujmy zbiór danych do testowania. Możemy użyć prostego przykładu:

texts = [
    "Kocham ten produkt, jest fantastyczny!",
    "Nie polecam, bardzo rozczarowany.",
    "Średni produkt, nic wyjątkowego.",
    "Działanie jest zadowalające, ale cena jest zbyt wysoka."
]

Analiza sentymentu

Teraz możemy przeprowadzić analizę sentymentu dla naszych tekstów:

results = sentiment_pipeline(texts)

for text, result in zip(texts, results):
    print(f"Tekst: {text}")
    print(f"Sentyment: {result['label']} (Pewność: {result['score']:.2f})")
    print("---")

Dostosowanie modelu

Jeśli chcemy dostosować model do naszych specyficznych danych, możemy użyć biblioteki Hugging Face Transformers do trenowania modelu na naszym zbiorze danych.

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

# Przykładowy zbiór danych
data = pd.DataFrame({
    "text": ["Kocham ten produkt", "Nie polecam", "Średni produkt"],
    "label": [1, 0, 0]  # 1 - pozytywny, 0 - negatywny
})

# Podział danych na zbiór treningowy i testowy
train_texts, test_texts, train_labels, test_labels = train_test_split(
    data["text"], data["label"], test_size=0.2
)

# Ładowanie tokenizera i modelu
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Tokenizacja danych
train_encodings = tokenizer(list(train_texts), truncation=True, padding=True)
test_encodings = tokenizer(list(test_texts), truncation=True, padding=True)

# Klasa do obsługi danych
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)

# Ustawienia trenowania
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,
)

# Trenowanie modelu
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset
)

trainer.train()

Wdrażanie modelu

Po trenowaniu modelu możemy go zapisać i użyć do analizy sentymentu:

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

# Ładowanie dostosowanego modelu
custom_model = AutoModelForSequenceClassification.from_pretrained("./custom_sentiment_model")
custom_tokenizer = AutoTokenizer.from_pretrained("./custom_sentiment_model")

# Przykładowa analiza
custom_pipeline = pipeline("sentiment-analysis", model=custom_model, tokenizer=custom_tokenizer)
print(custom_pipeline("Ten produkt jest świetny!"))

Podsumowanie

W tym artykule pokazaliśmy, jak zbudować własne narzędzie do analizy sentymentu wykorzystujące duże modele językowe. Krok po kroku omówiliśmy wybór modelu, przygotowanie danych, analizę sentymentu oraz dostosowanie modelu do naszych potrzeb. Dzięki temu narzędziu możemy efektywnie analizować emocjonalny ton tekstów w różnych dziedzinach.