junio 13, 2024

Cómo crear un modelo de análisis de sentimientos desde cero

El análisis de sentimientos es una técnica de procesamiento del lenguaje natural (PNL) que identifica la actitud detrás de un texto. También se conoce como minería de opinión. El objetivo del análisis de sentimiento es identificar si un texto en particular tiene un sentimiento positivo, negativo o neutral. Es ampliamente utilizado por las empresas para clasificar automáticamente el sentimiento en las reseñas de los clientes. El análisis de grandes volúmenes de reseñas ayuda a obtener información valiosa sobre las preferencias de los clientes.


Configuración del entorno

Debe estar familiarizado con los conceptos básicos de Python para seguir. Cambie a Google Colab o abra Jupyter Notebook. Luego crea un nuevo cuaderno. Ejecute el siguiente comando para instalar las bibliotecas necesarias en su entorno.

 ! pip install tensorflow scikit-learn pandas numpy pickle5

Utilizará la biblioteca NumPy y pandas para manipular el conjunto de datos. TensorFlow para construir y entrenar su modelo de aprendizaje automático. Scikit-learn para dividir el conjunto de datos en conjuntos de entrenamiento y prueba. Finalmente, utilizará pickle5 para seleccionar y guardar el objeto tokenizador.

Importación de bibliotecas necesarias

Importe las bibliotecas necesarias que usará para preprocesar los datos y construir el 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

Utilizará las clases importadas de los módulos más adelante en el código.

Cargando el conjunto de datos

Aquí, utilizará el conjunto de datos de Trip Advisor Hotel Reviews de Kaggle para crear el modelo de análisis de opinión.

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

Cargue el conjunto de datos e imprima las primeras cinco líneas. Imprimir las primeras cinco filas lo ayudará a verificar los nombres de las columnas en su conjunto de datos. Esto será fundamental durante el preprocesamiento del conjunto de datos.

Una salida que muestra las primeras cinco filas de un conjunto de datos

El conjunto de datos de Trip Advisor Hotel Reviews tiene una columna de índice, una columna de revisión y una columna de calificación.

Preprocesamiento de datos

Selecciona el Revisión Y Evaluación columnas del conjunto de datos. Cree una nueva columna basada en la columna Calificación y asígnele un nombre sentimiento. Si la calificación es superior a 3, etiquete el sentimiento como positivo. Si la calificación es inferior a 3, etiquételo como negativo. Si la puntuación es exactamente 3, etiquétala como neutral.

Seleccione solo las columnas Revisión y Opinión del conjunto de datos. Baraje aleatoriamente las filas y restablezca el índice del marco de datos. El barajado y la restauración aseguran que los datos se distribuyan aleatoriamente, lo cual es necesario para una capacitación y prueba exitosas del 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)

Convertir el Revisión texto a una secuencia de enteros usando el tokenizador. Esto crea un diccionario de las palabras únicas en el texto de revisión y asigna cada palabra a un valor entero único. Utilizar el pad_secuencias Función Keras para garantizar que todas las secuencias de revisión tengan la misma duración.

 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')

Convierta las etiquetas de opinión en codificación One-hot.

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

La codificación one-hot representa datos categóricos en un formato que es más fácil de trabajar con sus modelos.

Dividir el conjunto de datos en conjuntos de entrenamiento y prueba

Use scikit-learn para dividir aleatoriamente el conjunto de datos en conjuntos de entrenamiento y prueba. Utilizará el conjunto de entrenamiento para entrenar el modelo para clasificar los sentimientos de revisión. Y usará el conjunto de prueba para verificar qué tan bueno es el modelo para clasificar nuevas reseñas no vistas.

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

El tamaño de división del conjunto de datos es 0,2. Esto significa que el 80% de los datos entrenarán el modelo. Y el 20% restante pondrá a prueba el rendimiento del modelo.

Creación de la red neuronal

Cree una red neuronal con seis capas.

 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()

La primera capa de la red neuronal es una capa de incrustación. Este nivel aprende una representación densa de palabras en el vocabulario. La segunda capa es una capa Conv1D con 64 filtros y un tamaño de kernel de 5. Esta capa realiza operaciones de convolución en las secuencias de entrada, utilizando una pequeña ventana deslizante de tamaño 5.

La tercera capa reduce la secuencia de mapas de características a un solo vector. Toma el valor máximo en cada mapa de características. La cuarta capa realiza una transformación lineal en el vector de entrada. El quinto nivel establece aleatoriamente una fracción de las unidades de entrada en 0 durante el entrenamiento. Esto ayuda a prevenir el sobreajuste. El nivel final convierte la salida en una distribución de probabilidad en tres clases posibles: positiva, neutra y negativa.

Entrenamiento de la red neuronal

Ajuste los conjuntos de entrenamiento y prueba al modelo. Entrena el modelo durante diez épocas. Puede cambiar el número de épocas a su gusto.

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

Después de cada época, se evalúa el rendimiento del modelo en el conjunto de prueba.

Evaluación del desempeño del modelo entrenado

Utilizar el modelo.predecir() método para predecir etiquetas de sentimiento para el conjunto de prueba. Calcule la puntuación de precisión usando el puntuación_precisión() función de scikit-learn.

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

La precisión de este modelo es de aproximadamente 84%.

Guardando el modelo

Guarde el modelo usando el archivo modelo.guardar() método. Use pickle para decapar y guardar el objeto tokenizador.

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

El objeto tokenizador tokenizará su texto de entrada y lo preparará para alimentar al modelo entrenado.

Usando el modelo para clasificar el sentimiento de su texto

Una vez que haya creado y guardado la plantilla, puede usarla para categorizar el sentimiento de su texto. Primero, cargue su plantilla y tokenizador guardados.

 
import keras

model = keras.models.load_model('sentiment_analysis_model.h5')
with open('tokenizer.pickle', 'rb') as handle:
    tokenizer = pickle.load(handle)

Defina una función para predecir el sentimiento del texto de entrada.

 def predict_sentiment(text):
    
    text_sequence = tokenizer.texts_to_sequences([text])
    text_sequence = pad_sequences(text_sequence, maxlen=100)

    
    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, prediga su 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)

El sentimiento esperado de la revisión anterior es el siguiente:

Resultado de un modelo de análisis de sentimientos en Google Colab

El modelo es capaz de categorizar correctamente los sentimientos de las tres reseñas.

Predecir sentimientos usando modelos pre-entrenados

A veces, en el aprendizaje automático, puede enfrentar el desafío de encontrar el conjunto de datos correcto. Es posible que ni siquiera tenga los recursos para crear su propio conjunto de datos. Aquí es donde entran en juego los modelos pre-entrenados. Debe saber cómo usar su API y dejar que ellos se encarguen del resto.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *