Construction de votre propre outil d'analyse de sentiment à l'aide de LLM

Introduction

L'analyse de sentiment est un processus de détermination du ton émotionnel d'un texte, qui peut être appliqué dans de nombreux domaines, tels que le marketing, le service client ou les études d'opinion publique. Dans cet article, nous allons vous montrer comment construire votre propre outil d'analyse de sentiment utilisant de grands modèles linguistiques (LLM).

Choix du modèle

La première étape consiste à choisir un modèle linguistique approprié. Nous pouvons choisir entre :

Modèles pré-entraînés (par exemple, BERT, RoBERTa, DistilBERT) – prêts à l'emploi, mais nécessitant un ajustement.
Modèles spécialisés (par exemple, VADER, TextBlob) – conçus spécifiquement pour l'analyse de sentiment.
Modèles personnalisés – entraînés sur des données spécifiques à notre domaine.

Pour notre exemple, nous utiliserons Hugging Face Transformers avec le modèle DistilBERT, qui est une version plus légère de BERT et convient bien aux tâches d'analyse de sentiment.

Installation des bibliothèques requises

Pour commencer, installons les bibliothèques nécessaires :

pip install transformers torch pandas

Chargement du modèle et du tokeniseur

Ensuite, chargeons le modèle et le tokeniseur :

from transformers import pipeline

# Chargement de l'outil prêt à l'emploi pour l'analyse de sentiment
sentiment_pipeline = pipeline("sentiment-analysis")

Préparation des données

Préparons un ensemble de données pour les tests. Nous pouvons utiliser un exemple simple :

texts = [
    "J'adore ce produit, c'est fantastique !",
    "Je ne recommande pas, très déçu.",
    "Produit moyen, rien d'exceptionnel.",
    "Le fonctionnement est satisfaisant, mais le prix est trop élevé."
]

Analyse de sentiment

Nous pouvons maintenant effectuer une analyse de sentiment pour nos textes :

results = sentiment_pipeline(texts)

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

Adaptation du modèle

Si nous voulons adapter le modèle à nos données spécifiques, nous pouvons utiliser la bibliothèque Hugging Face Transformers pour entraîner le modèle sur notre ensemble de données.

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

# Exemple de jeu de données
data = pd.DataFrame({
    "text": ["J'adore ce produit", "Je ne recommande pas", "Produit moyen"],
    "label": [1, 0, 0]  # 1 - positif, 0 - négatif
})

# Division des données en ensemble d'entraînement et de test
train_texts, test_texts, train_labels, test_labels = train_test_split(
    data["text"], data["label"], test_size=0.2
)

# Chargement du tokeniseur et du modèle
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Tokenisation des données
train_encodings = tokenizer(list(train_texts), truncation=True, padding=True)
test_encodings = tokenizer(list(test_texts), truncation=True, padding=True)

# Classe pour gérer les données
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)

# Paramètres d'entraînement
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,
)

# Entraînement du modèle
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset
)

trainer.train()

Déploiement du modèle

Après l'entraînement du modèle, nous pouvons le sauvegarder et l'utiliser pour l'analyse de sentiment :

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

# Chargement du modèle personnalisé
custom_model = AutoModelForSequenceClassification.from_pretrained("./custom_sentiment_model")
custom_tokenizer = AutoTokenizer.from_pretrained("./custom_sentiment_model")

# Exemple d'analyse
custom_pipeline = pipeline("sentiment-analysis", model=custom_model, tokenizer=custom_tokenizer)
print(custom_pipeline("Ce produit est génial !"))

Résumé

Dans cet article, nous avons montré comment construire votre propre outil d'analyse de sentiment utilisant de grands modèles linguistiques. Étape par étape, nous avons discuté du choix du modèle, de la préparation des données, de l'analyse de sentiment et de l'adaptation du modèle à vos besoins. Grâce à cet outil, nous pouvons analyser efficacement le ton émotionnel des textes dans divers domaines.