Cómo crear un modelo de análisis de sentimiento 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 determinado texto 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 de su entorno

Necesitas estar familiarizado con Conceptos básicos de Python seguir adelante. Navegar a Colaboración de Google o abra Jupyter Notebook. Luego crea un nuevo cuaderno. Ejecute el siguiente comando para instalar las bibliotecas necesarias en su entorno.

El código fuente completo de este proyecto está disponible en este repositorio GitHub.

! pip instalar tensorflow scikit-learn pandas numpy pickle5

Usarás NumPy y biblioteca pandas para manipular el conjunto de datos. TensorFlow para crear y entrenar el modelo de aprendizaje automático. Scikit-learn para dividir el conjunto de datos en conjuntos de entrenamiento y prueba. Finalmente, utilizará pickle5 para serializar y guardar el objeto tokenizador.

Importación de las bibliotecas requeridas

Importe las bibliotecas necesarias que usará para preprocesar los datos y crear el modelo.

importar entumecido como notario público
importar pandas como p.d.
importar tensorflow como t.f.
de sklearn.modelo_selección importar tren_prueba_dividir
de sklearn.metrics importar precisión_puntuación
de tensorflow.keras.preprocesamiento.texto importar Tokenizador
de tensorflow.keras.preprocessing.sequence importar pad_secuencias
de tensorflow.keras.modelos importar Secuencial
de tensorflow.keras.layers importar Incrustación, Conv1D, GlobalMaxPooling1D, Dense, Dropout
importar pepinillo5 como pepinillo

Utilizará las clases que importe 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 construir el modelo de análisis de sentimientos.

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

Cargue el conjunto de datos e imprima sus primeras cinco filas. Imprimir las primeras cinco filas lo ayudará a verificar los nombres de las columnas de su conjunto de datos. Esto será crucial al preprocesar el 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 Revisar y Clasificació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 calificación es exactamente 3, etiquétala como neutral.

Seleccione solo las columnas Opinión y opinión del conjunto de datos. Baraja las filas al azar y restablece el índice del marco de datos. La mezcla y el restablecimiento garantizan que los datos se distribuyan aleatoriamente, lo cual es necesario para el entrenamiento y la prueba adecuados del modelo.

df = df[['Revisar', 'Clasificación']]
df['sentimiento'] = df['Clasificación'].aplicar(lambda X: 'positivo'si X > 3
demás'negativo'si X < 3
demás'neutral')
df = df[['Revisar', 'sentimiento']]
df = df.muestra (frac=1).reset_index (soltar=Verdadero)

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

tokenizador = tokenizador (num_words=5000, oov_token='')
tokenizer.fit_on_texts (df['Revisar'])
índice_palabra = tokenizador.índice_palabra
secuencias = tokenizer.texts_to_sequences (df['Revisar'])
padded_sequences = pad_sequences (secuencias, maxlen=100, truncando='correo')

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

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

La codificación one-hot representa datos categóricos en un formato con el que es más fácil trabajar para 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 las reseñas. Y usará el conjunto de prueba para conocer qué tan bueno es el modelo para clasificar nuevas reseñas no vistas.

x_train, x_test, y_train, y_test = train_test_split (secuencias_rellenadas, etiquetas_de_sentimiento, tamaño_de_prueba=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

Crear un red neuronal con seis capas.

modelo = Secuencial()
model.add (Incrustación (5000, 100, entrada_longitud=100))
modelo.add (Conv1D(64, 5, activación='relú'))
modelo.añadir (GlobalMaxPooling1D())
modelo.add (Denso(32, activación='relú'))
model.add (Abandono(0.5))
modelo.add (Denso(3, activación='softmax'))
model.compile (optimizador='Adán', pérdida='categorical_crossentropy', métricas=['exactitud'])
Resumen Modelo()

La primera capa de la red neuronal es una capa de incrustación. Esta capa 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 sobre cada mapa de características. La cuarta capa realiza una transformación lineal en el vector de entrada. La quinta capa establece aleatoriamente una fracción de las unidades de entrada en 0 durante el entrenamiento. Esto ayuda a prevenir el sobreajuste. La capa final convierte la salida en una distribución de probabilidad sobre las 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_tren, y_tren, épocas=10, lote_tamaño=32, validación_datos=(x_prueba, y_prueba))

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

Evaluación del rendimiento del modelo entrenado

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

y_pred = np.argmax (modelo.predecir (x_test), eje=-1)
imprimir("Exactitud:", precision_score (np.argmax (y_test, axis=-1), y_pred))

La precisión de este modelo es de alrededor del 84%.

Guardar el modelo

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

modelo.guardar('análisis_de_sentimientos_modelo.h5')
con abierto('tokenizer.pickle', 'wb') como manejar:
 pickle.dump (tokenizer, handle, protocol=pickle. PROTOCOLO_MÁS ALTO)

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

Usando el modelo para clasificar el sentimiento de su propio texto

Después de crear y guardar el modelo, puede usarlo para clasificar el sentimiento de su propio texto. Primero, cargue el modelo guardado y el tokenizador.

# Cargue el modelo guardado y el tokenizador
importar queras
modelo = keras.modelos.load_model('análisis_de_sentimientos_modelo.h5')
con abierto('tokenizer.pickle', 'rb') como manejar:
 tokenizador = pickle.load (manejador)

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

definitivamentepredecir_sentimiento(texto):
# Tokenizar y rellenar el texto de entrada
 text_sequence = tokenizer.texts_to_sequences([texto])
 text_sequence = pad_sequences (text_sequence, maxlen=100)
# Haz una predicción usando el modelo entrenado
 calificación_predicha = modelo.predecir (secuencia_texto)[0]
si np.argmax (predicted_rating) == 0:
devolver'Negativo'
elif np.argmax (predicted_rating) == 1:
devolver'Neutral'
demás:
devolver'Positivo'

Finalmente, prediga su propio texto.

entrada_de_texto = "Me encantó mi estadía en ese hotel. El personal fue increíble y la habitación era fantástica!"
sentimiento_predicho = sentimiento_predecible (entrada_de_texto)
imprimir (predicted_sentiment)

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

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

Predicción de sentimientos utilizando modelos previamente entrenados

A veces, en el aprendizaje automático, puede tener el desafío de encontrar el conjunto de datos correcto. Es posible que también le falten los recursos para crear su propio conjunto de datos. Aquí es donde entran los modelos pre-entrenados. Tienes que saber cómo usar su API y dejar que ellos se encarguen del resto.