Criação de um aplicativo de análise de opiniões sobre vacinas contra a COVID-19 usando modelos do Huggingface pré-treinados

Parte 1

Na onda da pandemia da COVID-19, nosso mundo testemunhou desafios e mudanças sem precedentes em vários aspectos da vida. Juntamente com a rápida disseminação do vírus, a Internet e as plataformas de mídia social se tornaram fontes essenciais de informação e comunicação para as pessoas em todo o mundo. Essas plataformas não só proporcionaram um caminho para a divulgação de atualizações vitais, mas também se tornaram um espaço para a expressão de emoções, opiniões e sentimentos relacionados à pandemia.

O desenvolvimento e a distribuição das vacinas contra a COVID-19 foram marcos monumentais em nossa batalha contra a pandemia global. Essas vacinas proporcionaram esperança e um caminho para a recuperação, oferecendo proteção contra os graves efeitos do vírus. À medida que os esforços de vacinação continuam a progredir em todo o mundo, torna-se cada vez mais importante avaliar o sentimento do público e entender as atitudes predominantes em relação às vacinas contra a COVID-19.

A análise de sentimentos, uma técnica poderosa no processamento de linguagem natural (NLP), nos permite extrair insights de dados de texto e descobrir os sentimentos expressos neles. Ao empregar a análise de sentimentos, podemos analisar grandes quantidades de textos on-line, como publicações em mídias sociais, artigos de notícias e opiniões públicas, para discernir as atitudes, opiniões e emoções predominantes relacionadas às vacinas contra a COVID-19.

Neste artigo, exploraremos o processo de criação de um aplicativo de análise de sentimentos em relação a vacinas contra a COVID-19 usando modelos pré-treinados do Hugging Face. O Hugging Face se estabeleceu como um importante fornecedor de tecnologias e estruturas de NLP, oferecendo modelos pré-treinados que aprenderam a reconhecer padrões e nuances na linguagem com precisão excepcional. Ao aproveitar o poder desses modelos, podemos desenvolver um aplicativo que analisa automaticamente o texto e fornece insights valiosos sobre os sentimentos expressos por indivíduos em relação às vacinas contra a COVID-19.

Portanto, junte-se a nós nesta jornada, enquanto aproveitamos o poder dos modelos pré-treinados do Hugging Face para criar um aplicativo de análise de sentimentos sobre as vacinas contra a COVID-19 e obter insights valiosos que podem moldar o discurso em torno dos esforços de vacinação contra a COVID-19.

Para acessar os conjuntos de dados usados, consulte este link do meu Github
https://github.com/AlbieCofie/sentimentanalysis

1. Instalar os pacotes

Para instalar os pacotes necessários para criar um aplicativo de análise de sentimentos sobre vacinas contra a COVID-19, você pode usar os seguintes comandos:

!pip install datasets
!pip install transformers
!pip install sentencepiece

Esses comandos instalarão os pacotes necessários: datasets, transformers e sentencepiece.

O pacote datasets fornece uma coleção de base de dados de NLP popular, o pacote transformers oferece modelos e ferramentas pré-treinados para tarefas de NLP e o sentencepiece, uma biblioteca para tokenização.

2. Importar Bibliotecas & Carregar a Base de Dados

As instruções de importação abaixo determinam as dependências e as bibliotecas necessárias para as etapas subsequentes da criação do modelo de análise de sentimentos.

import os
import pandas as pd
url = "https://raw.githubusercontent.com/AlbieCofie/sentimentanalysis/main/Train.csv"
df = pd.read_csv(url)
from datasets import load_dataset
from sklearn.model_selection import train_test_split
import numpy as np
from transformers import AutoModelForSequenceClassification
from transformers import TFAutoModelForSequenceClassification
from transformers import AutoTokenizer, AutoConfig
# from scipy.special import softmax
from transformers import TrainingArguments, Trainer, DataCollatorWithPadding
# from transformers import HubManager
from sklearn.metrics import mean_squared_error

import os: essa linha importa o módulo os, que fornece uma maneira de interagir com o sistema operacional e realizar operações como leitura ou gravação de arquivos.

import pandas as pd: essa linha importa a biblioteca pandas e atribui a ela o apelido pd. A pandas é uma biblioteca avançada de manipulação de dados que permite trabalhar com dados estruturados, como arquivos CSV, de forma eficiente.

url = "https://raw.githubusercontent.com/AlbieCofie/sentimentanalysis/main/Train.csv": essa linha atribui um URL à variável url. Ele aponta para um arquivo CSV que contém os dados de treinamento para o modelo de análise de sentimentos. O arquivo está hospedado no GitHub.

