Natural

Language
Processing en
Python
Vanessa Gmez Verdejo
Manel Mar5nez Ramn

1/54

Objetivos de esta sesin

Adquisicin de
documentos

NLTK
(Natural Language
Toolkit )

Procesado de
contenidos
In 2 weeks.
Aprendizaje
mquina sobre
textos
youll be NLTK
geeks!
2/54

Referencias bsicas

nltk.org/book

3/54

Empezando a
manejar NLTK
Parte 1

4/54

Instalacin y arranque
Se supone que el usuario Tene instalado el Python, con las
libreras:

NLTK
NLTK-Data
NumPy, Scipy
Pylab

Por sencillez se usar el ipython notebook en las prcTcas

Puesta en marcha: arrancar python y ejecutar
>> ipython notebook

import numpy
import pylab
import nltk
from __future__ import division
5/54

Textos disponibles en NLTK

nltk.download() #repositorio de paquetes!
Se abre la ventana de importacin, donde se deben seleccionar
los datos.

6/54

Carga de corpora
from nltk.book import *

text1: Moby Dick by Herman Melville 1851
text2: Sense and Sensibility by Jane Austen 1811
text3: The Book of Genesis
text4: Inaugural Address Corpus
text5: Chat Corpus
text6: Monty Python and the Holy Grail
text7: Wall Street Journal
text8: Personals Corpus
text9: The Man Who Was Thursday by G . K . Chesterton 1908

7/54

La clase text
Los anteriores textos pertenecen a la clase text de la librera
nltk, e incorporan diferentes funciones.
Algunas funciones Tles para anlisis semnTco
text2.concordance(monstrous)
Devuelve las lneas del texto text1 en las que aparece
monstrous

text2.similar(monstrous)
Devuelve palabras usadas de forma similar en el texto.

text2.common_contexts([monstrous,very])
Encuentra contextos comparTdos por dos o ms palabras
Los _ del resultado denotan dnde van las palabras.

text2.tokens
Crea una lista con los tokens del texto

8/54

Funciones tiles de Python

len(text1)
set(text1)
sorted(set(text1))
Obtenemos el vocabulario (por orden alfabTco) de un texto
words=sorted(set(text1))

Calculamos la frecuencia de aparicin de una palabra
def percentage(count,total):

return 100*count/total


Trabajando con listas recursivamente
[percentage(text.count(word),len(text1)) for word in words]
[word for word in words if percentage(text1.count(word),len(text1))>4]

9/54

El tipo str de Python

s.startswith(t)
test if s starts with t
s.endswith(t)
test if s ends with t
t in s
test if t is contained inside s
s.islower() test if all cased characters in s are lowercase
s.isupper() test if all cased characters in s are uppercase#
s.isalpha() test if all characters in s are alphabeTc
s.isalnum() test if all characters in s are alphanumeric
s.isdigit() test if all characters in s are digits
s.isTtle() test if s is Ttlecased (all words in s have have
iniTal capitals)

[w for w in set(text1) if w.endswith('ableness')]

10/54

El tipo str de Python

s.nd(t)
s.rnd(t)
s.index(t)
s.rindex(t)
s.join(text)
s.split(t)
s.splitlines()
s.lower()
s.upper()
s.Ttle()
s.strip()
s.replace(t, u)
s.startswith(t)
s.endswith(t)
t in s
s.islower()
s.isupper()
s.isalpha()
s.isalnum()
s.isdigit()
s.isTtle()

index of rst instance of string t inside s (-1 if not found)

index of last instance of string t inside s (-1 if not found)
like s.nd(t) except it raises ValueError if not found
like s.rnd(t) except it raises ValueError if not found
combine the words of the text into a string using s as the glue
split s into a list wherever a t is found (whitespace by default)
split s into a list of strings, one per line
a lowercased version of the string s
an uppercased version of the string s
a Ttlecased version of the string s
a copy of s without leading or trailing whitespace
replace instances of t with u inside s
test if s starts with t
test if s ends with t
test if t is contained inside s
test if all cased characters in s are lowercase
test if all cased characters in s are uppercase
test if all characters in s are alphabeTc
test if all characters in s are alphanumeric
test if all characters in s are digits
test if s is Ttlecased (all words in s have have iniTal capitals)

11/54

Expresiones tiles
EJERCICIO 1
Homogeneizar el vocabulario de un texto poniendo todas las
palabras en minsculas

EJERCICIO 2
Eliminar los signos de puntuacin de un texto

12/54

La funcin FreqDist
fdist=FreqDist(text2)

fdist es una funcin que genera una variable de la clase
nltk.probability.freqdist.
Incorpora diferentes funciones que permiten generar el vocabulario del
texto y la frecuencia de aparacin de cada elemento (en orden
decreciente). Incluye, entre otras, las siguientes funciones:

fdist.samples()
Genera una lista con el vocabulario
fdist.values()

Devuelve el n de veces que aparece cada


palabra
fdist.N()

N total de palabras en el texto
fdist.freq(word)
Devuelve la frecuencia de aparacin de word
fdist.inc(palabra)
Incrementa la cuenta para una palabra
fdist.max()

Palabra con mxima frecuencia
fdist.tabulate()
Tabula la distribucin de frecuencia
fdist.plot()

Representacin grca
13/54

My Jirst second bag of words

EJERCICIO 1:
UTlizando FreqDist generar el bag-of-words de text1 y
visualizarlo con .tabulate()



EJERCICIO 2:
UTlizando FreqDist, genere una lista de tuplas conteniendo las
palabras de ms de 16 caracteres y su frecuencia de aparicin.
Por ejemplo:
['companionableness', 7.063344069616319e-06],
['disinterestedness', 7.063344069616319e-06],
['disqualicaTons', 7.063344069616319e-06],....


14/54

Corpora de inters
Cmo importar un corpus
Vemos sus textos

