Python para NLP: Análisis de Sentimientos de Películas usando Deep Learning en Keras

Este es el artículo número 17 de mi serie de artículos sobre Python para PNL. En el último artículo, comenzamos nuestra discusión sobre el aprendizaje profundo para el procesamiento del lenguaje natural.

El artículo anterior se centró principalmente en las incrustaciones de palabras, donde vimos cómo las incrustaciones de palabras se pueden usar para convertir texto en un vector denso correspondiente, que posteriormente se puede usar como entrada para cualquier modelo de aprendizaje profundo. Realizamos tareas de clasificación básica mediante incrustaciones de palabras. Usamos un conjunto de datos personalizado que contenía 16 reseñas imaginarias sobre películas. Además, los algoritmos de clasificación se entrenaron y probaron con los mismos datos. Finalmente, solo usamos una red neuronal densamente conectada para probar nuestro algoritmo.

En este artículo, nos basaremos en los conceptos que estudiamos en el artículo anterior y veremos la clasificación con más detalle utilizando un conjunto de datos del mundo real. Utilizaremos tres tipos diferentes de redes neuronales profundas: red neuronal densamente conectada (red neuronal básica), red neuronal convolucional (CNN) y red de memoria a largo plazo a corto plazo (LSTM), que es una variante de las redes neuronales recurrentes . Además, veremos cómo evaluar el modelo de aprendizaje profundo sobre un dato totalmente invisible.

Nota : Este artículo utiliza la capa de incrustación de Keras y las incrustaciones de palabras GloVe para convertir texto a forma numérica. Es importante que ya comprenda estos conceptos. De lo contrario, debería leer mi artículo anterior y luego puede volver y continuar con este artículo.

El conjunto de datos

El conjunto de datos que se puede descargar desde este enlace de Kaggle .

Si descarga el conjunto de datos y extrae el archivo comprimido, verá un archivo CSV. El archivo contiene 50.000 registros y dos columnas: revisión y opinión. La columna de opinión contiene texto para la opinión y la columna de opinión contiene la opinión de la opinión. La columna de sentimiento puede tener dos valores, es decir, “positivo” y “negativo”, lo que hace que nuestro problema sea un problema de clasificación binaria.

Importación de bibliotecas necesarias

El siguiente script importa las bibliotecas necesarias:

import pandas as pd
import numpy as np
import re
import nltk
from nltk.corpus import stopwords

from numpy import array
from keras.preprocessing.text import one_hot
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers.core import Activation, Dropout, Dense
from keras.layers import Flatten
from keras.layers import GlobalMaxPooling1D
from keras.layers.embeddings import Embedding
from sklearn.model_selection import train_test_split
from keras.preprocessing.text import Tokenizer

Importar y analizar el conjunto de datos

Ahora importemos y analicemos nuestro conjunto de datos. Ejecute el siguiente script:

movie_reviews = pd.read_csv("E:DatasetsIMDB Dataset.csv")

movie_reviews.isnull().values.any()

movie_reviews.shape

En el script anterior, usamos el read_csv()método de la biblioteca de pandas para leer el archivo CSV que contiene nuestro conjunto de datos. En la siguiente línea, verificamos si el conjunto de datos contiene algún valor NULL o no. Finalmente, imprimimos la forma de nuestro conjunto de datos.

Imprimamos ahora las primeras 5 filas del conjunto de datos usando el head()método.

movie_reviews.head()

En la salida, verá el siguiente marco de datos:

Echemos ahora un vistazo a cualquiera de las revisiones para que tengamos una idea sobre el texto que vamos a procesar. Mira el siguiente guión.

movie_reviews["review"][3]

Debería ver la siguiente reseña:

"Basically there's a family where a little boy (Jake) thinks there's a zombie in his closet & his parents are fighting all the time.<br /><br />This movie is slower than a soap opera... and suddenly, Jake decides to become Rambo and kill the zombie.<br /><br />OK, first of all when you're going to make a film you must Decide if its a thriller or a drama! As a drama the movie is watchable. Parents are divorcing & arguing like in real life. And then we have Jake with his closet which totally ruins all the film! I expected to see a BOOGEYMAN similar movie, and instead i watched a drama with some meaningless thriller spots.<br /><br />3 out of 10 just for the well playing parents & descent dialogs. As for the shots with Jake: just ignore them."

