Cómo realizar análisis de sentimientos en Python 3 utilizando Natural Language Toolkit (NLTK)

El autor seleccionó el fondo Open Internet/Free Speech para recibir una donación como parte del programa Write for DOnations.

Introducción

Una gran cantidad de datos que se generan hoy en día no están estructurados, por lo que es necesario procesarlos para generar información. Algunos ejemplos de datos no estructurados son los artículos de noticias, las publicaciones en las redes sociales y el historial de búsqueda. El proceso de analizar el lenguaje natural y extraerle sentido se enmarca en el campo del procesamiento del lenguaje natural (PLN). El análisis de sentimientos es una tarea común del PLN, que implica clasificar textos o partes de textos en función de un sentimiento predefinido. Para analizar datos textuales, utilizará el kit de herramientas de lenguaje natural (NLTK), una biblioteca de PLN de uso común en Python.

En este tutorial, preparará un conjunto de datos de tuits de muestra del paquete NLTK para NLP con diferentes métodos de limpieza de datos. Una vez que el conjunto de datos esté listo para su procesamiento, entrenará un modelo con tuits preclasificados y lo usará para clasificar los tuits de muestra en sentimientos negativos y positivos.

Este artículo asume que estás familiarizado con los conceptos básicos de Python (consulta nuestra serie Cómo codificar en Python 3), principalmente el uso de estructuras de datos, clases y métodos. El tutorial asume que no tienes experiencia en PNL y nltk, aunque algunos conocimientos sobre el tema son una ventaja adicional.

Prerrequisitos

• Este tutorial se basa en la versión 3.6.5 de Python. Si no tienes Python 3 instalado, aquí tienes una guía para instalar y configurar un entorno de programación local para Python 3.
• Se recomienda estar familiarizado con el trabajo con datos de lenguaje. Si no está familiarizado con el uso de NLTK, consulte la guía Cómo trabajar con datos de lenguaje en Python 3 usando Natural Language Toolkit (NLTK).

Paso 1: Instalación de NLTK y descarga de datos

En este tutorial, utilizará el paquete NLTK en Python para todas las tareas de procesamiento del lenguaje natural. En este paso, instalará NLTK y descargará los tweets de muestra que utilizará para entrenar y probar su modelo.

Primero, instale el paquete NLTK con el pipadministrador de paquetes:

pip install nltk==3.3

En este tutorial se utilizarán tweets de muestra que forman parte del paquete NLTK. Primero, inicie una sesión interactiva de Python ejecutando el siguiente comando:

python3

Luego, importe el nltkmódulo en el intérprete de Python.

import nltk

Descargue los tweets de muestra del paquete NLTK:

nltk.download('twitter_samples')

Al ejecutar este comando desde el intérprete de Python, se descargan y almacenan los tweets de forma local. Una vez que se descargan las muestras, están disponibles para su uso.

Más adelante en el tutorial, utilizará los tuits negativos y positivos para entrenar su modelo en el análisis de sentimientos. Los tuits sin sentimientos se utilizarán para probar su modelo.

Si desea utilizar su propio conjunto de datos, puede recopilar tweets de un período de tiempo, usuario o hashtag específico utilizando la API de Twitter.

Ahora que ha importado NLTK y ha descargado los tweets de muestra, salga de la sesión interactiva ingresando exit(). Está listo para importar los tweets y comenzar a procesar los datos.

Paso 2: Tokenización de los datos

Una máquina no puede procesar con precisión el lenguaje en su forma original, por lo que es necesario procesarlo para que sea más fácil de entender para la máquina. La primera parte del proceso de interpretación de los datos se realiza mediante un proceso denominado tokenización, o división de cadenas en partes más pequeñas llamadas tokens.

Un token es una secuencia de caracteres en un texto que funciona como una unidad. Según cómo se creen los tokens, pueden consistir en palabras, emoticones, hashtags, enlaces o incluso caracteres individuales. Una forma básica de dividir el lenguaje en tokens es dividir el texto en función de los espacios en blanco y la puntuación.

Para comenzar, crea un nuevo .pyarchivo para guardar tu secuencia de comandos. En este tutorial, se utilizará lo siguiente nlp_test.py:

