Como criar um modelo de análise de sentimento do zero

Construir seu próprio modelo de análise de sentimento pode parecer assustador. Este guia orienta você nas etapas para começar.

A análise de sentimento é uma técnica de processamento de linguagem natural (PNL) que identifica a atitude por trás de um texto. Também é conhecido como mineração de opinião. O objetivo da análise de sentimento é identificar se um determinado texto possui sentimento positivo, negativo ou neutro. É amplamente utilizado por empresas para classificar automaticamente o sentimento nas avaliações dos clientes. A análise de grandes volumes de avaliações ajuda a obter insights valiosos sobre as preferências dos clientes.

Configurando seu ambiente

Você precisa estar familiarizado com os fundamentos do Python para prosseguir. Navegue até o Google Colab ou abra o Jupyter Notebook. Em seguida, crie um novo bloco de notas. Execute o comando a seguir para instalar as bibliotecas necessárias em seu ambiente.

! pip install tensorflow scikit-learn pandas numpy pickle5

Você usará a biblioteca NumPy e pandas para manipular o conjunto de dados. TensorFlow para criar e treinar o modelo de aprendizado de máquina. Scikit-learn para dividir o conjunto de dados em conjuntos de treinamento e teste. Finalmente, você usará pickle5 para serializar e salvar o objeto tokenizer.

Importando as bibliotecas necessárias

Importe as bibliotecas necessárias que você usará para pré-processar os dados e criar o modelo.

import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Conv1D, GlobalMaxPooling1D, Dense, Dropout
import pickle5 as pickle

Você usará as classes importadas dos módulos posteriormente no código.

Carregando o conjunto de dados

Aqui, você usará o conjunto de dados Trip Advisor Hotel Reviews do Kaggle para construir o modelo de análise de sentimento.

df = pd.read_csv('/content/tripadvisor_hotel_reviews.csv')
print(df.head())

Carregue o conjunto de dados e imprima suas primeiras cinco linhas. Imprimir as primeiras cinco linhas ajudará você a verificar os nomes das colunas do seu conjunto de dados. Isso será crucial ao pré-processar o conjunto de dados.

O conjunto de dados Trip Advisor Hotel Reviews tem uma coluna de índice, uma coluna de avaliação e uma coluna de classificação.

Pré-processamento de dados

Selecione as colunas Revisão e Classificação do conjunto de dados. Crie uma nova coluna com base na coluna Classificação e nomeie-a como sentimento. Se a classificação for superior a 3, rotule o sentimento como positivo. Se a classificação for inferior a 3, rotule-a como negativa. Se a classificação for exatamente 3, rotule-a como neutra.

Selecione apenas as colunas Revisão e sentimento do conjunto de dados. Embaralhe as linhas aleatoriamente e redefina o índice do quadro de dados. O embaralhamento e a redefinição garantem que os dados sejam distribuídos aleatoriamente, o que é necessário para o treinamento e teste adequados do modelo.

df = df[['Review', 'Rating']]
df['sentiment'] = df['Rating'].apply(lambda x: 'positive' if x > 3 
                                    else 'negative' if x < 3
                                    else 'neutral')
df = df[['Review', 'sentiment']]
df = df.sample(frac=1).reset_index(drop=True)

Converta o texto Review em uma sequência de números inteiros usando o tokenizer. Isso cria um dicionário de palavras exclusivas presentes no texto de revisão e mapeia cada palavra para um valor inteiro exclusivo. Use a função pad_sequences do Keras para garantir que todas as sequências de revisão tenham o mesmo comprimento.

tokenizer = Tokenizer(num_words=5000, oov_token='<OOV>')
tokenizer.fit_on_texts(df['Review'])
word_index = tokenizer.word_index
sequences = tokenizer.texts_to_sequences(df['Review'])
padded_sequences = pad_sequences(sequences, maxlen=100, truncating='post')

Converta os rótulos de sentimento em codificação One-hot.

sentiment_labels = pd.get_dummies(df['sentiment']).values

A codificação one-hot representa dados categóricos em um formato que é mais fácil para seus modelos trabalharem.

Dividindo o conjunto de dados em conjuntos de treinamento e teste

Use o scikit-learn para dividir aleatoriamente o conjunto de dados em conjuntos de treinamento e teste. Você usará o conjunto de treinamento para treinar o modelo para classificar os sentimentos das avaliações. E você usará o conjunto de testes para avaliar a qualidade do modelo na classificação de novas avaliações não vistas.

x_train, x_test, y_train, y_test = train_test_split(padded_sequences, sentiment_labels, test_size=0.2)

O tamanho da divisão do conjunto de dados é 0,2. Isso significa que 80% dos dados irão treinar o modelo. E os 20% restantes testarão o desempenho do modelo.

Criando a Rede Neural

Crie uma rede neural com seis camadas.

model = Sequential()
model.add(Embedding(5000, 100, input_length=100))
model.add(Conv1D(64, 5, activation='relu'))
model.add(GlobalMaxPooling1D())
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(3, activation='softmax'))
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.summary()

A primeira camada da rede neural é uma camada de incorporação. Esta camada aprende uma representação densa de palavras no vocabulário. A segunda camada é uma camada Conv1D com 64 filtros e tamanho de kernel 5. Esta camada realiza operações de convolução nas sequências de entrada, usando uma pequena janela deslizante de tamanho 5.

A terceira camada reduz a sequência de mapas de recursos a um único vetor. Assume o valor máximo em cada mapa de recursos. A quarta camada realiza uma transformação linear no vetor de entrada. A quinta camada define aleatoriamente uma fração das unidades de entrada como 0 durante o treinamento. Isso ajuda a evitar o sobreajuste. A camada final converte a saída em uma distribuição de probabilidade nas três classes possíveis: positiva, neutra e negativa.

Treinando a Rede Neural

Ajuste os conjuntos de treinamento e teste ao modelo. Treine o modelo por dez épocas. Você pode alterar o número de épocas ao seu gosto.

model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_test, y_test))

Após cada época, o desempenho do modelo no conjunto de testes é avaliado.

Avaliando o desempenho do modelo treinado

Use o método model.predict() para prever os rótulos de sentimento para o conjunto de teste. Calcule a pontuação de precisão usando a função accuracy_score() do scikit-learn.

y_pred = np.argmax(model.predict(x_test), axis=-1)
print("Accuracy:", accuracy_score(np.argmax(y_test, axis=-1), y_pred))

A precisão deste modelo é de cerca de 84%.

Salvando o modelo

Salve o modelo usando o método model.save(). Use pickle para serializar e salvar o objeto tokenizer.

model.save('sentiment_analysis_model.h5')
with open('tokenizer.pickle', 'wb') as handle:
    pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)

O objeto tokenizer irá tokenizar seu próprio texto de entrada e prepará-lo para alimentar o modelo treinado.

Usando o modelo para classificar o sentimento do seu próprio texto

Depois de criar e salvar o modelo, você pode usá-lo para classificar o sentimento do seu próprio texto. Primeiro, carregue o modelo salvo e o tokenizer.

# Load the saved model and tokenizer
import keras
model = keras.models.load_model('sentiment_analysis_model.h5')
with open('tokenizer.pickle', 'rb') as handle:
    tokenizer = pickle.load(handle)

Defina uma função para prever o sentimento do texto de entrada.

def predict_sentiment(text):
    # Tokenize and pad the input text
    text_sequence = tokenizer.texts_to_sequences([text])
    text_sequence = pad_sequences(text_sequence, maxlen=100)
    # Make a prediction using the trained model
    predicted_rating = model.predict(text_sequence)[0]
    if np.argmax(predicted_rating) == 0:
        return 'Negative'
    elif np.argmax(predicted_rating) == 1:
        return 'Neutral'
    else:
        return 'Positive'

Finalmente, preveja seu próprio texto.

text_input = "I absolutely loved my stay at that hotel. The staff was amazing and the room was fantastic!"
predicted_sentiment = predict_sentiment(text_input)
print(predicted_sentiment)

O sentimento previsto da revisão acima é o seguinte:

O modelo é capaz de classificar corretamente os sentimentos de todas as três avaliações.

Prever sentimentos usando modelos pré-treinados

Às vezes, no aprendizado de máquina, você pode enfrentar o desafio de encontrar o conjunto de dados certo. Você também pode não ter recursos para criar seu próprio conjunto de dados. É aqui que entram os modelos pré-treinados. Você tem que saber como usar sua API e deixar que eles cuidem do resto.