Puede ver que nuestro texto contiene signos de puntuación, corchetes y también algunas etiquetas HTML. Preprocesaremos este texto en la siguiente sección.

Finalmente, veamos la distribución de sentimientos positivos y negativos en nuestro conjunto de datos.

import seaborn as sns

sns.countplot(x='sentiment', data=movie_reviews)

Salida:

A partir del resultado, está claro que el conjunto de datos contiene el mismo número de reseñas positivas y negativas

Preprocesamiento de datos

Vimos que nuestro conjunto de datos contenía signos de puntuación y etiquetas HTML. En esta sección definiremos una función que toma una cadena de texto como parámetro y luego realiza un preprocesamiento en la cadena para eliminar caracteres especiales y etiquetas HTML de la cadena. Finalmente, la cadena se devuelve a la función que llama. Mira el siguiente guión:

def preprocess_text(sen):
    # Removing html tags
    sentence = remove_tags(sen)

    # Remove punctuations and numbers
    sentence = re.sub('[^a-zA-Z]', ' ', sentence)

    # Single character removal
    sentence = re.sub(r"s+[a-zA-Z]s+", ' ', sentence)

    # Removing multiple spaces
    sentence = re.sub(r's+', ' ', sentence)

    return sentence

TAG_RE = re.compile(r'<[^>]+>')

def remove_tags(text):
    return TAG_RE.sub('', text)

En el preprocess_text()método, el primer paso es eliminar las etiquetas HTML. Para eliminar las etiquetas HTML, remove_tags()se ha definido la función. La remove_tagsfunción simplemente reemplaza cualquier cosa entre abrir y cerrar <>con un espacio vacío.

A continuación, en la preprocess_textfunción, se elimina todo excepto las letras mayúsculas y minúsculas en inglés, lo que da como resultado caracteres únicos que no tienen sentido. Por ejemplo, cuando quita el apóstrofo de la palabra “Mark’s”, el apóstrofe se reemplaza por un espacio vacío. Por lo tanto, nos quedamos con un solo carácter “s”.

A continuación, eliminamos todos los caracteres individuales y los reemplazamos por un espacio que crea múltiples espacios en nuestro texto. Finalmente, también eliminamos los múltiples espacios de nuestro texto.

A continuación, procesaremos previamente nuestras reseñas y las almacenaremos en una nueva lista como se muestra a continuación:

X = []
sentences = list(movie_reviews['review'])
for sen in sentences:
    X.append(preprocess_text(sen))

Veamos nuevamente la cuarta revisión:

X[3]

La salida se ve así:

'Basically there a family where little boy Jake thinks there a zombie in his closet his parents are fighting all the time This movie is slower than soap opera and suddenly Jake decides to become Rambo and kill the zombie OK first of all when you re going to make film you must Decide if its thriller or drama As drama the movie is watchable Parents are divorcing arguing like in real life And then we have Jake with his closet which totally ruins all the film expected to see BOOGEYMAN similar movie and instead watched drama with some meaningless thriller spots out of just for the well playing parents descent dialogs As for the shots with Jake just ignore them '

En el resultado, puede ver que se han eliminado las etiquetas HTML, los signos de puntuación y los números. Solo nos quedan los alfabetos.

A continuación, necesitamos convertir nuestras etiquetas en dígitos. Dado que solo tenemos dos etiquetas en la salida, es decir, “positivo” y “negativo”. Podemos simplemente convertirlos en números enteros reemplazando “positivo” con el dígito 1 y negativo con el dígito 0 como se muestra a continuación:

y = movie_reviews['sentiment']

y = np.array(list(map(lambda x: 1 if x=="positive" else 0, y)))

Finalmente, necesitamos dividir nuestro conjunto de datos en conjuntos de prueba y de tren. El conjunto de trenes se utilizará para entrenar nuestros modelos de aprendizaje profundo, mientras que el conjunto de pruebas se utilizará para evaluar qué tan bien funciona nuestro modelo.

Podemos usar el train_test_splitmétodo del sklearn.model.selectionmódulo, como se muestra a continuación:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)

El script anterior divide nuestros datos en un 80% para el conjunto de entrenamiento y un 20% para el conjunto de prueba.

Ahora escribamos el script para nuestra capa de incrustación. La capa de incrustación convierte nuestros datos textuales en datos numéricos y se utiliza como la primera capa para los modelos de aprendizaje profundo en Keras.

Preparación de la capa de incrustación