nano nlp_test.py

En este archivo, primero importarás los twitter_samplesdatos para poder trabajar con ellos:

prueba nlp_test.py

from nltk.corpus import twitter_samples

Esto importará tres conjuntos de datos de NLTK que contienen varios tweets para entrenar y probar el modelo:

• negative_tweets.json:5000 tweets con sentimientos negativos
• positive_tweets.json:5000 tweets con sentimientos positivos
• tweets.20150430-223406.json:20000 tweets sin sentimientos

A continuación, cree variables para positive_tweets, negative_tweetsy text:

prueba nlp_test.py

from nltk.corpus import twitter_samplespositive_tweets = twitter_samples.strings('positive_tweets.json')negative_tweets = twitter_samples.strings('negative_tweets.json')text = twitter_samples.strings('tweets.20150430-223406.json')

El strings()método de twitter_samplesimprimirá todos los tweets dentro de un conjunto de datos como cadenas. Establecer las diferentes colecciones de tweets como una variable facilitará el procesamiento y la prueba.

Antes de usar un tokenizador en NLTK, debe descargar un recurso adicional, punkt. El punktmódulo es un modelo entrenado previamente que lo ayuda a tokenizar palabras y oraciones. Por ejemplo, este modelo sabe que un nombre puede contener un punto (como “S. Daityari”) y la presencia de este punto en una oración no necesariamente la termina. Primero, inicie una sesión interactiva de Python:

python3

Ejecute los siguientes comandos en la sesión para descargar el punktrecurso:

import nltk
nltk.download('punkt')

Una vez que se complete la descarga, estará listo para usar los tokenizadores de NLTK. NLTK proporciona un tokenizador predeterminado para tweets con el .tokenized()método. Agregue una línea para crear un objeto que tokenice el positive_tweets.jsonconjunto de datos:

prueba nlp_test.py

from nltk.corpus import twitter_samplespositive_tweets = twitter_samples.strings('positive_tweets.json')negative_tweets = twitter_samples.strings('negative_tweets.json')text = twitter_samples.strings('tweets.20150430-223406.json')tweet_tokens = twitter_samples.tokenized('positive_tweets.json')

Si desea probar el script para ver el .tokenizedmétodo en acción, agregue el contenido resaltado al nlp_test.pyscript. Esto convertirá en token un solo tuit del positive_tweets.jsonconjunto de datos:

prueba nlp_test.py

from nltk.corpus import twitter_samplespositive_tweets = twitter_samples.strings('positive_tweets.json')negative_tweets = twitter_samples.strings('negative_tweets.json')text = twitter_samples.strings('tweets.20150430-223406.json')tweet_tokens = twitter_samples.tokenized('positive_tweets.json')[0]print(tweet_tokens[0])

Guarde y cierre el archivo y ejecute el script:

python3 nlp_test.py

El proceso de tokenización lleva algo de tiempo porque no se trata de una simple división en espacios en blanco. Después de unos minutos de procesamiento, verás lo siguiente:

Output['#FollowFriday', '@France_Inte', '@PKuchly57', '@Milipol_Paris', 'for', 'being', 'top', 'engaged', 'members', 'in', 'my', 'community', 'this', 'week', ':)']

Aquí, el .tokenized()método devuelve caracteres especiales como @y _. Estos caracteres se eliminarán mediante expresiones regulares más adelante en este tutorial.

Ahora que has visto cómo .tokenized()funciona el método, asegúrate de comentar o eliminar la última línea para imprimir el tweet tokenizado del script agregando un #al comienzo de la línea:

prueba nlp_test.py

from nltk.corpus import twitter_samplespositive_tweets = twitter_samples.strings('positive_tweets.json')negative_tweets = twitter_samples.strings('negative_tweets.json')text = twitter_samples.strings('tweets.20150430-223406.json')tweet_tokens = twitter_samples.tokenized('positive_tweets.json')[0]#print(tweet_tokens[0])

Ahora su script está configurado para convertir los datos en tokens. En el siguiente paso, actualizará el script para normalizar los datos.

Paso 3: Normalización de los datos