from datasets import load_dataset: essa linha importa a função load_dataset da biblioteca datasets. Essa função é usada para carregar e acessar bases de dados, incluindo as predefinidas e as personalizadas.

from sklearn.model_selection import train_test_split: essa linha importa a função train_test_split do módulo sklearn.model_selection. Essa função é comumente usada para dividir os dados em conjuntos de treinamento e validação para treinamento e avaliação de modelos.

import numpy as np: Essa linha importa a biblioteca numpy e atribui a ela o apelido np. O numpy é um pacote fundamental para a computação científica em Python e é comumente usado para operações numéricas em arrays multidimensionais.

from transformers import AutoModelForSequenceClassification: essa linha importa a classe AutoModelForSequenceClassification da biblioteca transformers. Essa classe fornece um modelo pré-treinado projetado especificamente para tarefas de classificação de sequências, como a análise de sentimentos.

from transformers import TFAutoModelForSequenceClassification: essa linha importa a classe TFAutoModelForSequenceClassification da biblioteca transformers. Essa classe é uma versão compatível com o TensorFlow da AutoModelForSequenceClassification e pode ser usada para treinamento e inferência com o TensorFlow.

from transformers import AutoTokenizer, AutoConfig: essa linha importa as classes AutoTokenizer e AutoConfig da biblioteca transformers. Essas classes são usadas para selecionar e carregar automaticamente o tokenizador apropriado e a configuração do modelo com base no modelo pré-treinado escolhido.

from transformers import TrainingArguments, Trainer, DataCollatorWithPadding: essa linha importa as classes TrainingArguments, Trainer e DataCollatorWithPadding da biblioteca transformers. Essas classes fornecem as ferramentas e as configurações necessárias para o treinamento de um modelo, incluindo argumentos de treinamento, loop de treinamento e compilação de dados.

from sklearn.metrics import mean_squared_error: essa linha importa a função mean_squared_error do módulo sklearn.metrics. Essa função é usada para avaliar o desempenho de um modelo de regressão, calculando o erro quadrático médio entre os valores preditivos e os valores reais.

Em seguida, a linha de código df = df[~df.isna().any(axis=1)] é usada para remover linhas do DataFrame (df) que contenham quaisquer valores ausentes (NaN).

3. Os Dados

Dividir um DataFrame (df) em grupos de treinamento e avaliação.

train, eval = train_test_split(df, test_size=0.2, random_state=42, stratify=df['label'])

A linha de código acima divide o DataFrame df em grupos de treinamento e avaliação, com 80% dos dados atribuídos ao grupo de treinamento (train) e 20% atribuídos ao grupo de avaliação (eval). A semente aleatória garante a reprodutibilidade e o parâmetro stratify preserva a distribuição de classes na base de dados original durante a divisão.

Vamos obter um snapshot das primeiras 5 linhas dos dados

Base de Dados de Treinamento

train.head()

Snapshot da base de dados de treinamento

Base de Dados de Avaliação

eval.head()

Em seguida, usamos o eval.label.unique() para recuperar os valores exclusivos na coluna "label" do conjunto de avaliação (eval). Ele é usado para determinar as classes ou categorias distintas presentes na coluna "label".

Então, criamos o objeto DatasetDict usando a classe Dataset da biblioteca datasets. Ele também remove uma coluna excedente do conjunto de dados.

from datasets import DatasetDict, Dataset
train_dataset = Dataset.from_pandas(train[['tweet_id', 'safe_text', 'label', 'agreement']])
eval_dataset = Dataset.from_pandas(eval[['tweet_id', 'safe_text', 'label', 'agreement']])

dataset = DatasetDict({'train': train_dataset, 'eval': eval_dataset})
dataset = dataset.remove_columns('__index_level_0__')
dataset

4. Pré-processamento de Texto e Inicialização do Tokenizador

def preprocess(text):
   new_text = []
   for t in text.split(" "):
       t = '@user' if t.startswith('@') and len(t) > 1 else t
       t = 'http' if t.startswith('http') else t
       new_text.append(t)
   return " ".join(new_text)

checkpoint = "cardiffnlp/twitter-xlm-roberta-base-sentiment"