Como primer paso, usaremos la Tokenizerclase del keras.preprocessing.textmódulo para crear un diccionario de palabra a índice. En el diccionario de palabra a índice, cada palabra del corpus se usa como clave, mientras que el índice único correspondiente se usa como valor para la clave. Ejecute el siguiente script:

tokenizer = Tokenizer(num_words=5000)
tokenizer.fit_on_texts(X_train)

X_train = tokenizer.texts_to_sequences(X_train)
X_test = tokenizer.texts_to_sequences(X_test)

Si ve la X_trainvariable en el explorador de variables, verá que contiene 40.000 listas donde cada lista contiene números enteros. Cada lista corresponde realmente a cada oración del conjunto de entrenamiento. También notará que el tamaño de cada lista es diferente. Esto se debe a que las oraciones tienen diferentes longitudes.

Establecemos el tamaño máximo de cada lista en 100. Puede probar con un tamaño diferente. Las listas con un tamaño superior a 100 se truncarán a 100. Para las listas que tengan una longitud inferior a 100, agregaremos 0 al final de la lista hasta que alcance la longitud máxima. Este proceso se llama relleno.

El siguiente script encuentra el tamaño del vocabulario y luego realiza el relleno tanto en el tren como en el conjunto de prueba.

# Adding 1 because of reserved 0 index
vocab_size = len(tokenizer.word_index) + 1

maxlen = 100

X_train = pad_sequences(X_train, padding='post', maxlen=maxlen)
X_test = pad_sequences(X_test, padding='post', maxlen=maxlen)

Ahora, si ve el X_traino X_test, verá que todas las listas tienen la misma longitud, es decir, 100. Además, la vocabulary_sizevariable ahora contiene un valor 92547 lo que significa que nuestro corpus tiene 92547 palabras únicas.

Usaremos incrustaciones de GloVe para crear nuestra matriz de características. En el siguiente script cargamos las incrustaciones de palabras GloVe y creamos un diccionario que contendrá palabras como claves y su correspondiente lista incrustada como valores.

from numpy import array
from numpy import asarray
from numpy import zeros

embeddings_dictionary = dict()
glove_file = open('E:/Datasets/Word Embeddings/glove.6B.100d.txt', encoding="utf8")

for line in glove_file:
    records = line.split()
    word = records[0]
    vector_dimensions = asarray(records[1:], dtype="float32")
    embeddings_dictionary [word] = vector_dimensions
glove_file.close()

Finalmente, crearemos una matriz de incrustación donde cada número de fila corresponderá al índice de la palabra en el corpus. La matriz tendrá 100 columnas donde cada columna contendrá las incrustaciones de palabras GloVe para las palabras de nuestro corpus.

embedding_matrix = zeros((vocab_size, 100))
for word, index in tokenizer.word_index.items():
    embedding_vector = embeddings_dictionary.get(word)
    if embedding_vector is not None:
        embedding_matrix[index] = embedding_vector

Una vez que ejecute el script anterior, verá que embedding_matrixcontendrá 92547 filas (una para cada palabra en el corpus). Ahora estamos listos para crear nuestros modelos de aprendizaje profundo.

Clasificación de texto con una red neuronal simple

El primer modelo de aprendizaje profundo que vamos a desarrollar es una simple red neuronal profunda. Mira el siguiente guión:

model = Sequential()
embedding_layer = Embedding(vocab_size, 100, weights=[embedding_matrix], input_length=maxlen , trainable=False)
model.add(embedding_layer)

model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))

En el script de arriba, creamos un Sequential()modelo. A continuación, creamos nuestra capa de incrustación. La capa de incrustación tendrá una longitud de entrada de 100, la dimensión del vector de salida también será de 100. El tamaño del vocabulario será de 92547 palabras. Puesto que no estamos entrenando a nuestros propios incrustaciones y el uso de la incrustación de guante, nos propusimos trainablea Falsey en el weightsatributo pasamos nuestra propia matriz de incrustación.

Luego, la capa de incrustación se agrega a nuestro modelo. A continuación, dado que estamos conectando directamente nuestra capa de incrustación a la capa densamente conectada, aplanamos la capa de incrustación. Finalmente, agregamos una capa densa con sigmoidfunción de activación.

Para compilar nuestro modelo, usaremos el adamoptimizador, binary_crossentropycomo nuestra función de pérdida y accuracycomo métricas y luego imprimiremos el resumen de nuestro modelo:

model.compile(optimizer="adam", loss="binary_crossentropy", metrics=['acc'])

print(model.summary())

La salida se ve así:

Layer (type)                 Output Shape              Param #
=================================================================
embedding_1 (Embedding)      (None, 100, 100)          9254700
_________________________________________________________________
flatten_1 (Flatten)          (None, 10000)             0
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 10001
=================================================================
Total params: 9,264,701
Trainable params: 10,001
Non-trainable params: 9,254,700

Dado que hay 92547 palabras en nuestro corpus y cada palabra se representa como un vector de 100 dimensiones, el número de parámetros entrenables estará 92547x100en la capa de incrustación. En la capa de aplanamiento, simplemente multiplicamos filas y columnas. Finalmente, en la capa densa el número de parámetros es 10000 (de la capa de aplanamiento) y 1 para el parámetro de polarización, para un total de 10001.

Entrenemos ahora nuestro modelo:

history = model.fit(X_train, y_train, batch_size=128, epochs=6, verbose=1, validation_split=0.2)

En el scipt anterior, usamos el fitmétodo para entrenar nuestra red neuronal. Tenga en cuenta que estamos entrenando solo en nuestro tren. El validation_splitde 0,2 significa que el 20% de los datos de entrenamiento se utiliza para encontrar la precisión de entrenamiento del algoritmo.

Al final del entrenamiento, verá que la precisión del entrenamiento es de alrededor del 85,52%.

Para evaluar el rendimiento del modelo, simplemente podemos pasar el conjunto de prueba al evaluatemétodo de nuestro modelo.

score = model.evaluate(X_test, y_test, verbose=1)

Para comprobar la precisión y la pérdida de la prueba, ejecute el siguiente script:

print("Test Score:", score[0])
print("Test Accuracy:", score[1])

Una vez que ejecute el script anterior, verá que obtenemos una precisión de prueba del 74,68%. Nuestra precisión de entrenamiento fue del 85,52%. Esto significa que nuestro modelo se adapta demasiado al conjunto de entrenamiento. El sobreajuste ocurre cuando su modelo se desempeña mejor en el conjunto de entrenamiento que en el conjunto de prueba. Idealmente, la diferencia de rendimiento entre el entrenamiento y los conjuntos de prueba debería ser mínima.

Intentemos trazar las diferencias de pérdida y precisión para conjuntos de entrenamiento y prueba. Ejecute el siguiente script:

plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train','test'], loc="upper left")
plt.show()

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])

plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train','test'], loc="upper left")
plt.show()

Salida:

Puede ver claramente las diferencias de pérdida y precisión entre los conjuntos de entrenamiento y prueba.

Clasificación de texto con una red neuronal convolucional

La red neuronal convolucional es un tipo de red que se utiliza principalmente para la clasificación de datos 2D, como imágenes. Una red convolucional intenta encontrar características específicas en una imagen en la primera capa. En las siguientes capas, las características detectadas inicialmente se unen para formar características más grandes. De esta forma, se detecta toda la imagen.

Se ha descubierto que las redes neuronales convolucionales también funcionan bien con datos de texto. Aunque los datos de texto son unidimensionales, podemos usar redes neuronales convolucionales 1D para extraer características de nuestros datos. Para obtener más información sobre las redes neuronales convolucionales, consulte este artículo .

Creemos una red neuronal convolucional simple con 1 capa convolucional y 1 capa de agrupación. Recuerde, el código hasta la creación de la capa de incrustación seguirá siendo el mismo, ejecute el siguiente fragmento de código después de crear la capa de incrustación:

model = Sequential()

embedding_layer = Embedding(vocab_size, 100, weights=[embedding_matrix], input_length=maxlen , trainable=False)
model.add(embedding_layer)

model.add(Conv1D(128, 5, activation='relu'))
model.add(GlobalMaxPooling1D())
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer="adam", loss="binary_crossentropy", metrics=['acc'])

En el script anterior creamos un modelo secuencial, seguido de una capa de incrustación. Este paso es similar al que habíamos hecho antes. A continuación, creamos una capa convolucional unidimensional con 128 características o núcleos. El tamaño del kernel es 5 y la función de activación utilizada es sigmoid. A continuación, agregamos una capa de agrupación máxima global para reducir el tamaño de la entidad. Finalmente agregamos una capa densa con activación sigmoidea. El proceso de compilación es el mismo que en la sección anterior.