Las palabras tienen diferentes formas: por ejemplo, “ran”, “runs” y “running” son formas diferentes del mismo verbo, “run”. Según los requisitos de su análisis, es posible que sea necesario convertir todas estas versiones a la misma forma, “run”. La normalización en PNL es el proceso de convertir una palabra a su forma canónica.

La normalización ayuda a agrupar palabras con el mismo significado pero con formas diferentes. Sin la normalización, “ran”, “runs” y “running” se tratarían como palabras diferentes, aunque quizás quieras que se traten como la misma palabra. En esta sección, explorarás la lematización y la derivación, que son dos técnicas populares de normalización.

La lematización es un proceso de eliminación de afijos de una palabra. La lematización, que funciona únicamente con formas verbales simples, es un proceso heurístico que elimina las terminaciones de las palabras.

En este tutorial, utilizará el proceso de lematización, que normaliza una palabra con el contexto del vocabulario y el análisis morfológico de las palabras del texto. El algoritmo de lematización analiza la estructura de la palabra y su contexto para convertirla a una forma normalizada. Por lo tanto, tiene un costo en velocidad. Una comparación entre la lematización y la derivación se reduce en última instancia a un equilibrio entre velocidad y precisión.

Antes de continuar utilizando la lematización, descargue los recursos necesarios ingresando lo siguiente en una sesión interactiva de Python:

python3

Ejecute los siguientes comandos en la sesión para descargar los recursos:

import nltk
nltk.download('wordnet')
nltk.download('averaged_perceptron_tagger')

wordnetes una base de datos léxica para el idioma inglés que ayuda al sistema a determinar la palabra base. Necesita el averaged_perceptron_taggerrecurso para determinar el contexto de una palabra en una oración.

Una vez descargado, ya casi está listo para usar el lematizador. Antes de ejecutarlo, debe determinar el contexto de cada palabra de su texto. Esto se logra mediante un algoritmo de etiquetado, que evalúa la posición relativa de una palabra en una oración. En una sesión de Python, importe la pos_tagfunción y proporcione una lista de tokens como argumento para obtener las etiquetas. Probemos esto en Python:

from nltk.tag import pos_tag
from nltk.corpus import twitter_samples
tweet_tokens = twitter_samples.tokenized('positive_tweets.json')
print(pos_tag(tweet_tokens[0]))

Aquí está la salida de la pos_tagfunción.

Output[('#FollowFriday', 'JJ'), ('@France_Inte', 'NNP'), ('@PKuchly57', 'NNP'), ('@Milipol_Paris', 'NNP'), ('for', 'IN'), ('being', 'VBG'), ('top', 'JJ'), ('engaged', 'VBN'), ('members', 'NNS'), ('in', 'IN'), ('my', 'PRP$'), ('community', 'NN'), ('this', 'DT'), ('week', 'NN'), (':)', 'NN')]

De la lista de etiquetas, aquí está la lista de los elementos más comunes y su significado:

• NNP: Sustantivo, propio, singular
• NN: Sustantivo, común, singular o masivo
• IN: Preposición o conjunción, subordinante
• VBG: Verbo, gerundio o participio presente
• VBN: Verbo, participio pasado

Aquí hay una lista completa del conjunto de datos.

En general, si una etiqueta comienza con NN, la palabra es un sustantivo y si comienza con VB, la palabra es un verbo. Después de revisar las etiquetas, salga de la sesión de Python ingresando exit().

Para incorporar esto a una función que normaliza una oración, primero debes generar las etiquetas para cada token en el texto y luego lematizar cada palabra usando la etiqueta.

Actualice el nlp_test.pyarchivo con la siguiente función que lematiza una oración:

prueba nlp_test.py

...from nltk.tag import pos_tagfrom nltk.stem.wordnet import WordNetLemmatizerdef lemmatize_sentence(tokens):    lemmatizer = WordNetLemmatizer()    lemmatized_sentence = []    for word, tag in pos_tag(tokens):        if tag.startswith('NN'):            pos = 'n'        elif tag.startswith('VB'):            pos = 'v'        else:            pos = 'a'        lemmatized_sentence.append(lemmatizer.lemmatize(word, pos))    return lemmatized_sentenceprint(lemmatize_sentence(tweet_tokens[0]))