tokenizer = AutoTokenizer.from_pretrained(checkpoint

A função preprocess leva um parâmetro text e o processa substituindo os nomes de usuário do Twitter que começam com "@" por "@user" e substituindo os URLs que começam com "http" por "http”. A função divide o texto de entrada por espaços, realiza as substituições necessárias e junta o texto processado de volta em uma única string. Essa função pode ser usada para pré-processar os dados de texto antes de alimentá-los no modelo de análise de sentimentos.

Em seguida, o código inicializa um tokenizador usando a classe AutoTokenizer da biblioteca transformers.

O tokenizador é criado usando o ponto de verificação "cardiffnlp/twitter-xlm-roberta-base-sentiment", que representa o ponto de verificação** do modelo pré-treinado do Huggingface **para a análise de sentimentos dos dados do Twitter. O tokenizador é responsável por tokenizar o texto de entrada e prepará-lo para a entrada do modelo de análise de sentimentos.

5. Transformar e Preparar a Base de Dados para o Treinamento do Modelo

Essas etapas são essenciais para preparar a base de dados para o treinamento de um modelo de análise de sentimentos.

def transform_labels(label):

   label = label['label']
   num = 0
   if label == -1: #'Negative'
       num = 0
   elif label == 0: #'Neutral'
       num = 1
   elif label == 1: #'Positive'
       num = 2

   return {'labels': num}

def tokenize_data(example):
   return tokenizer(example['safe_text'], padding='max_length')

# Mudar os tweets para tokens que os modelos possam explorar
dataset = dataset.map(tokenize_data, batched=True)

# Transformar rótulos e remover as colunas inúteis
remove_columns = ['tweet_id', 'label', 'safe_text', 'agreement']
dataset = dataset.map(transform_labels, remove_columns=remove_columns)
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

O código acima inclui duas funções, transform_labels e tokenize_data, bem como código adicional para transformar e preparar a base de dados para o treinamento do modelo.

A função transform_labels leva um parâmetro label, que representa a coluna de rótulo da base de dados. Ela extrai o valor do rótulo usando label['label']. Em seguida, ela atribui um valor numérico ao rótulo com base em seu valor original. Nesse caso, se o rótulo for -1, será atribuído a ele um valor numérico de 0 (representando "Negativo"). Se o rótulo for 0, será atribuído um valor de 1 (representando "Neutro"). Se o rótulo for 1, será atribuído a ele um valor de 2 (representando "Positivo"). A função retorna um dicionário com o rótulo transformado armazenado sob a chave 'labels'.

A função tokenize_data leva um parâmetro example, representando um único exemplo da base de dados. Ela tokeniza a coluna 'safe_text' do exemplo usando o tokenizador inicializado anteriormente. O argumento padding='max_length' garante que todas as sequências tokenizadas tenham o mesmo comprimento, preenchendo-as ou truncando-as até o comprimento máximo da sequência definido pelo tokenizador.

A função tokenize_data é então aplicada a toda a base de dados usando o método map. Ela tokeniza a coluna "safe_text" de cada exemplo no conjunto de dados, modificando a base de dados no local. O argumento batched=True indica que a operação de mapeamento deve ser aplicada em lote para aumentar a eficiência.

Em seguida, uma lista chamada remove_columns é criada, contendo os nomes das colunas a serem removidos da base de dados. O método mapé então usado para aplicar a função transform_labels a cada exemplo na base de dados, removendo as colunas especificadas. Essa etapa transforma os rótulos e remove as colunas desnecessárias, modificando a base de dados no local.

5. Treinar

5.1. O objeto TrainingArguments no código abaixo especifica as configurações relacionadas ao treinamento, como o número de epochs (data e hora a partir da qual um computador mede o tempo do sistema), as estratégias de salvamento e avaliação, as configurações de registro e o tamanho do lote. Essas configurações definem como o modelo de análise de sentimentos será treinado e monitorado durante o processo de treinamento.

Vamos detalhar os argumentos usados no objeto TrainingArguments:

• "test_trainer": esse argumento especifica o diretório de saída onde o modelo treinado e os registros de treinamento serão salvos.
• num_train_epochs=10: esse argumento define o número de epochs de treinamento, que determina quantas vezes o modelo iterará sobre toda a base de dados de treinamento durante o treinamento.
• load_best_model_at_end=True: esse argumento especifica que o melhor modelo baseado nas métricas de avaliação será carregado no final do treinamento. O melhor modelo é determinado pela estratégia de avaliação, que, nesse caso, é definida como 'epoch'.
• save_strategy='epoch': Esse argumento determina quando salvar os pontos de verificação do modelo durante o treinamento. Defini-lo como "epoch" garante que o modelo seja salvo após cada epoch de treinamento.
• evaluation_strategy='epoch': esse argumento especifica quando realizar a avaliação durante o treinamento. Defini-lo como "epoch" significa que a avaliação será realizada após cada epoch de treinamento.
• logging_strategy='epoch': esse argumento determina quando registrar as métricas de treinamento. Defini-lo como "epoch" significa que as métricas serão registradas após cada época de treinamento.
• logging_steps=100: esse argumento define a frequência do registro durante o treinamento. As métricas de treinamento serão registradas a cada 100 etapas.
• per_device_train_batch_size=8: esse argumento define o tamanho do lote de treinamento por dispositivo. Ele determina quantos exemplos serão processados em paralelo durante cada etapa de treinamento.

5.2. Carregar um modelo pré-treinado enquanto especifica o número de rótulos em nossa base de dados para ajuste fino

model=AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=3)

5.3. Embaralhar bases de dados de treinamento e avaliação

Ao embaralhar as bases de dados de treinamento e avaliação, a ordem dos exemplos é aleatória, o que ajuda a evitar possíveis vieses ou padrões relacionados à ordem dos exemplos durante o treinamento e a avaliação. O embaralhamento das bases de dados pode levar a uma melhor generalização e desempenho do modelo.

train_dataset = dataset['train'].shuffle(seed=10)
eval_dataset = dataset['eval'].shuffle(seed=10)

5.4. Calcular métricas de avaliação para o modelo de análise de sentimentos.

def compute_metrics(eval_pred):
   logits, labels = eval_pred
   predictions = np.argmax(logits, axis=-1)
   return {"rmse": mean_squared_error(labels, predictions, squared=False)}

Define uma função chamada compute_metrics que leva um único parâmetro, eval_pred, que representa as previsões de avaliação feitas pelo modelo.

logits e labels são descompactados pelo parâmetro eval_pred. logits representa as pontuações preditivas ou probabilidades para cada classe, enquanto labels representa os rótulos verdadeiros dos exemplos.

predictions é calculada tomando o argmax (argumento máximo) ao longo do último eixo do array logits. Isso fornece o índice da classe com a maior pontuação ou probabilidade como a classe preditiva para cada exemplo.

Por fim, a função calcula a raiz do erro quadrático médio (RMSE) usando a função mean_squared_error do sklearn.metrics. Ela compara labels reais com predictions e calcula o valor RMSE. O argumento squared=False garante que o valor RMSE seja retornado em vez do valor ao quadrado.

A função compute_metrics é normalmente usada como um argumento na classe Trainer durante a avaliação. Ela permite o cálculo de métricas de avaliação personalizadas com base nas previsões do modelo e nos rótulos verdadeiros. Nesse caso, a função calcula a métrica RMSE, que pode ser útil para avaliar o desempenho do modelo em tarefas de regressão em que os rótulos de sentimentos são valores contínuos.

5.5. Treinar o Modelo

Durante o treinamento, o modelo de análise de sentimentos itera sobre a base de dados de treinamento para o número determinado de epochs. Em cada epoch, o modelo processa lotes de exemplos de treinamento, calcula os gradientes e atualiza os parâmetros do modelo para minimizar a função loss (perda). O processo de treinamento continua até que o número determinado de epochs seja atingido.

trainer.train()

Durante o treinamento, a classe Trainer tratará de vários aspectos, como processamento em lote, cálculo de gradiente, atualizações de parâmetros, registro de métricas de treinamento e armazenamento de pontos de verificação do modelo, de acordo com as configurações especificadas no objeto TrainingArguments.

6. Enviar o Modelo e o Tokenizer para a Huggingface

Como enviar um modelo treinado e um tokenizador para o Hub de Modelo do Hugging Face, tornando-os acessíveis a outras pessoas e permitindo fácil compartilhamento e colaboração.

token = "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"
model.push_to_hub("AlbieCofie/xlm_roberta_base", use_auth_token=token, commit_message="Pushed model")
tokenizer.push_to_hub("AlbieCofie/xlm_roberta_base", use_auth_token=token, commit_message="pushed tokenizer")

A variável token contém um token de autenticação necessário para acessar o Hub do Modelo do Hugging Face e enviar o modelo. É um token privado associado à conta Hugging Face do usuário.

model.push_to_hub() é usado para enviar o modelo treinado para o Hub do Modelo. A função recebe três argumentos: o nome do modelo ("AlbieCofie/xlm_roberta_base", neste caso), o use_auth_token para autenticar a conta do usuário e o commit_message para fornecer uma breve descrição do commit.

Ao chamar o model.push_to_hub(), o modelo treinado será carregado no Hub do Modelo de Hugging Face com o nome do modelo específico.

Da mesma forma, tokenizer.push_to_hub() é usado para enviar o tokenizador associado ao modelo treinado para o Hub do Model. Ele recebe o nome do tokenizador, use_auth_token e commit_message como argumentos.

Ao executar tokenizer.push_to_hub(), o tokenizador será carregado no Hub do Modelo do Hugging Face com o nome do tokenizador especificado.

Esse artigo foi escrito por Alberta Cofie e traduzido por Fátima Lima. O original pode ser lido aqui.