Veamos ahora el resumen de nuestro modelo:

print(model.summary())

_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
embedding_2 (Embedding)      (None, 100, 100)          9254700
_________________________________________________________________
conv1d_1 (Conv1D)            (None, 96, 128)           64128
_________________________________________________________________
global_max_pooling1d_1 (Glob (None, 128)               0
_________________________________________________________________
dense_2 (Dense)              (None, 1)                 129
=================================================================
Total params: 9,318,957
Trainable params: 64,257
Non-trainable params: 9,254,700

Puede ver que en el caso anterior no necesitamos aplanar nuestra capa de incrustación. También puede notar que el tamaño de la entidad ahora se reduce usando la capa de agrupación.

Entrenemos ahora nuestro modelo y evaluémoslo en el conjunto de entrenamiento. El proceso para entrenar y probar nuestro modelo sigue siendo el mismo. Para hacerlo, podemos usar los métodos fity evaluate, respectivamente.

history = model.fit(X_train, y_train, batch_size=128, epochs=6, verbose=1, validation_split=0.2)

score = model.evaluate(X_test, y_test, verbose=1)

El siguiente script imprime los resultados:

print("Test Score:", score[0])
print("Test Accuracy:", score[1])

Si compara la precisión del entrenamiento y la prueba, verá que la precisión del entrenamiento para CNN será de alrededor del 92%, que es mayor que la precisión del entrenamiento de la red neuronal simple. La precisión de la prueba es de alrededor del 82% para la CNN, que también es mayor que la precisión de la prueba para la red neuronal simple, que fue de alrededor del 74%.

Sin embargo, nuestro modelo de CNN todavía está sobreajustado, ya que existe una gran diferencia entre la precisión del entrenamiento y la prueba. Tracemos la pérdida y la diferencia de precisión entre el entrenamiento y el conjunto de prueba.

import matplotlib.pyplot as plt

plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])

plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train','test'], loc="upper left")
plt.show()

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])

plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train','test'], loc="upper left")
plt.show()

Salida:

Puede ver claramente las diferencias de pérdida y precisión entre el tren y los equipos de prueba.

Entrenemos ahora nuestro tercer modelo de aprendizaje profundo, que es una red neuronal recurrente, y veamos si podemos deshacernos del sobreajuste.

Clasificación de texto con red neuronal recurrente (LSTM)

La red neuronal recurrente es un tipo de red neuronal que se ha demostrado que funciona bien con datos de secuencia. Dado que el texto es en realidad una secuencia de palabras, una red neuronal recurrente es una opción automática para resolver problemas relacionados con el texto. En esta sección, utilizaremos una LSTM (Red de memoria a largo plazo a corto plazo), que es una variante de RNN, para resolver el problema de clasificación de sentimientos.

Una vez más, ejecute el código hasta la sección de incrustación de palabras y luego ejecute el siguiente fragmento de código.

model = Sequential()
embedding_layer = Embedding(vocab_size, 100, weights=[embedding_matrix], input_length=maxlen , trainable=False)
model.add(embedding_layer)
model.add(LSTM(128))

model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer="adam", loss="binary_crossentropy", metrics=['acc'])

En el script anterior, comenzamos inicializando un modelo secuencial seguido de la creación de la capa de incrustación. A continuación, creamos una capa LSTM con 128 neuronas (puedes jugar con la cantidad de neuronas). El resto del código es el mismo que para la CNN.

Tracemos el resumen de nuestro modelo.

print(model.summary())

El resumen del modelo se ve así:

_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
embedding_3 (Embedding)      (None, 100, 100)          9254700
_________________________________________________________________
lstm_1 (LSTM)                (None, 128)               117248
_________________________________________________________________
dense_3 (Dense)              (None, 1)                 129
=================================================================
Total params: 9,372,077
Trainable params: 117,377
Non-trainable params: 9,254,700

Nuestro siguiente paso es entrenar el modelo en el conjunto de entrenamiento y evaluar su desempeño en el conjunto de prueba.

history = model.fit(X_train, y_train, batch_size=128, epochs=6, verbose=1, validation_split=0.2)

score = model.evaluate(X_test, y_test, verbose=1)

El script anterior entrena el modelo en el conjunto de prueba. El tamaño del lote es 128, mientras que el número de épocas es 6. Al final del entrenamiento, verá que la precisión del entrenamiento es de alrededor del 85,40%.