Este código importa la WordNetLemmatizerclase y la inicializa en una variable, lemmatizer.

La función lemmatize_sentenceobtiene primero la etiqueta de posición de cada token de un tuit. Dentro de la ifdeclaración, si la etiqueta comienza con NN, el token se asigna como un sustantivo. De manera similar, si la etiqueta comienza con VB, el token se asigna como un verbo.

Guarde y cierre el archivo y ejecute el script:

python3 nlp_test.py

Aquí está el resultado:

Output['#FollowFriday', '@France_Inte', '@PKuchly57', '@Milipol_Paris', 'for', 'be', 'top', 'engage', 'member', 'in', 'my', 'community', 'this', 'week', ':)']

Notarás que el verbo beingcambia a su forma raíz, be, y el sustantivo memberscambia a member. Antes de continuar, comenta la última línea que imprime el tuit de muestra del script.

Ahora que ha creado con éxito una función para normalizar palabras, está listo para pasar a eliminar el ruido.

Paso 4: eliminar el ruido de los datos

En este paso, eliminará el ruido del conjunto de datos. El ruido es cualquier parte del texto que no agrega significado ni información a los datos.

El ruido es específico de cada proyecto, por lo que lo que constituye ruido en un proyecto puede no serlo en otro. Por ejemplo, las palabras más comunes en un idioma se denominan palabras vacías. Algunos ejemplos de palabras vacías son “es”, “el” y “un”. Por lo general, son irrelevantes al procesar el lenguaje, a menos que un caso de uso específico justifique su inclusión.

En este tutorial, utilizará expresiones regulares en Python para buscar y eliminar estos elementos:

• Hipervínculos : todos los hipervínculos de Twitter se convierten al acortador de URL t.co. Por lo tanto, mantenerlos en el procesamiento de texto no agregaría ningún valor al análisis.
• Nombres de usuario de Twitter en las respuestas : estos nombres de usuario de Twitter están precedidos por un @símbolo que no transmite ningún significado.
• Puntuación y caracteres especiales : si bien estos suelen brindar contexto a los datos textuales, este contexto suele ser difícil de procesar. Para simplificar, eliminará toda la puntuación y los caracteres especiales de los tweets.

Para eliminar hipervínculos, primero debe buscar una subcadena que coincida con una URL que comience con http://o https://, seguida de letras, números o caracteres especiales. Una vez que se encuentra un patrón coincidente, el .sub()método lo reemplaza con una cadena vacía.

Dado que normalizaremos las formas de las palabras dentro de la remove_noise()función, puedes comentar la lemmatize_sentence()función desde el script.

Agregue el siguiente código a su nlp_test.pyarchivo para eliminar el ruido del conjunto de datos:

prueba nlp_test.py

...import re, stringdef remove_noise(tweet_tokens, stop_words = ()):    cleaned_tokens = []    for token, tag in pos_tag(tweet_tokens):        token = re.sub('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.+#]|[!*(),]|'                       '(?:%[0-9a-fA-F][0-9a-fA-F]))+','', token)        token = re.sub("(@[A-Za-z0-9_]+)","", token)        if tag.startswith("NN"):            pos = 'n'        elif tag.startswith('VB'):            pos = 'v'        else:            pos = 'a'        lemmatizer = WordNetLemmatizer()        token = lemmatizer.lemmatize(token, pos)        if len(token)  0 and token not in string.punctuation and token.lower() not in stop_words:            cleaned_tokens.append(token.lower())    return cleaned_tokens

Este código crea una remove_noise()función que elimina el ruido e incorpora la normalización y lematización mencionadas en la sección anterior. El código toma dos argumentos: los tokens del tweet y la tupla de palabras vacías.

A continuación, el código utiliza un bucle para eliminar el ruido del conjunto de datos. Para eliminar los hipervínculos, el código primero busca una subcadena que coincida con una URL que comience con http://o https://, seguida de letras, números o caracteres especiales. Una vez que se encuentra una coincidencia con un patrón, el .sub()método lo reemplaza con una cadena vacía, o ''.

