Análise de Dados: Utilizando o modelo BERT para análises de sentimentos em um conjunto de dados
- #Estrutura de dados
Introdução
Nos últimos anos, a inteligência artificial (IA) consolidou-se como uma das principais inovações tecnológicos do século XXI, provocando mudanças significativas em diversos setores da sociedade. Desde a automação de tarefas costumeiros até a análise de grandes volumes de dados, a IA mostrou um imenso potencial para transformar a maneira como interagimos com o mundo ao nosso redor. Nesse contexto, a análise de sentimentos tornou-se um elemento-chave na busca por uma experiência de usuário cada vez mais satisfatória e atrativa.
Análise de dados
A análise de dados é um procedimento organizado e metódico que envolve examinar, purificar, converter e moldar dados para descobrir insights valiosos, facilitar a tomada de decisões e descobrir padrões ocultos. Quer se trate de empresas que pretendem melhorar as suas estratégias de mercado, de instituições de investigação que se aprofundam em novas descobertas científicas, ou mesmo de indivíduos como nós que fazem escolhas informadas com base nas informações disponíveis, a análise de dados desempenha um papel crucial. As empresas confiam na análise de dados para compreender o comportamento do consumidor, otimizar as cadeias de abastecimento e melhorar as táticas de marketing. No domínio da investigação científica, os dados são meticulosamente examinados para validar hipóteses, identificar tendências e contribuir para o avanço do conhecimento em vários campos.
Análise de sentimentos
A análise de sentimento é uma técnica de processamento de linguagem natural que busca apurar o sentimento ou emoção veiculada em um texto. Este método encontra ampla aplicação em mídias sociais, comentários de usuários e análises de produtos. No mundo dos negócios, a análise de sentimento evoluiu para uma ferramenta vital para avaliar a recepção de produtos e serviços entre os consumidores. As empresas esforçam-se não só para compreender as discussões em torno das suas ofertas, mas também para discernir o sentimento positivo ou negativo associado a essas discussões. Esta profunda compreensão do sentimento do consumidor permite adaptações rápidas às estratégias de marketing e melhoria do produto, promovendo assim a satisfação do cliente e a fidelidade à marca.
Modelo BERT
O modelo BERT (Bidirectional Encoder Representations from Transformers), desenvolvido pelos pesquisadores do Google, representa uma abordagem inovadora no campo da PLN (Processamento de linguagem natural), superando muitas limitações encontradas em modelos anteriores. O diferencial fundamental do BERT está na sua capacidade de compreender o contexto bidirecional das palavras em uma frase, o que significa que ele considera as palavras ao seu redor em ambos os lados, facilitando o processo, visto que não é necessário análisar palavra por palavra.
A arquitetura do BERT é baseada em transformers, uma classe de modelos que utiliza mecanismos de atenção para ponderar a importância de diferentes partes do texto durante o processamento. A atenção bidirecional do BERT permite que o modelo capture nuances e dependências complexas, tornando-o altamente eficaz em tarefas que envolvem compreensão de linguagem natural, como tradução automática, resumo de textos e análise de sentimentos.
Exemplo de Entrada de dados no modelo BERT:
A imagem representa um diagrama de um modelo de transformador para PLN, e como ele processa uma sentença em uma linguagem natural. O processo de tokenização, incorporação e codificação é dado:
1. Entrada de Sentença: A sentença “my dog is cute he likes playing” é dividida em tokens.
[MASK] - Token especial usado no treinamento de modelos de linguagem.
[CLS] - Token usado como um marcador para início de uma sentença.
[SEP] - Token usado para marcar o fim de uma sentença, ou, para indicar outra sentença que virá em seguida.
2. Incorporação de Tokens: Cada token é transformado em uma incorporação de token e uma incorporação de sentença.
3. Codificação Posicional: As incorporações são então processadas através de codificações posicionais do transformador.
Metodologia
Carregamento do conjunto de dados IMDB
Para a análise sentimental, utilizamos o conjunto de dados da IMDB em sua formatação reduzida, que contém avaliações de filmes classificadas como positivas ou negativas. Os dados são divididos em conjuntos de treinamentos e teste.
# Carregue o conjunto de dados IMDB com um número reduzido de exemplos
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000, skip_top=50, maxlen=100, start_char=1, oov_char=2, index_from=3)
Tabela de exemplo da estrutura da base de dados do conjunto da imdb, sendo que são as frases são rotuladas em 0 = negativo e 1 = positivo.
Por que o modelo BERT foi utilizado
A escolha do modelo BERT para este projeto foi baseada no desempenho comprovado em tarefas de processamento de linguagem natural (PLN) especificamente em análise de sentimentos. A facilidade de obtenção de suporte disponíveis na comunidade foi outro motivo da escolha. E também pela sua capacidade de lidar com a complexidade linguística, proporcionar uma base pré-treinada abrangente e oferecer um desempenho sólido em uma variedade de contextos textuais.
# Carregue o modelo BERT
bert_model = BertForSequenceClassification.from_pretrained('bert-base-uncased') #BertBaseUncased é um modelo reduzido do BERT
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)
Pré-Processamento dos dados
– Limpeza dos dados
Nesta etapa fazemos a reversão das sequências de inteiros para palavras, usando o índice do vocabulário do conjunto de dados IMDB. A reversão das sequências é uma prática comum para manter a interpretabilidade e a compreensão humana durante as etapas iniciais do processamento de texto, mesmo quando os modelos operam com representações numéricas.
– Tokenização e codificação
Aqui fazemos a tokenização e codificação do modelo de dados. Essa etapa foi crítica para preparar os dados do texto de maneira que modelos como o BERT possam compreender e processar efetivamente a informação contida no texto, capturando relações semânticas e contextualizando as palavras. A tokenização envolve dividir o texto em unidades menores chamadas tokens. No contexto do BERT, os tokens podem ser palavras, subpalavras ou até mesmo partes de palavras. A codificação é o processo de atribuir valores numéricos a cada token. No caso do BERT, essa codificação inclui a atribuição de IDs de token específicos e a criação de máscaras de atenção para indicar quais partes da sequência são relevantes durante o treinamento.
# Tokenize e codifique os dados usando o tokenizer BERT
encoded_train = tokenizer.batch_encode_plus(train_data, padding=True, truncation=True, max_length=128, return_tensors='pt')
encoded_test = tokenizer.batch_encode_plus(test_data, padding=True, truncation=True, max_length=128, return_tensors='pt')
input_ids_train = encoded_train['input_ids']
token_type_ids_train = encoded_train['token_type_ids']
attention_mask_train = encoded_train['attention_mask']
input_ids_test = encoded_test['input_ids']
token_type_ids_test = encoded_test['token_type_ids']
attention_mask_test = encoded_test['attention_mask']
– Criação do DataLoader
A criação do DataLoader serviu para organizar e fornecer os dados de treinamento em lotes durante o treinamento do modelo BERT. Essa foi uma prática essencial para treinar o modelo eficientemente, melhorar a generalização e simplificar o processo de treinamento, especialmente ao lidar com conjuntos de dados grandes e complexos como o conjunto da IMDB.
# Crie um TensorDataset e DataLoader para treino
train_dataset = TensorDataset(input_ids_train, attention_mask_train, torch.from_numpy(train_labels))
train_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)
# Crie um TensorDataset e DataLoader para teste
test_dataset = TensorDataset(input_ids_test, attention_mask_test, torch.from_numpy(test_labels))
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=False)
– Codificação de Rótulos
A codificação de rótulos foi essencial em meu modelo já que garantiu que os rótulos das classes fossem representados de maneira numérica, garantindo uma padronização das classes em todo o conjunto de dados e tornando-os compatíveis com os requisitos do modelo, facilitando o treinamento eficiente e a avaliação do desempenho.
– Treinamento do Modelo BERT
Primeiro foi criado um otimizador(optimizer) para ajustar os pesos do modelo, e um scheduler para ajustar dinamicamente a taxa de aprendizado. Em seguida foi definido o número de épocas(epochs) para ‘2’. Definindo que o treinamento será realizando em três ciclos pelo conjunto de treinamento. Logo após é criada uma função de perda para calcular a discrepância entre as previsões do modelo e os rótulos reais. O treinamento do modelo BERT é realizado em um loop de épocas, onde cada época consiste em várias iterações sobre o conjunto de treinamento. A quantidade e os tipos de testes apresentaram desafios, haja vista o tempo extremamente extenso para cada iteração de treinamento, validação e teste de um Transformer, o que limita a quantidade de experimentos para este trabalho. O primeiro treinamento com uma (batch_size = 32). Após completar o treinamento de cada época, o scheduler é acionado para ajustar dinamicamente a taxa de aprendizado.
Exemplo do treinamento:
# Crie um otimizador e um scheduler
optimizer = torch.optim.AdamW(bert_model.parameters(), lr=2e-5)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9)
# Defina o número de épocas
num_epochs = 2
# Defininindo a função de perda
loss_fn = torch.nn.CrossEntropyLoss() #Criação da classe 'CrossEntropyLoss' para calcular a perda durante o treinamento.
# Início do Loop de treinamento que itera sobre cada epoch
for epoch in range(num_epochs):
bert_model.train() # Indicando que o modelo bert está em modo de train(treinamento).
for input_ids, attention_mask, targets in train_dataloader: # Função de entrada pro modelo
optimizer.zero_grad() # Utilizado para zerar os gradientes acumulados dos parâmetros do modelo
outputs = bert_model(input_ids, attention_mask=attention_mask) # Saída do modelo
logits = outputs.logits # extração de pontuação antes da aplicação
loss = loss_fn(logits, targets)# Calculo de perda comparando os preditos('logits') com as classes reais ('targets)
loss.backward() # é calculado os gradientes em função do modelo
optimizer.step() # Usado para atualizar os parâmetros com base nos gradientes.
scheduler.step() # Atualize o scheduler a cada época
- Avaliação do Modelo
A avaliação do modelo é realizada no conjunto de teste após o treinamento. Foi definido uma função `evaluete_model` para avaliar o desempenho do modelo. Calculamos métricas de desempenho, como precisão, recall, F1-score e utilizamos uma matriz de confusão para avaliar a capacidade do modelo de realizar previsões precisas.
- Matriz confusão: é uma tabela que permite a visualização do desempenho de um algoritmo de classificação. Composta por quatro componentes:
- Verdadeiros Positivos (TP): Os casos em que o modelo previu corretamente a classe positiva.
- Verdadeiros Negativos (TN): Os casos em que o modelo previu corretamente a classe negativa.
- Falsos Positivos (FP): Os casos em que o modelo previu incorretamente a classe positiva.
- Falsos Negativos (FN): Os casos em que o modelo previu incorretamente a classe negativa.
Função de avaliação do modelo:
# Defina a função para avaliar o modelo
def evaluate_model(model, dataloader):
model.eval()
all_preds = []
all_targets = []
with torch.no_grad():
for input_ids, attention_mask, targets in dataloader:
outputs = model(input_ids, attention_mask=attention_mask)
logits = outputs.logits
preds = torch.argmax(logits, dim=1)
all_preds.extend(preds.cpu().numpy())
all_targets.extend(targets.cpu().numpy())
return np.array(all_preds), np.array(all_targets)
# Avaliação do modelo no conjunto de teste
eval_preds, eval_targets = evaluate_model(bert_model, test_dataloader)
Resultados e Insights
– Desempenho do modelo BERT
Ficou comprovado que o modelo é eficiente, alcançando uma taxa de 85% de acurácia e precisão na avaliação de treinamento, que ainda utilizando-se 2 epochs e 32 batch-sizes foi o máximo possível alcançado visando a falta de recursos e componentes. Realizando o cálculo médio, a cada epoch adicionada no modelo, o treinamento tem um aumento em torno de 40 a 50 minutos, isso utilizando uma GPU (Graphics Processing Unit) que é uma unidade de processamento gráfico disponível para aceleração das tarefas do modelo, mas ela é limitada, ou seja, depois de 2 treinamentos tivemos que utilizar uma CPU (Central Processing Unit) que é uma unidade de processamento mais lenta, o que elevou ainda mais o tempo de treinamento. Todos os testes foram realizados na plataforma Google Colab da Google.
- Matriz Confusão
O modelo tem facilidade para análisar sentimentos positivos. Podemos ver uma taxa significativa de Verdadeiros positivos e Verdadeiros Negativos. E poucos Falsos negativos e Falsos positivos, o que mostra que a acurácia do modelo foi significativamente boa.
Conclusão
Neste trabalho foi executado um projeto de uma deep learning com a arquitetura profunda de uma rede neural artificiais(BERT) com processamento de linguagem natural, com o foco na análise de sentimentos, e como isso está impactando na personalização e experiência do usuário. Todos os objetivos gerais e específicos propostos foram cumpridos. Com este modelo será possível extrair informações sobre a análise de sentimentos de diferentes fontes de textos, e utiliza-lo para aplicações do mundo real.
É Importante ressaltar que embora a análise de sentimentos ofereça valiosas percepções sobre a experiência do usuário, é imprescindível a ética e a transparência para se lidar com dados sensíveis de usuários mantendo a ética de trabalho contínua.
