Construindo sua própria ferramenta de análise de sentimento usando LLM

Introdução

A análise de sentimento é um processo de determinar o tom emocional de um texto, que pode ser aplicado em várias áreas, como marketing, atendimento ao cliente ou pesquisas de opinião pública. Neste artigo, apresentaremos como construir sua própria ferramenta de análise de sentimento utilizando grandes modelos de linguagem (LLM).

Escolha do modelo

O primeiro passo é escolher o modelo de linguagem adequado. Podemos escolher entre:

Modelos pré-treinados (por exemplo, BERT, RoBERTa, DistilBERT) – prontos para uso, mas exigindo ajustes.
Modelos especializados (por exemplo, VADER, TextBlob) – projetados especificamente para análise de sentimento.
Modelos personalizados – treinados em dados específicos para o nosso domínio.

Para nosso exemplo, usaremos Hugging Face Transformers com o modelo DistilBERT, que é uma versão mais leve do BERT e se adapta bem a tarefas de análise de sentimento.

Instalação das bibliotecas necessárias

Para começar, instalemos as bibliotecas necessárias:

pip install transformers torch pandas

Carregamento do modelo e tokenizador

Em seguida, carregamento do modelo e tokenizador:

from transformers import pipeline

# Carregamento da ferramenta pronta para análise de sentimento
sentiment_pipeline = pipeline("sentiment-analysis")

Preparação dos dados

Preparemos um conjunto de dados para testar. Podemos usar um exemplo simples:

texts = [
    "Amo este produto, é fantástico!",
    "Não recomendo, muito decepcionado.",
    "Produto médio, nada excepcional.",
    "O desempenho é satisfatório, mas o preço é muito alto."
]

Análise de sentimento

Agora podemos realizar a análise de sentimento para nossos textos:

results = sentiment_pipeline(texts)

for text, result in zip(texts, results):
    print(f"Texto: {text}")
    print(f"Sentimento: {result['label']} (Confiança: {result['score']:.2f})")
    print("---")

Ajuste do modelo

Se quisermos ajustar o modelo para nossos dados específicos, podemos usar a biblioteca Hugging Face Transformers para treinar o modelo em nosso conjunto de dados.

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

# Conjunto de dados de exemplo
data = pd.DataFrame({
    "text": ["Amo este produto", "Não recomendo", "Produto médio"],
    "label": [1, 0, 0]  # 1 - positivo, 0 - negativo
})

# Divisão dos dados em conjunto de treinamento e teste
train_texts, test_texts, train_labels, test_labels = train_test_split(
    data["text"], data["label"], test_size=0.2
)

# Carregamento do tokenizador e modelo
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Tokenização dos dados
train_encodings = tokenizer(list(train_texts), truncation=True, padding=True)
test_encodings = tokenizer(list(test_texts), truncation=True, padding=True)

# Classe para manipulação dos dados
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)

# Configurações de treinamento
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,
)

# Treinamento do modelo
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset
)

trainer.train()

Implantação do modelo

Após o treinamento do modelo, podemos salvá-lo e usá-lo para análise de sentimento:

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

# Carregamento do modelo ajustado
custom_model = AutoModelForSequenceClassification.from_pretrained("./custom_sentiment_model")
custom_tokenizer = AutoTokenizer.from_pretrained("./custom_sentiment_model")

# Análise de exemplo
custom_pipeline = pipeline("sentiment-analysis", model=custom_model, tokenizer=custom_tokenizer)
print(custom_pipeline("Este produto é ótimo!"))

Resumo

Neste artigo, mostramos como construir sua própria ferramenta de análise de sentimento utilizando grandes modelos de linguagem. Passo a passo, discutimos a escolha do modelo, preparação dos dados, análise de sentimento e ajuste do modelo para nossas necessidades. Com essa ferramenta, podemos analisar eficazmente o tom emocional de textos em várias áreas.