De manera similar, para eliminar @menciones, el código sustituye la parte relevante del texto mediante expresiones regulares. El código utiliza la rebiblioteca para buscar @símbolos, seguidos de números, letras o _, y los reemplaza con una cadena vacía.

Por último, puedes eliminar la puntuación utilizando la biblioteca string.

Además de esto, también eliminará las palabras vacías utilizando un conjunto integrado de palabras vacías en NLTK, que debe descargarse por separado.

Ejecute el siguiente comando desde una sesión interactiva de Python para descargar este recurso:

nltk.download('stopwords')

Una vez descargado el recurso, salga de la sesión interactiva.

Puedes usar el .words()método para obtener una lista de palabras vacías en inglés. Para probar la función, ejecutémosla en nuestro tuit de muestra. Agrega las siguientes líneas al final del nlp_test.pyarchivo:

prueba nlp_test.py

...from nltk.corpus import stopwordsstop_words = stopwords.words('english')print(remove_noise(tweet_tokens[0], stop_words))

Después de guardar y cerrar el archivo, ejecute el script nuevamente para recibir un resultado similar al siguiente:

Output['#followfriday', 'top', 'engage', 'member', 'community', 'week', ':)']

Tenga en cuenta que la función elimina todas @las menciones, palabras vacías y convierte las palabras a minúsculas.

Antes de continuar con el ejercicio de modelado en el siguiente paso, utilice la remove_noise()función para limpiar los tuits positivos y negativos. Comente la línea para imprimir el resultado remove_noise()en el tuit de muestra y agregue lo siguiente al nlp_test.pyscript:

prueba nlp_test.py

...from nltk.corpus import stopwordsstop_words = stopwords.words('english')#print(remove_noise(tweet_tokens[0], stop_words))positive_tweet_tokens = twitter_samples.tokenized('positive_tweets.json')negative_tweet_tokens = twitter_samples.tokenized('negative_tweets.json')positive_cleaned_tokens_list = []negative_cleaned_tokens_list = []for tokens in positive_tweet_tokens:    positive_cleaned_tokens_list.append(remove_noise(tokens, stop_words))for tokens in negative_tweet_tokens:    negative_cleaned_tokens_list.append(remove_noise(tokens, stop_words))

Ahora que ha añadido el código para limpiar los tuits de muestra, puede que quiera comparar los tokens originales con los tokens limpios para un tuit de muestra. Si desea probar esto, agregue el siguiente código al archivo para comparar ambas versiones del tuit número 500 de la lista:

prueba nlp_test.py

...print(positive_tweet_tokens[500])print(positive_cleaned_tokens_list[500])

Guarde y cierre el archivo y ejecute el script. En el resultado, verá que se han eliminado la puntuación y los vínculos, y que las palabras se han convertido a minúsculas.

Output['Dang', 'that', 'is', 'some', 'rad', '@AbzuGame', '#fanart', '!', ':D', 'https://t.co/bI8k8tb9ht']['dang', 'rad', '#fanart', ':d']

Existen ciertos problemas que pueden surgir durante el preprocesamiento del texto. Por ejemplo, las palabras sin espacios ("iLoveYou") se tratarán como una sola y puede resultar difícil separarlas. Además, el script tratará de forma diferente "Hi", "Hii" y "Hiiiii" a menos que escribas algo específico para solucionar el problema. Es habitual ajustar el proceso de eliminación de ruido para tus datos específicos.

Ahora que has visto la remove_noise()función en acción, asegúrate de comentar o eliminar las dos últimas líneas del script para poder agregarle más:

prueba nlp_test.py

...#print(positive_tweet_tokens[500])#print(positive_cleaned_tokens_list[500])

En este paso, eliminó el ruido de los datos para que el análisis fuera más eficaz. En el siguiente paso, analizará los datos para encontrar las palabras más comunes en el conjunto de datos de muestra.

Paso 5: Determinación de la densidad de palabras

La forma más básica de análisis de datos textuales es extraer la frecuencia de las palabras. Un solo tuit es una entidad demasiado pequeña para determinar la distribución de palabras, por lo tanto, el análisis de la frecuencia de las palabras se realizaría en todos los tuits positivos.

