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

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 tem um 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 informações valiosas sobre as preferências dos clientes.

Configurando seu ambiente

Você precisa estar familiarizado com Noções básicas de Python para seguir. Navegar para Google Colab ou abra o Jupyter Notebook. Em seguida, crie um novo bloco de anotações. Execute o seguinte comando para instalar as bibliotecas necessárias em seu ambiente.

O código-fonte completo deste projeto está disponível neste Repositório GitHub.

! pip instalar tensorflow scikit-learn pandas numpy pickle5

Você usará NumPy e biblioteca 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. Por fim, você usará pickle5 para serializar e salvar o objeto tokenizador.

Importando as bibliotecas necessárias

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

importar entorpecido como np
importar pandas como pd
importar tensorflow como tf
de sklearn.model_selection importar train_test_split
de sklearn.metrics importar exatidão_pontuação
de tensorflow.keras.preprocessing.text importar Tokenizador
de tensorflow.keras.preprocessing.sequence importar pad_sequences
de tensorflow.keras.models importar Sequencial
de tensorflow.keras.layers importar Incorporação, Conv1D, GlobalMaxPooling1D, Denso, Dropout
importar pickle5 como salmoura

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

Carregando o conjunto de dados

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

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

Carregue o conjunto de dados e imprima suas cinco primeiras 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 do 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 os Análise e Avaliação colunas do conjunto de dados. Crie uma nova coluna com base na coluna Classificação e nomeie-a sentimento. Se a classificação for maior que 3, rotule o sentimento como positivo. Se a classificação for inferior a 3, rotule-a como negativo. Se a classificação for exatamente 3, rotule-a como neutro.

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[['Análise', 'Avaliação']]
df['sentimento'] = df['Avaliação'].aplicar(lambda x: 'positivo'se x > 3
outro'negativo'se x < 3
outro'neutro')
df = df[['Análise', 'sentimento']]
df = df.sample (frac=1).reset_index (drop=Verdadeiro)

Converter o Análise text em uma sequência de inteiros usando o tokenizador. Isso cria um dicionário de palavras exclusivas presentes no texto da revisão e mapeia cada palavra para um valor inteiro exclusivo. Use o pad_sequences função de Keras para garantir que todas as sequências de revisão tenham o mesmo comprimento.

tokenizador = tokenizador (num_palavras=5000, oov_token='')
tokenizer.fit_on_texts (df['Análise'])
word_index = tokenizer.word_index
sequências = tokenizer.texts_to_sequences (df['Análise'])
padded_sequences = pad_sequences (sequências, maxlen=100, truncando='publicar')

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

sentiment_labels = pd.get_dummies (df['sentimento']).valores

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 revisõ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

Criar uma rede neural com seis camadas.

modelo = Sequencial()
model.add (Incorporação(5000, 100, input_length=100))
model.add (Conv1D(64, 5, ativação='relu'))
model.add (GlobalMaxPooling1D())
model.add (Dense(32, ativação='relu'))
model.add (Desistir(0.5))
model.add (Dense(3, ativação='softmax'))
model.compile (otimizador='Adão', perda ='categorical_crossentropy', métricas=['precisão'])
modelo.resumo()

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 um tamanho de kernel de 5. Essa camada executa 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. Leva o valor máximo sobre cada mapa de recursos. A quarta camada executa uma transformação linear no vetor de entrada. A quinta camada define aleatoriamente uma fração das unidades de entrada para 0 durante o treinamento. Isso ajuda a evitar o overfitting. 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, épocas=10, batch_size=32, validação_dados=(x_teste, y_teste))

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

Avaliando o Desempenho do Modelo Treinado

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

y_pred = np.argmax (model.predict (x_test), axis=-1)
imprimir("Precisão:", 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 model.save() método. Use pickle para serializar e salvar o objeto tokenizador.

modelo.salvar('sentiment_analysis_model.h5')
com abrir('tokenizer.pickle', 'wb') como lidar:
 pickle.dump (tokenizer, handle, protocol=pickle. HIGHEST_PROTOCOL)

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

Usando o modelo para classificar o sentimento de 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 e tokenizador salvos.

# Carregue o model e o tokenizer salvos
importar keras
modelo = keras.models.load_model('sentiment_analysis_model.h5')
com abrir('tokenizer.pickle', 'rb') como lidar:
 tokenizer = pickle.load (manipulador)

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

defprever_sentiment(texto):
# Tokenize e preencha o texto de entrada
 text_sequence = tokenizer.texts_to_sequences([texto])
 text_sequence = pad_sequences (text_sequence, maxlen=100)
# Faça uma previsão usando o modelo treinado
 predict_rating = model.predict (text_sequence)[0]
se np.argmax (predicted_rating) == 0:
retornar'Negativo'
elif np.argmax (predicted_rating) == 1:
retornar'Neutro'
outro:
retornar'Positivo'

Por fim, preveja seu próprio texto.

text_input = "Adorei a minha estadia neste hotel. A equipe foi incrível e o quarto foi fantástico!"
predict_sentiment = predict_sentiment (text_input)
imprimir (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.

Prevendo sentimentos usando modelos pré-treinados

Às vezes, no aprendizado de máquina, você pode ter o desafio de encontrar o conjunto de dados correto. 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 a API deles e deixar que eles cuidem do resto.