UD03 · Notebook 1 — Introducción al procesamiento del lenguaje natural¶
Muchas de las operaciones actuales de procesamiento del lenguaje natural se basan en aprendizaje automático y aprendizaje profundo. Hasta hace poco, sin embargo, estas operaciones se basaban en reglas y estadísticas. En esta práctica, veremos cómo usar algunas de estas técnicas básicas para trabajar con texto.
En esta práctica veremos las operaciones básicas dadas por las librerías de Python más utilizadas para preprocesar el texto y las representaciones que podemos obtener.
Tokenización¶
La tokenización es el proceso de dividir una cadena de caracteres en unidades más pequeñas. Estas unidades pueden ser palabras, personajes, frases, etc.
Esta es una operación básica y necesaria para aplicar cualquier técnica de procesamiento del lenguaje natural.En esta práctica usaremos la palabra tokenización, es decir, dividiremos el texto en palabras.
Para hacer esto, usaremos la librería TextBlob. Esta librería nos permitirá un texto simple de manera simple.
%pip install textblob==0.19.0
%pip install gensim
Requirement already satisfied: textblob==0.19.0 in /usr/local/lib/python3.11/dist-packages (0.19.0) Requirement already satisfied: nltk>=3.9 in /usr/local/lib/python3.11/dist-packages (from textblob==0.19.0) (3.9.1) Requirement already satisfied: click in /usr/local/lib/python3.11/dist-packages (from nltk>=3.9->textblob==0.19.0) (8.1.8) Requirement already satisfied: joblib in /usr/local/lib/python3.11/dist-packages (from nltk>=3.9->textblob==0.19.0) (1.4.2) Requirement already satisfied: regex>=2021.8.3 in /usr/local/lib/python3.11/dist-packages (from nltk>=3.9->textblob==0.19.0) (2024.11.6) Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from nltk>=3.9->textblob==0.19.0) (4.67.1) Requirement already satisfied: gensim in /usr/local/lib/python3.11/dist-packages (4.3.3) Requirement already satisfied: numpy<2.0,>=1.18.5 in /usr/local/lib/python3.11/dist-packages (from gensim) (1.26.4) Requirement already satisfied: scipy<1.14.0,>=1.7.0 in /usr/local/lib/python3.11/dist-packages (from gensim) (1.13.1) Requirement already satisfied: smart-open>=1.8.1 in /usr/local/lib/python3.11/dist-packages (from gensim) (7.1.0) Requirement already satisfied: wrapt in /usr/local/lib/python3.11/dist-packages (from smart-open>=1.8.1->gensim) (1.17.2)
Para tokenizar un texto con TextBlob antes teneamos que bajar los 'corpus'. Los corpus son conjuntos de datos que nos permiten usar las características de la librería.
!python -m textblob.download_corpora
[nltk_data] Downloading package brown to /root/nltk_data... [nltk_data] Unzipping corpora/brown.zip. [nltk_data] Downloading package punkt_tab to /root/nltk_data... [nltk_data] Unzipping tokenizers/punkt_tab.zip. [nltk_data] Downloading package wordnet to /root/nltk_data... [nltk_data] Downloading package averaged_perceptron_tagger_eng to [nltk_data] /root/nltk_data... [nltk_data] Unzipping taggers/averaged_perceptron_tagger_eng.zip. [nltk_data] Downloading package conll2000 to /root/nltk_data... [nltk_data] Unzipping corpora/conll2000.zip. [nltk_data] Downloading package movie_reviews to /root/nltk_data... [nltk_data] Unzipping corpora/movie_reviews.zip. Finished.
Tokenización de palabras¶
Una vez que hemos bajado el modelo, podemos tokenizar el texto. Para hacer esto, primero debemos importar la librería.
A continuación, crearemos un objeto textblob con el texto que queremos tokenizar. Este objeto nos permitirá acceder a la funcionalidad de la librería.
Finalmente, usaremos la función de words para tokenizar el texto.
# Importamos la librería
from textblob import TextBlob
# Creamos un objeto TextBLOB con el texto que queremos tokenizar
text = "El Barça es el mejor equipo del mundo. A veces."
blob = TextBlob(text)
# Tokenizamos el texto
tokens = blob.words
# Mostramos los tokens
tokens
WordList(['El', 'Barça', 'es', 'el', 'mejor', 'equipo', 'del', 'mundo', 'A', 'veces'])
Una de las funciones más interesantes de TextBlob es que nos permite obtener la categoría gramatical de cada palabra. Para hacer esto, utilizaremos el atributo tags del objeto TextBlob.
# Obtenemos la categoría gramatical de cada palabra
# Las categorías de gramática se pueden consultar en: https://www.clips.uantwerpen.be/pages/mbsp-tags
tags = blob.tags
tags
[('El', 'NNP'),
('Barça', 'NNP'),
('es', 'VBZ'),
('el', 'FW'),
('mejor', 'JJ'),
('equipo', 'NN'),
('del', 'FW'),
('mundo', 'NN'),
('A', 'DT'),
('veces', 'NNS')] También podemos hacer la extracción de frase nominal. Esta función nos permite obtener los grupos de palabras que componen un nombre.
# Conseguimos las frases nominales
nps = blob.noun_phrases
nps
WordList(['el barça', 'es el mejor equipo del mundo'])
Tokenitzación de frases¶
En algunos casos, también es necesario tokenizar el texto en oraciones. Para hacer esto, utilizaremos la función sentences del objeto TextBlob.
# Tokenizamos el text en oraciones
text = "El Barça es el mejor equipo del mundo. A veces. "
blob = TextBlob(text)
sentences = blob.sentences
sentences
[Sentence("El Barça es el mejor equipo del mundo."), Sentence("A veces.")] Stopwords y signos de puntuación¶
- Las stopwords son palabras que no proporcionan información relevante para la tarea que estamos haciendo. Por ejemplo, en la tarea de clasificación de texto, las stopwords no proporcionan información para la clasificación.
Por lo tanto, en muchos casos, es aconsejable eliminar las stopwords en el texto antes de aplicar cualquier técnica de procesamiento del lenguaje natural.
TextBlob nos permite eliminar las stopwords del texto.Para hacer esto, usaremos la lista stopwords que tiene NLTK (librería en la que se basa TextBloB).
# Obtenemos las stopwords
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
stop = stopwords.words('spanish')
stop
[nltk_data] Downloading package stopwords to /root/nltk_data... [nltk_data] Unzipping corpora/stopwords.zip.
['de', 'la', 'que', 'el', 'en', 'y', 'a', 'los', 'del', 'se', 'las', 'por', 'un', 'para', 'con', 'no', 'una', 'su', 'al', 'lo', 'como', 'más', 'pero', 'sus', 'le', 'ya', 'o', 'este', 'sí', 'porque', 'esta', 'entre', 'cuando', 'muy', 'sin', 'sobre', 'también', 'me', 'hasta', 'hay', 'donde', 'quien', 'desde', 'todo', 'nos', 'durante', 'todos', 'uno', 'les', 'ni', 'contra', 'otros', 'ese', 'eso', 'ante', 'ellos', 'e', 'esto', 'mí', 'antes', 'algunos', 'qué', 'unos', 'yo', 'otro', 'otras', 'otra', 'él', 'tanto', 'esa', 'estos', 'mucho', 'quienes', 'nada', 'muchos', 'cual', 'poco', 'ella', 'estar', 'estas', 'algunas', 'algo', 'nosotros', 'mi', 'mis', 'tú', 'te', 'ti', 'tu', 'tus', 'ellas', 'nosotras', 'vosotros', 'vosotras', 'os', 'mío', 'mía', 'míos', 'mías', 'tuyo', 'tuya', 'tuyos', 'tuyas', 'suyo', 'suya', 'suyos', 'suyas', 'nuestro', 'nuestra', 'nuestros', 'nuestras', 'vuestro', 'vuestra', 'vuestros', 'vuestras', 'esos', 'esas', 'estoy', 'estás', 'está', 'estamos', 'estáis', 'están', 'esté', 'estés', 'estemos', 'estéis', 'estén', 'estaré', 'estarás', 'estará', 'estaremos', 'estaréis', 'estarán', 'estaría', 'estarías', 'estaríamos', 'estaríais', 'estarían', 'estaba', 'estabas', 'estábamos', 'estabais', 'estaban', 'estuve', 'estuviste', 'estuvo', 'estuvimos', 'estuvisteis', 'estuvieron', 'estuviera', 'estuvieras', 'estuviéramos', 'estuvierais', 'estuvieran', 'estuviese', 'estuvieses', 'estuviésemos', 'estuvieseis', 'estuviesen', 'estando', 'estado', 'estada', 'estados', 'estadas', 'estad', 'he', 'has', 'ha', 'hemos', 'habéis', 'han', 'haya', 'hayas', 'hayamos', 'hayáis', 'hayan', 'habré', 'habrás', 'habrá', 'habremos', 'habréis', 'habrán', 'habría', 'habrías', 'habríamos', 'habríais', 'habrían', 'había', 'habías', 'habíamos', 'habíais', 'habían', 'hube', 'hubiste', 'hubo', 'hubimos', 'hubisteis', 'hubieron', 'hubiera', 'hubieras', 'hubiéramos', 'hubierais', 'hubieran', 'hubiese', 'hubieses', 'hubiésemos', 'hubieseis', 'hubiesen', 'habiendo', 'habido', 'habida', 'habidos', 'habidas', 'soy', 'eres', 'es', 'somos', 'sois', 'son', 'sea', 'seas', 'seamos', 'seáis', 'sean', 'seré', 'serás', 'será', 'seremos', 'seréis', 'serán', 'sería', 'serías', 'seríamos', 'seríais', 'serían', 'era', 'eras', 'éramos', 'erais', 'eran', 'fui', 'fuiste', 'fue', 'fuimos', 'fuisteis', 'fueron', 'fuera', 'fueras', 'fuéramos', 'fuerais', 'fueran', 'fuese', 'fueses', 'fuésemos', 'fueseis', 'fuesen', 'sintiendo', 'sentido', 'sentida', 'sentidos', 'sentidas', 'siente', 'sentid', 'tengo', 'tienes', 'tiene', 'tenemos', 'tenéis', 'tienen', 'tenga', 'tengas', 'tengamos', 'tengáis', 'tengan', 'tendré', 'tendrás', 'tendrá', 'tendremos', 'tendréis', 'tendrán', 'tendría', 'tendrías', 'tendríamos', 'tendríais', 'tendrían', 'tenía', 'tenías', 'teníamos', 'teníais', 'tenían', 'tuve', 'tuviste', 'tuvo', 'tuvimos', 'tuvisteis', 'tuvieron', 'tuviera', 'tuvieras', 'tuviéramos', 'tuvierais', 'tuvieran', 'tuviese', 'tuvieses', 'tuviésemos', 'tuvieseis', 'tuviesen', 'teniendo', 'tenido', 'tenida', 'tenidos', 'tenidas', 'tened']
A continuación veremos un ejemplo de cómo eliminar los stopwords de un texto.
# Eliminamos las palabras de parada de un texto
text = "El Barça es el mejor equipo del mundo. A veces."
blob = TextBlob(text)
tokens = [token for token in blob.words if token not in stop]
tokens
['El', 'Barça', 'mejor', 'equipo', 'mundo', 'A', 'veces']
También podemos ver cómo, junto con las palabras de parada, también se eliminan los signos de puntuación.
Lematización i stemming¶
La Lematización es el proceso de convertir una palabra en su forma base. Por ejemplo, la palabra está se convierte en estar.
El Stemming, por otro lado, es eliminar los añadidos de las palabras. Por ejemplo, la palabra estar se convierte est.
Ambas técnicas nos permiten reducir el vocabulario del texto y, por lo tanto, reducir la dimensionalidad de los vectores de la palabra; Lo que puede ayudarnos a mejorar el rendimiento de nuestros modelos.
Vemos un ejemplo de cómo aplicar la lematización y el stemming de TextBlob.
# Lematizamos y stemmizamos un texto
text = """
The titular threat of The Blob has always struck me as the ultimate movie
monster: an insatiably hungry, amoeba-like mass able to penetrate
virtually any safeguard, capable of--as a doomed doctor chillingly
describes it--"assimilating flesh on contact.
Snide comparisons to gelatin be damned, it's a concept with the most
devastating of potential consequences, not unlike the grey goo scenario
proposed by technological theorists fearful of
artificial intelligence run rampant.
"""
#text = "Serias un buen cantante, si no fuera por la voz."
blob = TextBlob(text)
# Lematizamos
lemmas = [token.lemmatize() for token in blob.words]
# Stemmizamos
stemes = [token.stem() for token in blob.words]
lemmas, stemes
(['The', 'titular', 'threat', 'of', 'The', 'Blob', 'ha', 'always', 'struck', 'me', 'a', 'the', 'ultimate', 'movie', 'monster', 'an', 'insatiably', 'hungry', 'amoeba-like', 'mass', 'able', 'to', 'penetrate', 'virtually', 'any', 'safeguard', 'capable', 'of', 'a', 'a', 'doomed', 'doctor', 'chillingly', 'describes', 'it', 'assimilating', 'flesh', 'on', 'contact', 'Snide', 'comparison', 'to', 'gelatin', 'be', 'damned', 'it', "'s", 'a', 'concept', 'with', 'the', 'most', 'devastating', 'of', 'potential', 'consequence', 'not', 'unlike', 'the', 'grey', 'goo', 'scenario', 'proposed', 'by', 'technological', 'theorist', 'fearful', 'of', 'artificial', 'intelligence', 'run', 'rampant'], ['the', 'titular', 'threat', 'of', 'the', 'blob', 'ha', 'alway', 'struck', 'me', 'as', 'the', 'ultim', 'movi', 'monster', 'an', 'insati', 'hungri', 'amoeba-lik', 'mass', 'abl', 'to', 'penetr', 'virtual', 'ani', 'safeguard', 'capabl', 'of', 'as', 'a', 'doom', 'doctor', 'chillingli', 'describ', 'it', 'assimil', 'flesh', 'on', 'contact', 'snide', 'comparison', 'to', 'gelatin', 'be', 'damn', 'it', "'s", 'a', 'concept', 'with', 'the', 'most', 'devast', 'of', 'potenti', 'consequ', 'not', 'unlik', 'the', 'grey', 'goo', 'scenario', 'propos', 'by', 'technolog', 'theorist', 'fear', 'of', 'artifici', 'intellig', 'run', 'rampant'])
N-grams¶
Los N-Grrams son secuencias de n palabras consecutivas. Por ejemplo, si tenemos el siguiente texto: 'El Barça es el mejor equipo del mundo', los N-gramas de 2 palabras serían: 'El Barça', 'Barça es', 'es el', 'el mejor', 'mejor equipo', 'equipo del', 'del mundo'.
Los N-Grams nos permiten tener en cuenta la relación entre palabras consecutivas. Por ejemplo, en el texto anterior, si solo usamos Unigrammes, no sabremos que 'mejor' y 'equipo' están relacionados. Sin embargo, si usamos Bigramas, sabremos que 'mejor equipo' están relacionados.
Para crear los N-Grams en TextBlob, usaremos la función ngrams.
# Creamos bigrams de un texto
text = "El Barça es el mejor equipo del mundo."
blob = TextBlob(text)
bigrams = blob.ngrams(n=2)
bigrams
[WordList(['El', 'Barça']), WordList(['Barça', 'es']), WordList(['es', 'el']), WordList(['el', 'mejor']), WordList(['mejor', 'equipo']), WordList(['equipo', 'del']), WordList(['del', 'mundo'])]
Representación del texto¶
Una vez que hemos procesado el texto previamente, debemos representarlo en un formato que la computadora pueda entender.
Veremos algunas de las representaciones más utilizadas en el procesamiento del lenguaje natural. En esta práctica, nos centraremos en algunas de las representaciones más utilizadas en las tareas de clasificación de texto.
Codificación de un solo estado¶
La representación una codificación única es crear un vector para cada documento. Este vector tiene tantas dimensiones como palabras diferentes en el vocabulario. Cada dimensión del vector representa una palabra del vocabulario y el valor de la dimensión es 1 si la palabra aparece en el documento y 0 si no aparece.
Por ejemplo, si tenemos el siguiente vocabulario: 'Casa', 'Coche', 'Avión' y el siguiente documento: 'Casa coche casa', el vector resultante sería: [1, 1, 0].
Usaremos la clase OneHotencoder de la librería Sklearn para crear la representación una codificación única.
import numpy
from sklearn import preprocessing
# Creamos la representación de rendimiento única de un texto
text = "El Barça es el mejor equipo del mundo. A veces."
blob = TextBlob(text)
tokens = numpy.array([token for token in blob.words if token not in stop])
encoder = preprocessing.OneHotEncoder()
encoded = encoder.fit_transform(tokens.reshape(-1, 1)).toarray()
encoded
array([[0., 0., 1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0., 0., 0.],
[0., 0., 0., 0., 0., 1., 0.],
[1., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 1.]]) Bolsa de palabras¶
La representación Bolsa de palabras es crear un vector para cada documento. Este vector tiene tantas dimensiones como palabras diferentes en el vocabulario. Cada dimensión del vector representa una palabra del vocabulario y el valor de la dimensión es el número de apariencias de esta palabra en el documento.
Por ejemplo, si tenemos el siguiente vocabulario: 'Casa', 'Coche', 'Avion' y el siguiente documento: 'Casa Coche Casa', el vector resultante sería: [2, 1, 0].
Para crear la representación Bolsa de palabras Usaremos la clase Countorizer de la librería Sklearn'.
# Creamos la representación de la bolsa de palabras de un texto
from sklearn.feature_extraction.text import CountVectorizer
text = "Me paso la vida del trabajo a casa y de casa al trabajo."
blob = TextBlob(text)
tokens = [token for token in blob.words if token not in stop]
text = ' '.join(tokens)
vectorizer = CountVectorizer()
bow = vectorizer.fit_transform([text])
print(vectorizer.get_feature_names_out())
print(bow.toarray())
['casa' 'me' 'paso' 'trabajo' 'vida'] [[2 1 1 2 1]]
TF-IDF¶
La representación TF-IDF (Frecuencia de documento inversa) es crear un vector para cada documento. Este vector tiene tantas dimensiones como palabras diferentes en el vocabulario. Cada dimensión del vector representa una palabra del vocabulario y el valor de la dimensión es el producto de la frecuencia de la palabra en el documento (TF) y la frecuencia inversa de la palabra en el conjunto de documentos (IDF).
Por ejemplo, si tenemos el siguiente vocabulario: 'Casa', 'coche', 'Avion' y el siguiente documento: 'Casa Coche Casa', el vector resultante sería: [2/3, 1/3, 0].
Para crear la representación TF-IDF, utilizaremos la clase TFIDFVectorizer de la librería sklearn.
# Creamos la representación TF-IDF de un texto
from sklearn.feature_extraction.text import TfidfVectorizer
text = "Me paso la vida del trabajo a casa y de casa al trabajo."
blob = TextBlob(text)
tokens = [token for token in blob.words if token not in stop]
text = ' '.join(tokens)
vectorizer = TfidfVectorizer()
tfidf = vectorizer.fit_transform([text])
print(vectorizer.get_feature_names_out())
print(tfidf.toarray())
['casa' 'me' 'paso' 'trabajo' 'vida'] [[0.60302269 0.30151134 0.30151134 0.60302269 0.30151134]]
Word2Vec¶
Word2Vec es un algoritmo que nos permite representar palabras en un espacio vectorial. Esta representación nos permite tener en cuenta la semántica de las palabras. Por ejemplo, si representamos las palabras 'rey' y 'reina' en un espacio vectorial, veremos que la distancia entre los vectores es menor que la distancia entre los vectores de 'rey' y 'coche' .
Para crear la representación Word2Vec, usaremos la clase Word2Vec de la librería Gensim.
# Creamos la representación de Word2Vec de un texto
from gensim.models import Word2Vec
text = "Me paso la vida del trabajo a casa y de casa al trabajo."
blob = TextBlob(text)
tokens = [token for token in blob.words if token not in stop]
model = Word2Vec([tokens], min_count=1)
model.wv['casa']
array([-5.3622725e-04, 2.3643136e-04, 5.1033497e-03, 9.0092728e-03,
-9.3029495e-03, -7.1168090e-03, 6.4588725e-03, 8.9729885e-03,
-5.0154282e-03, -3.7633716e-03, 7.3805046e-03, -1.5334714e-03,
-4.5366134e-03, 6.5540518e-03, -4.8601604e-03, -1.8160177e-03,
2.8765798e-03, 9.9187379e-04, -8.2852151e-03, -9.4488179e-03,
7.3117660e-03, 5.0702621e-03, 6.7576934e-03, 7.6286553e-04,
6.3508903e-03, -3.4053659e-03, -9.4640139e-04, 5.7685734e-03,
-7.5216377e-03, -3.9361035e-03, -7.5115822e-03, -9.3004224e-04,
9.5381187e-03, -7.3191668e-03, -2.3337686e-03, -1.9377411e-03,
8.0774371e-03, -5.9308959e-03, 4.5162440e-05, -4.7537340e-03,
-9.6035507e-03, 5.0072931e-03, -8.7595852e-03, -4.3918253e-03,
-3.5099984e-05, -2.9618145e-04, -7.6612402e-03, 9.6147433e-03,
4.9820580e-03, 9.2331432e-03, -8.1579173e-03, 4.4957981e-03,
-4.1370760e-03, 8.2453608e-04, 8.4986202e-03, -4.4621765e-03,
4.5175003e-03, -6.7869602e-03, -3.5484887e-03, 9.3985079e-03,
-1.5776526e-03, 3.2137157e-04, -4.1406299e-03, -7.6826881e-03,
-1.5080082e-03, 2.4697948e-03, -8.8802696e-04, 5.5336617e-03,
-2.7429771e-03, 2.2600652e-03, 5.4557943e-03, 8.3459532e-03,
-1.4537406e-03, -9.2081428e-03, 4.3705525e-03, 5.7178497e-04,
7.4419081e-03, -8.1328274e-04, -2.6384138e-03, -8.7530091e-03,
-8.5655687e-04, 2.8265631e-03, 5.4014288e-03, 7.0526563e-03,
-5.7031214e-03, 1.8588197e-03, 6.0888636e-03, -4.7980510e-03,
-3.1072604e-03, 6.7976294e-03, 1.6314756e-03, 1.8991709e-04,
3.4736372e-03, 2.1777749e-04, 9.6188262e-03, 5.0606038e-03,
-8.9173904e-03, -7.0415605e-03, 9.0145587e-04, 6.3925339e-03],
dtype=float32) Otras funcionalidades de TextBlob (A partir de aquí... en Ingles)¶
TextBlob nos permite realizar otras tareas de procesamiento del lenguaje natural. Estas son algunas de estas funcionalidades.
Análisis de sentimientos¶
TextBlob nos permite analizar los sentimientos de un texto.Para hacer esto, utilizaremos el atributo sentiment del objeto TextBlob. Este atributo nos devuelve un objeto Sentiment con dos atributos: polarity y subjectivity. La polaridad es un valor entre -1 y 1 que indica si el texto es positivo o negativo. La subjetividad es un valor entre 0 y 1 que indica si el texto es objetivo o subjetivo.
# Analizamos los sentimientos de un texto
text = "This song is great!, it's the best song I've heard."
blob = TextBlob(text)
blob.sentiment
Sentiment(polarity=-0.15, subjectivity=0.4)
Clasificación¶
TextBlob nos permite clasificar el texto utilizando diferentes clasificadores. Para hacer esto, primero debemos entrenar el clasificador.
En esta práctica, usaremos el clasificador Naive Bayes para clasificar el texto. Para entrenar el clasificador, usaremos la clase NaiveBayesClasifier de la librería Textblob.Clasifiers.
Una vez que el clasificador ha sido entrenado, podemos clasificar el texto utilizando la clasificación del objeto NaiveBayesClasifier.
A continuación, veremos un ejemplo de cómo clasificar el texto con TextBlob.
#Primero crearemos los datos de capacitación y prueba
# Training data
train = [
('The application crashes when I try to open it.', 'Bug'),
('I would like to request a new feature.', 'Feature Request'),
('How do I reset my password?', 'Question'),
('There is a typo on the main page.', 'Bug'),
('Could you add support for multiple languages?', 'Feature Request'),
('Where can I find the user manual?', 'Question'),
]
# Testing data
test = [
('The app is not responding.', 'Bug'),
('I think it would be great if you could add a dark mode.', 'Feature Request'),
('What is the maximum file size I can upload?', 'Question'),
]
# Entrenamos el clasificador
from textblob.classifiers import NaiveBayesClassifier
classifier = NaiveBayesClassifier(train)
# Clasificamos texto
classifier.classify('The app crashes when I try to upload a file.')
'Bug'
classifier.accuracy(test)
1.0
Conclusiones¶
En esta práctica, hemos visto cómo el texto previo al proceso y cómo representarlo en un formato que la computadora pueda entender.Además, hemos visto cómo usar algunas de las características de TextBlob y librerías relacionadas.
TextBlob, sin embargo, se basa en NLTK, una librería que se basa en reglas y, como hemos visto en teoría, estas librerías no siempre funcionan bien. Por lo tanto, en la siguiente práctica veremos cómo usar herramientas basadas en redes neuronales para preprocesar y clasificarlo.