El siguiente fragmento define una función generadora, denominada get_all_words, que toma una lista de tweets como argumento para proporcionar una lista de palabras en todos los tokens de tweets unidos. Agregue el siguiente código a su nlp_test.pyarchivo:

prueba nlp_test.py

...def get_all_words(cleaned_tokens_list):    for tokens in cleaned_tokens_list:        for token in tokens:            yield tokenall_pos_words = get_all_words(positive_cleaned_tokens_list)

Ahora que has recopilado todas las palabras de la muestra de tweets, puedes averiguar cuáles son las más comunes utilizando la FreqDistclase NLTK. Agregando el siguiente código al nlp_test.pyarchivo:

prueba nlp_test.py

from nltk import FreqDistfreq_dist_pos = FreqDist(all_pos_words)print(freq_dist_pos.most_common(10))

El .most_common()método enumera las palabras que aparecen con mayor frecuencia en los datos. Guarde y cierre el archivo después de realizar estos cambios.

Cuando ejecute el archivo ahora, encontrará los términos más comunes en los datos:

Output[(':)', 3691), (':-)', 701), (':d', 658), ('thanks', 388), ('follow', 357), ('love', 333), ('...', 290), ('good', 283), ('get', 263), ('thank', 253)]

A partir de estos datos, puedes ver que las entidades de emoticones forman algunas de las partes más comunes de los tuits positivos. Antes de continuar con el siguiente paso, asegúrate de comentar la última línea del script que imprime los diez tokens principales.

En resumen, extrajiste los tweets de nltk, los tokenizaste, los normalizaste y los limpiaste para usarlos en el modelo. Por último, también analizaste las frecuencias de los tokens en los datos y verificaste las frecuencias de los diez tokens principales.

En el siguiente paso, preparará los datos para el análisis de sentimientos.

Paso 6: Preparación de los datos para el modelo

El análisis de sentimientos es un proceso que permite identificar la actitud del autor sobre un tema sobre el que se escribe. Para entrenar un modelo, creará un conjunto de datos de entrenamiento. Es un proceso de aprendizaje automático supervisado que requiere que asocie cada conjunto de datos con un “sentimiento” para el entrenamiento. En este tutorial, su modelo utilizará los sentimientos “positivos” y “negativos”.

El análisis de sentimientos se puede utilizar para categorizar el texto en una variedad de sentimientos. Para simplificar y facilitar la disponibilidad del conjunto de datos de entrenamiento, este tutorial le ayuda a entrenar su modelo en solo dos categorías: positiva y negativa.

Un modelo es una descripción de un sistema que utiliza reglas y ecuaciones. Puede ser tan simple como una ecuación que predice el peso de una persona, dada su altura. Un modelo de análisis de sentimientos que usted creará asociaría los tuits con un sentimiento positivo o negativo. Deberá dividir su conjunto de datos en dos partes. El propósito de la primera parte es crear el modelo, mientras que la siguiente parte prueba el rendimiento del modelo.

En el paso de preparación de datos, preparará los datos para el análisis de sentimientos convirtiendo los tokens al formato de diccionario y luego dividirá los datos para fines de entrenamiento y prueba.

Convertir tokens en un diccionario

En primer lugar, preparará los datos que se introducirán en el modelo. Para realizar el ejercicio de modelado, utilizará el clasificador Naive Bayes de NLTK. Observe que el modelo no solo requiere una lista de palabras de un tuit, sino un diccionario de Python con palabras como claves y Truecomo valores. La siguiente función crea una función generadora para cambiar el formato de los datos limpios.

Agregue el siguiente código para convertir los tweets de una lista de tokens limpios en diccionarios con claves como tokens y Truecomo valores. Los diccionarios correspondientes se almacenan en positive_tokens_for_modely negative_tokens_for_model.

prueba nlp_test.py

...def get_tweets_for_model(cleaned_tokens_list):    for tweet_tokens in cleaned_tokens_list:        yield dict([token, True] for token in tweet_tokens)positive_tokens_for_model = get_tweets_for_model(positive_cleaned_tokens_list)negative_tokens_for_model = get_tweets_for_model(negative_cleaned_tokens_list)

