Breaking

Post Top Ad

Your Ad Spot

jueves, 8 de agosto de 2019

Python para PNL: Análisis del sentimiento de la película usando Deep Learning en Keras

Este es el artículo 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 se pueden usar las incrustaciones de palabras para convertir texto en un vector denso correspondiente, que posteriormente se puede usar como entrada para cualquier modelo de aprendizaje profundo. Realizamos tareas básicas de clasificación utilizando incrustaciones de palabras. Utilizamos un conjunto de datos personalizado que contenía 16 revisiones imaginarias sobre películas. Además, los algoritmos de clasificación fueron entrenados y probados con los mismos datos. Finalmente, solo usamos una red neuronal densamente conectada para probar nuestro algoritmo.
En este artículo, desarrollaremos 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 corto plazo (LSTM), que es una variante de las redes neuronales recurrentes . Además, veremos cómo evaluar el modelo de aprendizaje profundo en datos totalmente invisibles.
Nota : Este artículo utiliza la capa de incrustación Keras y las incrustaciones de palabras GloVe para convertir texto en forma numérica. Es importante que ya comprenda estos conceptos. De lo contrario, deberías leer mi artículo anterior y luego puedes 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 revisión contiene texto para la revisión y la columna de opinión contiene el sentimiento para la revisión. La columna de opinión puede tener dos valores, es decir, "positivo" y "negativo", lo que hace que nuestro problema sea un problema de clasificación binaria.

Importar bibliotecas requeridas

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:\Datasets\IMDB Dataset.csv")

movie_reviews.isnull().values.any()

movie_reviews.shape
En el script anterior, utilizamos 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 NULO 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:
cabeza
Ahora echemos un vistazo a cualquiera de las revisiones para tener una idea sobre el texto que vamos a procesar. Mira el siguiente script.
movie_reviews["review"][3]
Debería ver la siguiente revisión:
"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 algunas etiquetas HTML también. 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:
distribución_entimiento
A partir de la salida, está claro que el conjunto de datos contiene el mismo número de críticas 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 de llamada. Mira el siguiente script:
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 elimina el apóstrofe de la palabra "Mark", el apóstrofe se reemplaza por un espacio vacío. Por lo tanto, nos quedamos con un solo carácter "s".
A continuación, reescribimos todos los caracteres individuales y los reemplazamos por un espacio que crea múltiples espacios en nuestro texto. Finalmente, también eliminamos los espacios múltiples de nuestro texto.
A continuación, procesaremos previamente nuestras revisiones 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))
Ahora veamos nuevamente la cuarta revisión:
X[3]
El resultado 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 '
Desde el resultado, puede ver que las etiquetas HTML, los signos de puntuación y los números se han eliminado. Solo nos quedan los alfabetos.
A continuación, debemos convertir nuestras etiquetas en dígitos. Dado que solo tenemos dos etiquetas en la salida, es decir, "positivo" y "negativo". Simplemente podemos convertirlos en 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 trenes y conjuntos de pruebas. El conjunto de entrenamiento se usará para entrenar nuestros modelos de aprendizaje profundo, mientras que el conjunto de prueba se usará 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 80% para el conjunto de entrenamiento y 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, utilizaremos la Tokenizerclase del keras.preprocessing.textmódulo para crear un diccionario de palabra a índice. En el diccionario de palabra a índice, cada palabra en el corpus se usa como una clave, mientras que un índice único correspondiente se usa como el valor de 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 enteros. Cada lista corresponde en realidad a cada oración en el 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 un tamaño diferente. Las listas con un tamaño superior a 100 se truncarán a 100. Para las listas que tienen 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_trainX_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.
Utilizaremos las incrustaciones 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 lista de incrustación correspondiente 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 en 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 red neuronal simple

El primer modelo de aprendizaje profundo que vamos a desarrollar es una red neuronal profunda simple. Mira el siguiente script:
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 guión anterior, 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 trainableFalsey en el weightsatributo pasamos nuestra propia matriz de incrustación.
La capa de incrustación se agrega a nuestro modelo. Luego, como estamos conectando directamente nuestra capa de incrustación a una capa densamente conectada, aplanamos la capa de incrustación. Finalmente, agregamos una capa densa con sigmoidfunción de activación.
Para compilar nuestro modelo, utilizaremos el adamoptimizador, binary_crossentropycomo nuestra función de pérdida y accuracycomo métrica, y luego imprimiremos el resumen de nuestro modelo:
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])

print(model.summary())
El resultado 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
Como 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 inclusió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.
Ahora entrenemos a nuestro modelo:
history = model.fit(X_train, y_train, batch_size=128, epochs=6, verbose=1, validation_split=0.2)
En el texto anterior, usamos el fitmétodo para entrenar nuestra red neuronal. Tenga en cuenta que solo estamos entrenando en nuestro conjunto de trenes. El valor validation_split0.2 significa que el 20% de los datos de entrenamiento se utilizan 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 pruebas al evaluatemétodo de nuestro modelo.
score = model.evaluate(X_test, y_test, verbose=1)
Para verificar la precisión y 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 está sobreajustado en el conjunto de entrenamiento. El sobreajuste ocurre cuando su modelo funciona mejor en el conjunto de entrenamiento que el conjunto de prueba. Idealmente, la diferencia de rendimiento entre los conjuntos de entrenamiento y prueba debería ser mínima.
Tratemos de trazar las diferencias de pérdida y precisión para los 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:
img1
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 las 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 manera, 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 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 a lo que habíamos hecho antes. A continuación, creamos una capa convolucional unidimensional con 128 características o núcleos. El tamaño del núcleo es 5 y la función de activación utilizada es sigmoidA 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 signmoide. 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 característica ahora se reduce utilizando la capa de agrupación.
Ahora entrenemos 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 fitevaluate, 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 CNN sigue siendo demasiado adecuado, ya que existe una gran diferencia entre el entrenamiento y la precisión de la prueba. Tracemos la pérdida y la diferencia de precisión entre el conjunto de entrenamiento y 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:
img2
Puede ver claramente las diferencias de pérdida y precisión entre el tren y los conjuntos de prueba.
Ahora entrenemos 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 redes neuronales 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 corto y largo 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 (puede jugar con varias 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 al 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 pruebas con el siguiente script:
print("Test Score:", score[0])
print("Test Accuracy:", score[1])
En la salida, verá que nuestra precisión de 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 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:
img3
El resultado muestra que la diferencia entre los valores de precisión para el entrenamiento y los conjuntos de pruebas 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 al azar el número de capas, neuronas, hiperparámetros, etc. Sugeriría que intente cambiar el número de capas, el número de neuronas y las funciones de activación para las tres redes neuronales que se analizan en este artículo y ver qué La red neuronal funciona mejor para usted.

Hacer predicciones en instancia única

Esta es la sección final del artículo y aquí veremos cómo hacer predicciones en una sola instancia o en un solo sentimiento. Recuperemos cualquier revisión de nuestro corpus y luego intentemos predecir su sentimiento.
Primero, seleccione randmoly 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 crítica 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.
Luego, necesitamos rellenar nuestra secuencia de entrada como lo hicimos para 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)
El resultado 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 sigmoide 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 del 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 de lenguaje natural más comunes. En este artículo vimos cómo realizar análisis de sentimientos, que es un tipo de clasificación de texto usando la biblioteca de aprendizaje profundo Keras. Utilizamos tres tipos diferentes de redes neuronales para clasificar el sentimiento público sobre diferentes películas. Los resultados muestran que LSTM, que es una variante de RNN, supera a CNN y a la red neuronal simple.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas