NLP - Analizamos Los Cuentos de Hernan Casciari

26/8/2020 NLP: Analizamos los cuentos de Hernan Casciari | Aprende Machine Learning
 
Aprende
Machine
Learning
antes de que sea demasiado tarde
Privacidad - Términos
https://www.aprendemachinelearning.com/ejercicio-nlp-cuentos-de-hernan-casciari-python-espanol/ 1/28
 
PRÁCTICA
NLP: Analizamos los cuentos

de Hernan Casciari
 January 14, 2019 by Na8
Ejercicio Python de Procesamiento del

Lenguaje Natural
( ó “¿Qué tiene Casciari en la cabeza?” )
 
Luego de haber escrito sobre la teoría de iniciación al NLP en el artículo anterior llega
la hora de hacer algunos ejercicios prácticos en código Python para adentrarnos en

este mundo. 
Como la idea es hacer Aprendizaje Automático en Español, se me ocurrió buscar
textos en castellano y recordé a Hernan Casciari que tiene los cuentos de su blog
disponibles online y me pareció un buen desafío.
Para quien no conozca a Hernan Casciari, es un escritor genial, hace cuentos muy
entretenidos, de humor (y drama) muy reales, relacionados con su vida, infancia,
relaciones familiares con toques de cción. Vivió en España durante más de una
década y tuvo allí a su primera hija. En 2005 fue premiado como “El mejor blog del
mundo” por Deutsche Welle de Alemania. En 2008 Antonio Gasalla tomó su obra
“Más respeto que soy tu madre” y la llevó al teatro con muchísimo éxito. Escribió
columnas para importantes periódicos de España y Argentina hasta que fundó su
propia editorial Orsai en 2010 donde no depende de terceros para comercializar ni
distribuir sus productos y siempre ofrece versione en pdf (gratuitos). Tiene 7 libros
publicados, apariciones en radio (Vorterix y Perros de la Calle) y hasta llevó sus
historias a una genial puesta en escena llamada “Obra en Construcción” que giró por
muchas provincias de la Argentina, España y Uruguay.
 
Agenda del Día: “NLP tradicional”

 
Lo cierto es que utilizaremos la librería python NLTK para NLP y haremos uso de
varias funciones y análisis tradicionales, me re ero a que sin meternos – aún- en
Deep Learning (eso lo dejaremos para otro futuro artículo).
1. Obtener los Datos (los cuentos)

2. Exploración Inicial
3. Limpieza de datos
4. Análisis Exploratorio
5. Análisis de Sentimiento
6. Modelado de Tópicos
Vamos al código!
1 – Obtener los Cuentos
Para obtener los textos, haremos webscraping (LEER ARTíCULO) en el blog de Hernan

Casciari, recorreremos los cuentos que afortunadamente están clasi cados en
directorios por año, del 2004 al 2005 y guardaremos todos los posts de cada año en
un archivo txt.
ATENCIóN: Este código puede tardar MUCHOS minutos en descargar todos los textos, pues para ser amables con el
servidor, haremos un sleep(0.75) entre cada request (y son 386 cuentos).
Python
1 # Web scraping, pickle imports
2 import requests
3 from bs4 import BeautifulSoup
4 import pickle
5 from time import sleep
6
7 # Web Scrapes transcript data from blog
8 def url_to_transcript(url):
9 '''Obtener los enlaces del blog de Hernan Casciari.'''
10 page = requests.get(url).text
11 soup = BeautifulSoup(page, "lxml")
12 print('URL',url)
13 enlaces = []
14 for title in soup.find_all(class_="entry-title"):
15 for a in title.find_all('a', href=True):
16 print("Found link:", a['href'])
17
18
19

enlaces.append(a['href'])
sleep(0.75) #damos tiempo para que no nos penalice un firewall
return enlaces