nltk.corpus.gutenberg.leids()
['austen-emma.txt', 'austen-persuasion.txt', ...

Seleccionamos uno de ellos
emma = nltk.corpus.gutenberg.words('austen-emma.txt')

O, directamente
from nltk.corpus import gutenberg

emma = gutenberg.words('austen-emma.txt')
15/54

Funciones del corpus

leids()

leids([categories])
categories()

categories([leids])
raw()

raw(leids=[f1,f2,f3])
raw(categories=[c1,c2])
words()

words(leids=[f1,f2,f3])
words(categories=[c1,c2])
sents()

sents(leids=[f1,f2,f3])
sents(categories=[c1,c2])
abspath(leid)
encoding(leid)
open(leid)

root()

readme()

the les of the corpus

the les of the corpus corresponding to these categories
the categories of the corpus
the categories of the corpus corresponding to these les
the raw content of the corpus
the raw content of the specied les
the raw content of the specied categories
the words of the whole corpus
the words of the specied leids
the words of the specied categories
the sentences of the whole corpus
the sentences of the specied leids
the sentences of the specied categories
the locaTon of the given le on disk
the encoding of the le (if known)
open a stream for reading the given corpus le
the path to the root of locally installed corpus
the contents of the README le of the corpus

16/54

Corpora etiquetados

EJEMPLO:
from nltk.corpus import brown
brown.categories()
[[leid, brown.categories(leid)] for leid in brown.leids()]

17/54

Adquisicin de
documentos
Parte 2

18/54

Objetivos
Adquisicin de
documentos

Texto plano desde

repositorios web
Contenido web
Pginas html
Blogs
Contenido local

Procesado de
contenidos

Aprendizaje mquina
sobre textos

19/54

Importacin de texto plano

Se puede importar cualquier texto plano. La descarga desde un
repositorio web puede hacerse as:

from urllib import urlopen

url = "h{p://www.gutenberg.org/les/2554/2554.txt"
raw = urlopen(url).read()
En la variable raw habr texto crudo. Antes de proceder a su
procesado hay que formatearlo (tokenizaTon).
El formato consiste simplemente en converTrlo en una lista de
elementos (palabras, frases, bigramas, por ejemplo).
tokens = nltk.word_tokenize(raw)

20/54

Importacin de pginas web

ParTcularmente interesante es la posibilidad de leer cualquier
pgina web
url = "h{p://news.bbc.co.uk/2/hi/health/2284783.stm"
texto = urlopen(url).read()
Este obviamente es un ar5culo de BBC News. En efecto, si
hacemos:
texto[715:800]

obtenemos cualquier disparate. Cul en este caso?



21/54

Importacin de pginas web

Las eTquetas HTML se pueden eliminar automTcamente
antes de la tokenizacin (pero las frases absurdas no):
raw = nltk.clean_html(html)
tokens = nltk.word_tokenize(raw)
tokens[:10]

['BBC', 'NEWS', '|', 'Health', '|', 'Blondes', "'to", 'die', 'out', 'in']

22/54

Importacin de blogs
Se puede importar RSS
import feedparser
llog = feedparser.parse("h{p://languagelog.ldc.upenn.edu/nll/?
feed=atom")

Ttulo
post = llog.entries[2]
post.Ttle
u'NPR: oyez.org nishes Supreme Court oral arguments project

Contenido
content = post.content[0].value

23/54

Importacin de contenido local

Datos locales
path = nltk.data.nd('corpora/gutenberg/melville-
moby_dick.txt')



#Busca un texto
raw = open(path, 'rU').read()

#Carga el texto
tokens = nltk.word_tokenize(raw)

#Formato
raw[1:29]
'Moby Dick by Herman Melville

Desde el teclado (no funciona en iPython)
s = raw_input("Enter some text: ")

24/54

Un vocabulario muy simple

Construccin de un vocabulario (vanse
operaciones con strings )
words = [w.lower() for w in tokens]
# eliminamos maysculas
vocab = sorted(set(words))
len(vocab)
21317

words = [w.lower() for w in tokens if w.isalpha()]
# Nos quedamos solo con el texto
vocab = sorted(set(words))
len(vocab)
15940
25/54

Procesado de
contenido
Parte 3

26/54

Objetivos
Adquisicin de
documentos

Procesado de
contenidos

Aprendizaje
mquina sobre
textos

Tokenizacin
Extraccin de races:
lemaTzacin
Eliminacin de stopwords
Correccin de texto
Spell-checker
Expresiones regulares
Caracteres repeTdos

Sinnimos

27/54

Tokenizacin
Paso de texto a frases

from nltk.tokenize import sent_tokenize

frase=Trabajo bsicamente en el apartado de la comedia. Me gustara
estar en Diseo de Programacin, pero por desgracia aprob el bachillerato.
sent_tokenize(frase)
['Trabajo b\xc3\xa1sicamente en el apartado de la comedia.', 'Me gustar
\xc3\xada estar en Dise\xc3\xb1o de Programaci\xc3\xb3n, pero por
desgracia aprob\xc3\xa9 el bachillerato.]

UTliza una instancia de PunktSentenceTokenizer, que funciona para una gran
variedad de idiomas.

Si se deben formatear muchas frases en ingls, es ms eciente cargar el
mdulo correspondiente
import nltk.data
tokenizer=nltk.data.load(tokenizers/punkt/english.pickle)
tokenizer.tokenize(frase)

28/54

Tokenizacin
Otros idiomas.
Para formatear texto en frases en otros idiomas cargando
previamente la librera, hay que especicarlo:
tokenizer=nltk.data.load(tokenizers/punkt/spanish.pickle)

Paso de texto a palabras

from nltk.tokenize import word_tokenize
word_tokenize(Hola, mundo.)
[Hola, , , mundo , .]

word_tokenize no elimina la puntuacin y puede separar
contracciones (en castellano no hay).

29/54

Tokenizacin
Denicin de criterios de separacin usando RegexpTokenizer
from nltk.tokenize import regexp_tokenize
regexp_tokenize(Cant is a contracTon.,[\w]+)
[Cant, is, a, contracTon]

Ejemplo: separador por espacios

regexp_tokenize(Cant is a contracTon.,[\S]+)
[Cant, is, a, contracTon.]

Ntese que esta vez ha incluido el punto.
Vase la seccin de expresiones regulares para ms detalles.

30/54

Librera re (expresiones regulares)

.

^abc
abc$
[abc]
[A-Z0-9]
ed|ing|s
*

+

?

{n}
{n,}
{,n}
{m,n}
a(b|c)+

Wildcard
Encuentra un patrn abc al inicio de una cadena
Encuentra abc al nal de una cadena
Encuentra uno de un conjunto de caracteres
Encuentra uno de un rango de caracteres
Encuentra una de las cadenas especicadas (disjuncTon)
Cero o ms de los tems previos. Ej.: a*, [a-z]* (Kleene Closure)
Uno o ms de los tems previos, Ej.: a+, [a-z]+
Opcional, ej.: a?, [a-z]?
Exactamente n repeTciones
Al menos n repeTciones
No ms de n repeTciones
Al menos m y no ms de m
Parntesis que indica el objeto de las operaciones

31/54

Librera re (expresiones regulares)

Smbolo
\b
\d
\D
\s
\S
\w
\W
\t

\n
\r

\f

\v

Funcin
Word boundary (zero width)
Cualquier decimal (equivalente a [0-9])
Cualquier no decimal (equivalente a [^0-9])

Cualquier espacio (equivalente a [ \t\n\r\f\v]

Cualquier no espacio (equivalente a [^ \t\n\r\f\v])
Cualquier alfanumrico (equivalente a [a-zA-Z0-9_])

Cualquier no alfanumrico (equivalente a [^a-zA-Z0-9_])
Tabulador

Nueva lnea
Retorno de carro
Form feed (pgina nueva)
Tabulador verTcal

32/54

Librera re (expresiones regulares)

Ejemplo: Palabras que terminan en ed en ingls

import re
# Importa la la librera
wordlist = [w for w in nltk.corpus.words.words('en') if
w.islower()] # Cargamos el voabulario ingls

words=[w for w in wordlist if re.search('ed$', w)] #ObTene las
que terminan en ed
print words[:10]

['abaissed', 'abandoned', 'abased', 'abashed', 'abaTsed', 'abed',
'aborted', 'abridged', 'abscessed', 'absconded']
33/54

Librera re (expresiones regulares)

Ejemplo: Palabras que conTenen ..j..t.. donde los . son
wildcards
words=[w for w in wordlist if re.search('^..j..t..$', w)]
words[:10]

['majesTc, 'majesTc, 'majesTc, 'objected, 'majesTc,

'majesTc, 'abjectly, 'majesTc,'dejected']

Ntense las palabras repeTdas, porque hemos buscado en el
texto completo. Podemos buscar en el vocabulario
anteriormente construido
words=[w for w in vocab if re.search('^..j..t..$', w)]
words[:10]

['abjectly', 'abjectus', 'dejected', 'majesTc', 'objected']

34/54

Librera re (expresiones regulares)

Otros ejemplos
print [w for w in wordlist if re.search('^m+e+$', w)]
print [w for w in wordlist if re.search('^m*e+$', w)]
print [w for w in wordlist if re.search('^[me]+$', w)]

['me']
['e', 'me']
['e', 'em', 'eme', 'm', 'me', 'mem']

35/54

Librera re (expresiones regulares)

Divisin de texto: re.split(expre,texto)

raw ="'When I'M a Duchess,' she said to herself, (not in a very hopeful
tone though), 'I won't have any pepper in my kitchen AT ALL. Soup does
very well without--Maybe it's always pepper that makes people hot-
tempered,'...

re.split(r' ', raw)
#Dividimos cuando hay espacios
re.split(r'[ \t\n]+', raw) #Dividimos cuando hay espacios,


#tabulaciones o retornos de carro
re.split(r'\W+', raw) #Dividimos cuando aparece cualquier

#carcter que NO es alfanumrico


36/54

Librera re (expresiones regulares)

Busqueda de expresiones regulares: re.ndall(expre,w)
word = 'supercafrelisTcexpialidocious'
len(re.ndall(r'[aeiou]', word))
16 o 14?

re.ndall(r'\w+|\S\w*', raw)
re.ndall(r"\w+(?:[-']\w+)*|'|[-.(]+|\S\w*", raw)

Eliminacin de sujos:
stem, sux = re.ndall(r'(^.*)(ing|ly|ed|ious|ies|ive|es|s|ment)$',
'processing')[0]
Ntense

el uso de los parntesis r()()

la asignacin a,b = c,d;
el uso de r
[0] signica que se accede al primer elemento de la lista devuelta

37/54

Extractor de races simple

Ejercicio: Denir una funcin que nos devuelva la raz de las
palabras, es decir, que elimine los sujos ing, ly, ed, ious, ies,
ive, es, s, ment

38/54

Extractores de races en NLTK

EXTRACTORES PORTER Y LANCASTER

raw = DENNIS: Listen, strange women lying in ponds distribuTng swords
... is no basis for a system of government. Supreme execuTve power derives from
... a mandate from the masses, not from some farcical aquaTc ceremony.

tokens = nltk.word_tokenize(raw)

porter = nltk.PorterStemmer()
[porter.stem(t) for t in tokens]
['DENNI', ':', 'Listen', ',', 'strang', 'women', 'lie', 'in', 'pond', ....

lancaster = nltk.LancasterStemmer()
[lancaster.stem(t) for t in tokens]
['den', ':', 'list', ',', 'strange', 'wom', 'lying', 'in', 'pond', 'distribut', ...
39/54

Extractores de races en nltk

EXTRACTOR SNOWBALL

Funciona con 15 lenguas: SnowballStemmer.languages devuelve
la lista.

from nltk.stem import SnowballStemmer
spanish_stemmer=SnowballStemmer("spanish")
texto=Hola estoy disfrutando de este curso mientras me estoy
durmiendo

tokens = nltk.word_tokenize(texto)
[spanish_stemmer.stem(t) for t in tokens]
40/54

Lematizacin
Un lemaTzador extrae la autnTca raz de una palabra a parTr de un
diccionario.
NLTK uTliza WordNet, una base de datos lxica en ingls, a travs de un
interfaz.
Tiene una versin en castellano (h{p://grial.uab.es/sensem/
download/).
from nltk.stem import WordNetLemmaTzer
lemmaTzer = WordNetLemmaTzer()
[lemmaTzer.lemmaTze(t) for t in tokens]

El resultado ya no conTene las palabras con los sujos extrados sino que
conTene la raz o lema de las palabras.
Con Lancaster:
'execut', 'power', 'deriv

Con lemaTzador:

'execuTve, 'power, 'derives',

41/54

Lematizacin
El lemaTzador busca un lema para la palabra, y la devuelve tal
cual si no lo halla.
lemmaTzer.lemmaTze('ndings')
nding

Si se quieren encontrar los verbos, hay que especicarlo

lemmaTzer.lemmaTze(ndings,pos=v)
nd

Reconoce adjeTvos (pos=a), sustanTvos (pos=n), adverbios

(pos=r) y verbos (pos=v)

42/54

Lemmatizacin
EJERCICIO
Construir una funcin que a parTr de un texto de entrada (ya
separado en tokens ) lemaTce su contenido de manera secuencial
(primero considera que es nombre, a conTnuacin considera que
es verbo, adjeTvo y/o adverbio)

43/54

Eliminacin de palabras irrelevantes

NLTK incorpora una librera para eliminar palabras
irrelevantes (stopwords), esto es, que no contribuyen al
signicado del texto: de, la, que, el, en, y, a,
los, del,

from nltk.corpus import stopwords

stopwords.words(spanish)

EJERCICIO: Crear una funcin que elimine las palabras

irrelevantes de un texto tokenizado.

44/54

Correccin de texto
Se puede uTlizar el diccionario Wordlist para buscar aquellas
palabras del texto que no estn en el diccionario.

def unusual_words(text):
text_vocab = set(w.lower() for w in text if w.isalpha())
english_vocab = set(w.lower() for w in nltk.corpus.words.words())
unusual = text_vocab.dierence(english_vocab)
return sorted(unusual)

45/54

Correccin de texto

La funcin se puede probar de la siguiente manera:

# Nmero de palabras no usuales
print len(nltk.corpus.gutenberg.words('austen-sense.txt'))
print len(unusual_words(nltk.corpus.gutenberg.words('austen-sense.txt')))

# Nmero de palabras no usuales tras lemaTzacin
texto=nltk.corpus.gutenberg.words('austen-sense.txt')
wnl = nltk.WordNetLemmaTzer()
clean_text=[wnl.lemmaTze(t) for t in texto]
print len(unusual_words(clean_text))

clean_text=improved_lemmaTzer(texto)
print unusual_words(clean_text)[:10]
print len(unusual_words(clean_text))

46/54

Correccin de texto
EJERCICIO: Modicar la funcin anterior para que elimine las
palabras inusuales de un texto tokenizado

47/54

Reemplazo de palabras por expresiones regulares

Funcionalidad pensada para susTtuir contracciones (en ingls) por expresiones regulares
Podemos crear la clase RegexpReplacer y generar una librera replacers.py:

replacement_pa{erns = [
(r'won\'t', 'will not'),
(r'can\'t', 'cannot'),
(r'i\'m', 'i am'),
(r'ain\'t', 'is not'),
(r'(\w+)\'ll', '\g<1> will'),
(r'(\w+)n\'t', '\g<1> not'),
(r'(\w+)\'ve', '\g<1> have'),
(r'(\w+)\'s', '\g<1> is'),
(r'(\w+)\'re', '\g<1> are'),
(r'(\w+)\'d', '\g<1> would')
]

class RegexpReplacer(object):
def __init__(self, pa{erns=replacement_pa{erns):

self.pa{erns = [(re.compile(regex), repl) for (regex, repl) in pa{erns]

def replace(self, text):

s = text
for (pa{ern, repl) in self.pa{erns:
(s, count) = re.subn(pa{ern, repl, s)
return s

48/54

Reemplazo de palabras por expresiones regulares

Para usar esta funcin:

from replacers import RegexpReplacer
replacer = RegexpReplacer()

word_tokenize("can't is a contracTon)
['cant', 'is', 'a', 'contracTon']

word_tokenize(replacer.replace("can't is a contracTon"))
['can', 'not', 'is', 'a', 'contracTon']

49/54

Eliminacin de caracteres repetidos

Funcionalidad pensada para normalizar palabras que aparecen
escritas con caracteres repeTdos: ahhhhh, ummmmm,.
Podemos crear la clase RepeatReplacer en la librera replacers.py:
class RepeatReplacer(object):
def __init__(self):

self.repeat_regexp = re.compile(r'(\w*)(\w)\2(\w*)')

self.repl = r'\1\2\3
def replace(self, word):

repl_word = self.repeat_regexp.sub(self.repl, word)

if repl_word != word:


return self.replace(repl_word)

else:


return repl_word
50/54

Eliminacin de caracteres repetidos

Para usar esta funcin:
from replacers import RepeatReplacer
replacer = RepeatReplacer()

print replacer.replace('looooove')
print replacer.replace('oooooh')
print replacer.replace('goose')

51/54

Eliminando sinnimos
WordNet incorpora una base de datos lxica
Para cada trmino proporciona una familia semnTca de
trminos
from nltk.corpus import wordnet as wn
synset_clases=wn.synsets('pre{y')

print synset_clases
[Synset('pre{y.s.01'), Synset('pre{y.s.02'),
Synset('reasonably.r.01')]
synset_clases[2].lemma_names
['reasonably', 'moderately', 'pre{y', 'jolly', 'somewhat',
'fairly', 'middling', 'passably']
52/54

Eliminando sinnimos
EJERCICIO: Construir una funcin que susTtuya cada palabra
de un texto tokenizado por el primer trmino de su primera
familia semnTca

53/54

Eliminando sinnimos
Podemos probar esta funcin con:
text=nltk.corpus.gutenberg.words('austen-sense.txt')
print len(set(text))

clean_text1=improved_lemmaTzer(text)
print len(set(clean_text1))
6833
clean_text2=[synonim_converter(w) for w in clean_text1]
print len(set(clean_text2))
5035

54/54

Un vocabulario avanzado
Creemos una librera (lib_curso.py)
con todas las funciones:

improved_lemmaTzer
remove_stopwords
elimina_unusual_words
synonim_converter?

Creemos un script principal que haciendo uso de estas

funciones, lea un texto, lo tokenize, lo limpie y normalice, y,
nalmente, cree un bag of words
Texto de ejemplo:
path = nltk.data.nd('corpora/gutenberg/melville-moby_dick.txt')
raw = open(path, 'rU').read()
55/54

ClasiJicacin de
textos
Parte 4.

prximamente en Matlab

56/54