División del conjunto de datos para entrenar y probar el modelo

A continuación, debe preparar los datos para entrenar la NaiveBayesClassifierclase. Agregue el siguiente código al archivo para preparar los datos:

prueba nlp_test.py

...import randompositive_dataset = [(tweet_dict, "Positive")                     for tweet_dict in positive_tokens_for_model]negative_dataset = [(tweet_dict, "Negative")                     for tweet_dict in negative_tokens_for_model]dataset = positive_dataset + negative_datasetrandom.shuffle(dataset)train_data = dataset[:7000]test_data = dataset[7000:]

Este código adjunta una etiqueta Positiveo Negativea cada tuit. Luego crea una datasetal unir los tuits positivos y negativos.

De forma predeterminada, los datos contienen todos los tuits positivos seguidos de todos los tuits negativos en secuencia. Al entrenar el modelo, debe proporcionar una muestra de sus datos que no contenga ningún sesgo. Para evitarlo, ha agregado un código para organizar los datos de forma aleatoria utilizando el .shuffle()método de random.

Por último, el código divide los datos mezclados en una proporción de 70:30 para el entrenamiento y la prueba, respectivamente. Dado que la cantidad de tweets es 10 000, puede utilizar los primeros 7000 tweets del conjunto de datos mezclados para entrenar el modelo y los 3000 finales para probarlo.

En este paso, convirtió los tokens limpios a un formato de diccionario, mezcló aleatoriamente el conjunto de datos y lo dividió en datos de entrenamiento y prueba.

Paso 7: construcción y prueba del modelo

Por último, puedes usar la NaiveBayesClassifierclase para crear el modelo. Utiliza el .train()método para entrenar el modelo y el .accuracy()método para probar el modelo en los datos de prueba.

prueba nlp_test.py

...from nltk import classifyfrom nltk import NaiveBayesClassifierclassifier = NaiveBayesClassifier.train(train_data)print("Accuracy is:", classify.accuracy(classifier, test_data))print(classifier.show_most_informative_features(10))

Guarde, cierre y ejecute el archivo después de agregar el código. El resultado del código será el siguiente:

OutputAccuracy is: 0.9956666666666667Most Informative Features                      :( = True           Negati : Positi =   2085.6 : 1.0                      :) = True           Positi : Negati =    986.0 : 1.0                 welcome = True           Positi : Negati =     37.2 : 1.0                  arrive = True           Positi : Negati =     31.3 : 1.0                     sad = True           Negati : Positi =     25.9 : 1.0                follower = True           Positi : Negati =     21.1 : 1.0                     bam = True           Positi : Negati =     20.7 : 1.0                    glad = True           Positi : Negati =     18.1 : 1.0                     x15 = True           Negati : Positi =     15.9 : 1.0               community = True           Positi : Negati =     14.1 : 1.0

La precisión se define como el porcentaje de tuits en el conjunto de datos de prueba para los cuales el modelo pudo predecir correctamente el sentimiento. Una precisión del 99,5 % en el conjunto de pruebas es bastante buena.

En la tabla que muestra las características más informativas, cada fila en la salida muestra la proporción de ocurrencia de un token en tweets etiquetados como positivos y negativos en el conjunto de datos de entrenamiento. La primera fila en los datos significa que en todos los tweets que contienen el token :(, la proporción de tweets negativos a positivos fue 2085.6de 1. Curiosamente, parece que había un token con :(en los conjuntos de datos positivos. Puedes ver que los dos elementos discriminantes principales en el texto son los emoticones. Además, palabras como sadconducen a sentimientos negativos, mientras que welcomey gladestán asociadas con sentimientos positivos.

A continuación, puedes comprobar cómo funciona el modelo con tweets aleatorios de Twitter. Añade este código al archivo:

prueba nlp_test.py

...from nltk.tokenize import word_tokenizecustom_tweet = "I ordered just once from TerribleCo, they screwed up, never used the app again."custom_tokens = remove_noise(word_tokenize(custom_tweet))print(classifier.classify(dict([token, True] for token in custom_tokens)))

Este código te permitirá probar tweets personalizados actualizando la cadena asociad