20
21 base = 'https://editorialorsai.com/category/epocas/'
22 urls = []
23 anios = ['2004','2005','2006','2007','2008','2009','2010','2011','2012','2013','2014','2015']
24 for anio in anios:
25 urls.append(base + anio + "/")
26 print(urls)
27
28 # Recorrer las URLs y obtener los enlaces
29 enlaces = [url_to_transcript(u) for u in urls]
30 print(enlaces)
31
32 def url_get_text(url):
33 '''Obtener los textos de los cuentos de Hernan Casciari.'''
34 print('URL',url)
35 text=""
36 try:
37 page = requests.get(url).text
38 soup = BeautifulSoup(page, "lxml")
39 text = [p.text for p in soup.find(class_="entry-content").find_all('p')]
40 except Exception:
41 print('ERROR, puede que un firewall nos bloquea.')
42 return ''
43 sleep(0.75) #damos tiempo para que no nos penalice un firewall
44 return text
45
46 # Recorrer las URLs y obtener los textos
47 MAX_POR_ANIO = 50 # para no saturar el server
48 textos=[]
49 for i in range(len(anios)):
50 arts = enlaces[i]
51 arts = arts[0:MAX_POR_ANIO]
52 textos.append([url_get_text(u) for u in arts])
53 print(len(textos))
54
55 ## Creamos un directorio y nombramos los archivos por año
56 !mkdir blog
57
58 for i, c in enumerate(anios):
59 with open("blog/" + c + ".txt", "wb") as file:
60 cad=""
61 for texto in textos[i]:
62 for texto0 in texto:
63 cad=cad + texto0
64 pickle.dump(cad, file)
Al nalizar obtendremos una carpeta llamada blog con 12 archivos: 2004.txt a

2015.txt.
Recuerda que puedes descargar todos los archivos, jupyter

Notebook y código Python desde mi cuenta de Github
2 – Exploración Inicial / Cargamos los

 
Datos
Cargaremos los archivos txt que creamos en el paso anterior y lo pasaremos a una
estructura en un dataframe de Pandas para seguir usando en el próximo paso.
Python
1 data = {}
2 for i, c in enumerate(anios):
3 with open("blog/" + c + ".txt", "rb") as file:
4 data[c] = pickle.load(file)
5 # Revisamos que se haya guardado bien
6 print(data.keys())
7 # Veamos algun trozo de texto
8 print(data['2008'][1000:1222])
9
10 # Combine it!
11 data_combined = {key: [value] for (key, value) in data.items()}
12
13 # We can either keep it in dictionary format or put it into a pandas dataframe
14 import pandas as pd
15 pd.set_option('max_colwidth',150)
16
17 data_df = pd.DataFrame.from_dict(data_combined).transpose()
18 data_df.columns = ['transcript']
19 data_df = data_df.sort_index()
20 data_df
3 – Limpieza de Datos
Ahora aplicaremos algunos de los ltros de limpieza que se suelen usar para poder
tratar el texto:
 
Pasar texto a minúsculas
Quitar signos de puntuación (interrogación, etc.)
Quitar espacios extra, cambio de carro, tabulaciones
Python
1 # Apply a first round of text cleaning techniques
2 import re
3 import string
4
5 def clean_text_round1(text):
6 '''Make text lowercase, remove text in square brackets, remove punctuation and remove words
7 text = text.lower()
8 text = re.sub('\[.*?¿\]\%', ' ', text)
9 text = re.sub('[%s]' % re.escape(string.punctuation), ' ', text)
10 text = re.sub('\w*\d\w*', '', text)
11 return text
12
13 round1 = lambda x: clean_text_round1(x)
14
15 data_clean = pd.DataFrame(data_df.transcript.apply(round1))
16
17 # Apply a second round of cleaning
18 def clean_text_round2(text):
19 '''Get rid of some additional punctuation and non-sensical text that was missed the first t
20 text = re.sub('[‘’“”…«»]', '', text)
21 text = re.sub('\n', ' ', text)
22 return text
23
24 round2 = lambda x: clean_text_round2(x)
25
26 data_clean = pd.DataFrame(data_clean.transcript.apply(round2))
27 data_clean
28
29 # Let's pickle it for later use
30 data_df.to_pickle("corpus.pkl")
Y creamos nuestro “Bag of Words”
A partir del dataset que limpiamos, creamos y contamos las palabras:

(el archivo spanish.txt lo incluye NLTK ó si no lo tienes, copia de mi Github en el
mismo directorio en donde tienes el código)
Python
1 # We are going to create a document-term matrix using CountVectorizer, and exclude common Spani
2 from sklearn.feature_extraction.text import CountVectorizer
3
4 with open('spanish.txt') as f: Privacidad - Términos
5 lines = f.read().splitlines()
6
7 cv = CountVectorizer(stop_words=lines)
8 data_cv = cv.fit_transform(data_clean.transcript)
9 data_dtm = pd.DataFrame(data_cv.toarray(), columns=cv.get_feature_names())
10
11
12

data_dtm.index = data_clean.index
data_dtm.to_pickle("dtm.pkl")

13 # Let's also pickle the cleaned data (before we put it in document-term matrix format) and the C
14 data_clean.to_pickle('data_clean.pkl')
15 pickle.dump(cv, open("cv.pkl", "wb"))
16
17 data_dtm
4 – Análisis Exploratorio
Ahora que tenemos nuestro dataset, investigaremos un poco
Python
1 data = pd.read_pickle('dtm.pkl')
2 data = data.transpose()
3 data.head()
4.1 – Palabras más usadas por año

veamos las palabras más usadas cada año:
1

top_dict = {}
 Python