Una vez que se entrena el modelo, podemos ver los resultados del modelo en el conjunto de prueba con el siguiente script:

print("Test Score:", score[0])
print("Test Accuracy:", score[1])

En el resultado, verá que la precisión de nuestra prueba es de alrededor del 85,04%. La precisión de la prueba es mejor que la CNN y la red neuronal densamente conectada. Además, podemos ver que hay una diferencia muy pequeña entre la precisión del entrenamiento y la precisión de la prueba, lo que significa que nuestro modelo no está sobreajustado.

Tracemos las diferencias de pérdida y precisión entre los conjuntos de entrenamiento y de prueba.

import matplotlib.pyplot as plt

plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])

plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train','test'], loc="upper left")
plt.show()

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])

plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train','test'], loc="upper left")
plt.show()

Salida:

El resultado muestra que la diferencia entre los valores de precisión para los conjuntos de entrenamiento y prueba es mucho menor en comparación con la red neuronal simple y la CNN. Del mismo modo, la diferencia entre los valores de pérdida también es insignificante, lo que demuestra que nuestro modelo no está sobreajustado. Podemos concluir que para nuestro problema, RNN es el mejor algoritmo.

En este artículo, elegimos aleatoriamente el número de capas, neuronas, hiperparámetros, etc. Le sugiero que intente cambiar el número de capas, el número de neuronas y las funciones de activación para las tres redes neuronales discutidas en este artículo y ver cuál La red neuronal funciona mejor para ti.

Hacer predicciones en una sola instancia

Esta es la sección final del artículo y aquí veremos cómo hacer predicciones en una sola instancia o sentimiento. Recuperemos cualquier reseña de nuestro corpus y luego intentemos predecir su opinión.

Primero seleccionemos aleatoriamente cualquier revisión de nuestro corpus:

instance = X[57]
print(instance)

Salida:

I laughed all the way through this rotten movie It so unbelievable woman leaves her husband after many years of marriage has breakdown in front of real estate office What happens The office manager comes outside and offers her job Hilarious Next thing you know the two women are going at it Yep they re lesbians Nothing rings true in this Lifetime for Women with nothing better to do movie Clunky dialogue like don want to spend the rest of my life feeling like had chance to be happy and didn take it doesn help There a wealthy distant mother who disapproves of her daughter new relationship sassy black maid unbelievable that in the year film gets made in which there a sassy black maid Hattie McDaniel must be turning in her grave The woman has husband who freaks out and wants custody of the snotty teenage kids Sheesh No cliche is left unturned

Puede ver claramente que esta es una revisión negativa. Para predecir el sentimiento de esta revisión, tenemos que convertir esta revisión en forma numérica. Podemos hacerlo usando el tokenizerque creamos en la sección de incrustación de palabras. El text_to_sequencesmétodo convertirá la oración en su contraparte numérica.

A continuación, necesitamos rellenar nuestra secuencia de entrada como hicimos con nuestro corpus. Finalmente, podemos usar el predictmétodo de nuestro modelo y pasarle nuestra secuencia de entrada procesada. Mira el siguiente código:

instance = tokenizer.texts_to_sequences(instance)

flat_list = []
for sublist in instance:
    for item in sublist:
        flat_list.append(item)

flat_list = [flat_list]

instance = pad_sequences(flat_list, padding='post', maxlen=maxlen)

model.predict(instance)

La salida se ve así:

array([[0.3304276]], dtype=float32)

Recuerde, asignamos las salidas positivas a 1 y las salidas negativas a 0. Sin embargo, la función sigmoidea predice un valor flotante entre 0 y 1. Si el valor es menor que 0.5, el sentimiento se considera negativo donde como si el valor fuera mayor que 0,5, el sentimiento se considera positivo. El valor de sentimiento para nuestra instancia única es 0.33, lo que significa que nuestro sentimiento se predice como negativo, que en realidad es el caso.

Conclusión

La clasificación de texto es una de las tareas de procesamiento del lenguaje natural más comunes. En este artículo vimos cómo realizar un análisis de sentimientos, que es un tipo de clasificación de texto que utiliza la biblioteca de aprendizaje profundo de Keras. Usamos tres tipos diferentes de redes neuronales para clasificar la opinión pública sobre diferentes películas. Los resultados muestran que LSTM, que es una variante de RNN, supera tanto a la CNN como a la red neuronal simple.