2 for c in data.columns:
3 top = data[c].sort_values(ascending=False).head(30)
4 top_dict[c]= list(zip(top.index, top.values))
5 print(top_dict)
6 # Print the top 15 words by year
7 for anio, top_words in top_dict.items():
8 print(anio)
9 print(', '.join([word for word, count in top_words[0:14]]))
Python
1 --- 2004 si, alex, vez, lucas, cada, dos, ahora, ser, después, casa, años, siempre, nadie, ver <b
4.2 Agregamos Stop Words
Vemos en el listado que hay palabras muy usadas pero que realmente no tienen un
signi cado útil para el análisis. Entonces haremos lo siguiente: uniremos las 12 listas
de más palabras en un nuevo ranking y de esas, tomaremos las “más usadas” para
ser agregar en nuestro listado de Stop Words.
Python
1 from collections import Counter
2
3 # Let's first pull out the top 30 words for each anio
4 words = []
5 for anio in data.columns:
6 top = [word for (word, count) in top_dict[anio]]
7 for t in top:
8 words.append(t)
9 print(Counter(words).most_common())
10 add_stop_words = [word for word, count in Counter(words).most_common() if count > 6]
11 add_stop_words
Python
1 ['si', 'vez', 'cada', 'dos', 'ahora', 'después', 'años', 'hace
4.3 Actualizamos nuestra Bag of Words
Ahora quitaremos las Stop words de nuestro dataset. Usaremos el listado de

spanish.txt, el que generamos recién y uno adicional que hice yo a partir de los
resultados obtenidos (ojo… esto les puede parecer arbitrario y en parte lo es!)
Python
1 from sklearn.feature_extraction import text
3
4
5
6

# Read in cleaned data
data_clean = pd.read_pickle('data_clean.pkl')


7 # Add new stop words
8 with open('spanish.txt') as f:
9 stop_words = f.read().splitlines()
10 for pal in add_stop_words:
11 stop_words.append(pal)
12 more_stop_words=['alex','lucas','andrés','mirta','tres','primer','primera','dos','uno','veces',
13 for pal in more_stop_words:
15
16 # Recreate document-term matrix
17 cv = CountVectorizer(stop_words=stop_words)
18 data_cv = cv.fit_transform(data_clean.transcript)
19 data_stop = pd.DataFrame(data_cv.toarray(), columns=cv.get_feature_names())
20 data_stop.index = data_clean.index
21
22 # Pickle it for later use
23 import pickle
24 pickle.dump(cv, open("cv_stop.pkl", "wb"))
25 data_stop.to_pickle("dtm_stop.pkl")
4.4 Nube de Palabras
Haremos una primer aproximación a “qué tenía Hernan Casciari en su cabeza” entre
2004 y 2015 en sus cuentos usando un modo de visualización llamado WordCloud.
Esto puede requerir que debas instalar la librería Wordcloud con Pip ó si tienes
instalado Anaconda, desde la interface ó por terminal con conda install -c conda-forge
wordcloud
Python
1 from wordcloud import WordCloud
2
3 wc = WordCloud(stopwords=stop_words, background_color="white", colormap="Dark2",
4 max_font_size=150, random_state=42)
5
6 import matplotlib.pyplot as plt
7 plt.rcParams['figure.figsize'] = [16,12]
8
9 # Create subplots for each anio
10 for index, anio in enumerate(data.columns):
11 wc.generate(data_clean.transcript[anio])
12 plt.subplot(4, 3, index+1)
13 plt.imshow(wc, interpolation="bilinear")
14 plt.axis("off")
15 plt.title(anios[index])
16 plt.show()
 
4.5 Estadísticas de Palabras por año
Ahora sacaremos algunas estadísticas de palabras únicas por año (el tamaño del
vocabulario empleado) y el promedio de palabras por artículo
Python
1 # Find the number of unique words per Year
2 # Identify the non-zero items in the document-term matrix, meaning that the word occurs at least
3 unique_list = []
5 uniques = data[anio].nonzero()[0].size
6 unique_list.append(uniques)
7
8 # Create a new dataframe that contains this unique word count
9 data_words = pd.DataFrame(list(zip(anios, unique_list)), columns=['Anio', 'unique_words'])
10 #data_unique_sort = data_words.sort_values(by='unique_words')
11 data_unique_sort = data_words # sin ordenar
12 data_unique_sort
13 # ejecuta este si hicimos el webscrapping, o no tenemos los valores en la variable
14 posts_per_year=[]
15 try:
16 enlaces
17 except NameError:
18 # Si no hice, los tengo hardcodeados:
19 posts_per_year = [50, 27, 18, 50, 42, 22, 50, 33, 31, 17, 33, 13]
20 else:
21 for i in range(len(anios)):
22 arts = enlaces[i]
23 #arts = arts[0:10] #limito a maximo 10 por año
24 print(anios[i],len(arts))
25 posts_per_year.append(min(len(arts),MAX_POR_ANIO)) Privacidad - Términos
26
27 # Find the total number of words per Year

28 total_list = []
30 totals = sum(data[anio])
31
32
33

total_list.append(totals)

# Let's add some columns to our dataframe

34 data_words['total_words'] = total_list
35 data_words['posts_per_year'] = posts_per_year
36 data_words['words_per_posts'] = data_words['total_words'] / data_words['posts_per_year']
37
38 # Sort the dataframe by words per minute to see who talks the slowest and fastest
39 #data_wpm_sort = data_words.sort_values(by='words_per_posts')
40 data_wpm_sort = data_words #sin ordenar
41 data_wpm_sort
4.5.1 Visualización de la tabla
Veamos los datos en grá co de barras horizontales:
Python
1 import numpy as np
2 plt.rcParams['figure.figsize'] = [16, 6]
3
4 y_pos = np.arange(len(data_words))
5
6 plt.subplot(1, 3, 1)
7 plt.barh(y_pos,posts_per_year, align='center')
8 plt.yticks(y_pos, anios)
9 plt.title('Number of Posts', fontsize=20)
10
11
13 plt.barh(y_pos, data_unique_sort.unique_words, align='center')
14 plt.yticks(y_pos, data_unique_sort.Anio) Privacidad - Términos
15 plt.title('Number of Unique Words', fontsize=20)

16
18 plt.barh(y_pos, data_wpm_sort.words_per_posts, align='center')
19 plt.yticks(y_pos, data_wpm_sort.Anio)
20
21
22

plt.title('Number of Words Per Posts', fontsize=20)
plt.tight_layout()

23 plt.show()
Y hagamos una comparativa de frecuencia de uso de algunas palabras (aquí tu

podrías escoger otras) En mi caso seleccioné casa, mundo,tiempo y vida
Python
1 import nltk
2 from nltk.corpus import PlaintextCorpusReader
3 corpus_root = './python_projects/blog'
4 wordlists = PlaintextCorpusReader(corpus_root, '.*', encoding='latin-1')
5 #wordlists.fileids() # con esto listamos los archivos del directorio
6
7 cfd = nltk.ConditionalFreqDist(
8 (word,genre)
9 for genre in anios
10 for w in wordlists.words(genre + '.txt')
11 for word in ['casa','mundo','tiempo','vida']
12 if w.lower().startswith(word) )
13 cfd.plot()
 
5 – Análisis de Sentimiento
Ahora probaremos analizando los sentimientos en cuanto a “positivos y negativos”

encontrados en el texto y sus cambios de polaridad. Para simpli car usaremos una
librería llamada TextBlob que ya tiene esta funcionalidad hecha, aunque NO LO
recomiendo para uso en producción. Por desgracia sólo funciona con textos en
inglés, por lo que además nos obliga a traducir el texto con lo que eso conlleva… Pero
para nes educativos -cómo los de este blog- es un buen ejemplo para ver el análisis
de sentimiento.
Python
1 data = pd.read_pickle('corpus.pkl')
2 from textblob import TextBlob
3
4 pol = lambda x: TextBlob(x).sentiment.polarity
5 pol2 = lambda x: x.sentiment.polarity
6 sub = lambda x: TextBlob(x).sentiment.subjectivity
7 sub2 = lambda x: x.sentiment.subjectivity
8
9 traducir = lambda x: TextBlob(x).translate(to="en")
10
11 data['blob_en'] = data['transcript'].apply(traducir)
12 data['polarity'] = data['blob_en'].apply(pol2)
13 data['subjectivity'] = data['blob_en'].apply(sub2)
14 data Privacidad - Términos
 
5.1 Visualización global
Veamos globalmente tomando en cuenta la polaridad y la subjetividad detectadas

por la librería:
Python
2
3 for index, anio in enumerate(data.index):
4 x = data.polarity.loc[anio]
5 y = data.subjectivity.loc[anio]
6 plt.scatter(x, y, color='blue')
7 plt.text(x+.001, y+.001, data['full_name'][index], fontsize=10)
8 plt.xlim(-0.051, 0.152)
9
10 plt.title('Sentiment Analysis', fontsize=20)
11 plt.xlabel('<-- Negative -------- Positive -->', fontsize=15)
12 plt.ylabel('<-- Facts -------- Opinions -->', fontsize=15)
13
14 plt.show()
 
5.2 Sentimiento año por año
Ahora intentaremos analizar el comportamiento del sentimiento a medida que el

autor escribía cuentos a lo largo de los años. Para ello, tomaremos de a 12 “trozos”
de texto de cada año y los analizaremos. (NOTA: Esto no es preciso realmente, pues
no coincide temporalmente con 12 meses, es para dar una idea al lector de las
diversas técnicas que podemos aplicar).
Python
1 import math
2
3 def split_text(text, n=12):
4 '''Takes in a string of text and splits into n equal parts, with a default of 12 equal part
5
6 # Calculate length of text, the size of each chunk of text and the starting points of each
7 length = len(text)
8 size = math.floor(length / n)
9 start = np.arange(0, length, size)
10
11 # Pull out equally sized pieces of text and put it into a list
12 split_list = []
13 for piece in range(n):
14 split_list.append(text[start[piece]:start[piece]+size])
15 return split_list
16
17 list_pieces = []
18 for t in data.blob_en:#transcript:
19 split = split_text(t,12)
20 list_pieces.append(split)
21
22
23
24

polarity_transcript = []
for lp in list_pieces:
polarity_piece = []

25 for p in lp:
26 #polarity_piece.append(TextBlob(p).translate(to="en").sentiment.polarity)
27 polarity_piece.append(p.sentiment.polarity)
28 polarity_transcript.append(polarity_piece)
29
31
32 for index, anio in enumerate(data.index):
33 plt.subplot(3, 4, index+1)
34 plt.plot(polarity_transcript[index])
35 plt.plot(np.arange(0,12), np.zeros(12))
36 plt.title(data['full_name'][index])
37 plt.ylim(ymin=-.1, ymax=.2)
38
39 plt.show()
6. Modelado de Tópicos (ó temas)
Ahora intentaremos obtener “automáticamente” algunos de los temas sobre los que
escribe el autor. A decir verdad para que funcione deberíamos aplicar Lemmatization
y limpiar mejor nuestro dataset. Para poder mostrar esta técnica nos vale, aunque no
obtendremos resultados realmente buenos.
Utilizaremos la conocida librería Gensim y utilizaremos el algoritmo Latent Dirichlet

Allocation (LDA)
 
Python
1 data = pd.read_pickle('dtm_stop.pkl')
2 tdm = data.transpose()
3 sparse_counts = scipy.sparse.csr_matrix(tdm)
4 corpus = matutils.Sparse2Corpus(sparse_counts)
5 cv = pickle.load(open("cv_stop.pkl", "rb"))
6 id2word = dict((v, k) for k, v in cv.vocabulary_.items())
7
8 from nltk import word_tokenize, pos_tag
9
10 def nouns_adj(text):
11 '''Given a string of text, tokenize the text and pull out only the nouns and adjectives.'''
12 is_noun_adj = lambda pos: pos[:2] == 'NN' or pos[:2] == 'JJ'
13 tokenized = word_tokenize(text,language='spanish')
14 nouns_adj = [word for (word, pos) in pos_tag(tokenized) if is_noun_adj(pos)]
15 return ' '.join(nouns_adj)
16
17 data_clean = pd.read_pickle('data_clean.pkl')
18 data_clean
19
20 from sklearn.feature_extraction import text
22
23 # Re-add the additional stop words since we are recreating the document-term matrix
24 #add_stop_words = ['di', 'la', 'know', 'just', 'dont', 'thats', 'right', 'people',
25 # 'youre', 'got', 'gonna', 'time', 'think', 'yeah', 'said']
26 #stop_words = text.ENGLISH_STOP_WORDS.union(add_stop_words)
27 # Add new stop words
28 #stop_words = text.ENGLISH_STOP_WORDS.union(add_stop_words)
29 with open('spanish.txt') as f:
30 stop_words = f.read().splitlines()#
31 for pal in add_stop_words:
33 for pal in more_stop_words:
35
36 # Create a new document-term matrix using only nouns and adjectives, also remove common words w
37 cvna = CountVectorizer(stop_words=stop_words, max_df=.8)
38 data_cvna = cvna.fit_transform(data_nouns_adj.transcript)
39 data_dtmna = pd.DataFrame(data_cvna.toarray(), columns=cvna.get_feature_names())
40 data_dtmna.index = data_nouns_adj.index
41 data_dtmna
42
43 data_nouns_adj = pd.DataFrame(data_clean.transcript.apply(nouns_adj))
44 data_nouns_adj
45
46 # Create the gensim corpus
47 corpusna = matutils.Sparse2Corpus(scipy.sparse.csr_matrix(data_dtmna.transpose()))
48
49 # Create the vocabulary dictionary
50 id2wordna = dict((v, k) for k, v in cvna.vocabulary_.items())
51
52 # Probamos a modelar con 3 tópicos
53 ldana = models.LdaModel(corpus=corpusna, num_topics=3, id2word=id2wordna, passes=10)
54 ldana.print_topics()
6.1 Identi car los temas

Ahora haremos una “pasada” más profunda para ver si obtenemos 3 temáticas
diferenciadas:
 
Python
1 QTY_TOPICS=3
2 ldana = models.LdaModel(corpus=corpusna, num_topics=QTY_TOPICS, id2word=id2wordna, passes=80)
3 ldana.print_topics()
Python
1 [(0, '0.001"jugador" + 0.001"papelitos" + 0.001"niño" + 0.001"casciari" +
Python
1 corpus_transformed = ldana[corpusna]
2 list(zip([a for [(a,b)] in corpus_transformed], data_dtmna.index))
Python
1 [(1, '2004'), (1, '2005'), (2, '2006'), (3, '2007'), (2, '2008'), (1, '2
podemos intuir (¿forzosamente?) que lo que detectó el algoritmo se re ere a estos 3

temas:
Jugar / Niñez
Fútbol
Futuro
Conclusiones nales
Repasemos lo que hicimos y que resultados sacamos:
Extracción de 386 textos -> conseguimos los cuentos de 2004 al 2015

Limpiamos los textos, quitamos caracteres que no utilizamos y creamos un
listado de stop_words (palabras para omitir)
Exploración de datos:
Realizamos estadísticas básicas, como el vocabulario usado, cantidad de
palabras por año y promedio por posts.
Creamos Nubes de Palabras por año ya que es una manera de visualizar
textos
Análisis de Sentimiento: visualizamos las variaciones en los textos a lo largo
del tiempo y vimos leves sobresaltos, pero por lo general, una tendencia
neutral.
Modelado de temáticas: en este punto no creo que hayamos conseguido
 
unas categorías muy de nidas. Parte del problema es que no pudimos hacer
Lemmatization pues no conseguí herramientas Python en Español. Otra
opción es que no hay temáticas claras.
ATENCIóN: este artículo es algo “estándar”, como para comenzar a entender el NLP
aplicado y cómo -con diversas técnicas- comprender el lenguaje humano. Realmente
hay muchas más aplicaciones y tareas que se pueden hacer. Debo decir que casi
todo “en el mercado” está hecho para analizar textos en inglés y parte de la di cultad
para desarrollar el ejercicio consistió en llevarlo al castellano. Si conoces otras
buenas herramientas en español, escríbeme!
ATENCIóN (2): Podrás encontrar diferencias entre las visualizaciones en este artículo
y el último Jupyter Notebook colgado en Github, esto se debe a que hubo
actualizaciones en el código que no están re ejados en el artículo.
Espero en el futuro poder mostrar más utilidades del NLP y también llegar a usar NLP
con algoritmos de Deep Learning (por ejemplo con redes neuronales
convolucionales).
Suscripción al Blog
Recibe los nuevos artículos sobre Machine Learning, redes neuronales, NLP y código
Python cada 3 semanas aprox.
Email: Your email address here
ENVIAR
Recursos – Descarga el código

 
Ver código completo Python y archivos en Github
Ver/Descarga el Jupyter Notebook completo aqui
y no olvides de las stop words: spanish.txt
(esto es si no lo tienes descargado por NLTK)
Si no haces el web scrapping, puedes descargar un zip con los textos del blog
de casciari en txt
Recuerda que para el ejercicio deberás instalar las librerías Python adicionales:
WordCloud
Gensim
TextBlob
Si te salteaste la teoría te recomiendo que leas mi artículo anterior,
Introducción al Procesamiento del Lenguaje Natural (sólo teoría) NLP
Puedes leer mi artículo sobre cómo hacer WebScraping de cualquier página
web
Comparte el artículo:
      
Relacionado
Procesamiento del Lenguaje Principales Algoritmos usados en Regresión Logística con Python
Natural (NLP) Machine Learning paso a paso
Ejercicio Jupyter Notebook nlp PLN Python

 
PROCESAMIENTO DEL LENGUAJE NATURAL (NLP)
EJEMPLO WEB SCRAPING EN PYTHON: IBEX35® LA BOLSA DE MADRID
7 comments
Geanfranco Palomino · July 9, 2019
Hola, como podría trabajar Lemmatization para textos en castellano?
Reply
Emilio P.R. · September 19
Muchas gracias por compartir tan magní co trabajo. Privacidad - Términos
Reply
 Na8 · September 21

Hola Emilio, gracias por escribir! Saludos
Reply
gabibold · November 1
sos un genio!! grandisimo aporte… Tengo un caso concreto que estoy

interesado en desarrollar con mi equipo. Esta relacionado con
interpretacion de emails para poder automatizar las respuestas ( utilizando
tecnologia de automatizacion de procesos (RPA) ) si te interesa colaborar,
serias mas que bienvenido 😀
Reply
Raul · November 18
Hola! El formato dle blog de Casciari cambio un poco

Deberias cambiar la funcion url_get_text() a:
def url_get_text(url):
”’Obtener los textos de los cuentos de Hernan Casciari.”’
print(‘URL’,url)
text=”” Privacidad - Términos
try:
page = requests.get(url).text
 soup = BeautifulSoup(page, “lxml”) 
text = [p.text for p in soup. nd(class_=”section-single-content”). nd_all(‘p’)]
except Exception:
print(‘ERROR, puede que un rewall nos bloquea.’)
return ”
sleep(0.75) #damos tiempo para que no nos penalice un rewall
return text
Reply
Nelson Acosta · February 10
Gracias hombre, muy buen dato!
Reply
Daniel S · July 24
Excelente ejemplo, muchas gracias!!
Reply
Leave a Reply
 
Visita nuestra Guía de Aprendizaje
Buscar
Search …
Contacto
Suscripción
Recibe los artículos de Aprende Machine Learning en tu casilla de correo. Cada 15 días y sin
Spam!
Email: Your email address here
 
ENVIAR
Proudly powered by WordPress | Theme: Eighties by Justin Kopepasah.

NLP - Analizamos Los Cuentos de Hernan Casciari

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

NLP - Analizamos Los Cuentos de Hernan Casciari

Cargado por

Copyright:

Formatos disponibles

26/8/2020 NLP: Analizamos los cuentos de Hernan Casciari | Aprende Machine Learning

NLP: Analizamos los cuentos

Ejercicio Python de Procesamiento del

( ó “¿Qué tiene Casciari en la cabeza?” )

Agenda del Día: “NLP tradicional”

1. Obtener los Datos (los cuentos)

1 – Obtener los Cuentos

Para obtener los textos, haremos webscraping (LEER ARTíCULO) en el blog de Hernan

Al nalizar obtendremos una carpeta llamada blog con 12 archivos: 2004.txt a

Recuerda que puedes descargar todos los archivos, jupyter

2 – Exploración Inicial / Cargamos los

Y creamos nuestro “Bag of Words”

A partir del dataset que limpiamos, creamos y contamos las palabras:

Ahora que tenemos nuestro dataset, investigaremos un poco

4.1 – Palabras más usadas por año

veamos las palabras más usadas cada año:

4.2 Agregamos Stop Words

4.3 Actualizamos nuestra Bag of Words

Ahora quitaremos las Stop words de nuestro dataset. Usaremos el listado de

4.4 Nube de Palabras

4.5 Estadísticas de Palabras por año

27 # Find the total number of words per Year

4.5.1 Visualización de la tabla

Veamos los datos en grá co de barras horizontales:

15 plt.title('Number of Unique Words', fontsize=20)

Y hagamos una comparativa de frecuencia de uso de algunas palabras (aquí tu

Ahora probaremos analizando los sentimientos en cuanto a “positivos y negativos”

5.1 Visualización global

Veamos globalmente tomando en cuenta la polaridad y la subjetividad detectadas

5.2 Sentimiento año por año

Ahora intentaremos analizar el comportamiento del sentimiento a medida que el

6. Modelado de Tópicos (ó temas)

Utilizaremos la conocida librería Gensim y utilizaremos el algoritmo Latent Dirichlet

6.1 Identi car los temas

podemos intuir (¿forzosamente?) que lo que detectó el algoritmo se re ere a estos 3

Repasemos lo que hicimos y que resultados sacamos:

Extracción de 386 textos -> conseguimos los cuentos de 2004 al 2015

Email: Your email address here

Recursos – Descarga el código

Ejercicio Jupyter Notebook nlp PLN Python

EJEMPLO WEB SCRAPING EN PYTHON: IBEX35® LA BOLSA DE MADRID

Geanfranco Palomino · July 9, 2019

Hola, como podría trabajar Lemmatization para textos en castellano?

Emilio P.R. · September 19

Muchas gracias por compartir tan magní co trabajo. Privacidad - Términos

sos un genio!! grandisimo aporte… Tengo un caso concreto que estoy

Hola! El formato dle blog de Casciari cambio un poco

Nelson Acosta · February 10

Gracias hombre, muy buen dato!

Excelente ejemplo, muchas gracias!!

Visita nuestra Guía de Aprendizaje

Email: Your email address here

Proudly powered by WordPress | Theme: Eighties by Justin Kopepasah.

También podría gustarte