César Antonio Aguilar

Facultad de Letras

18/10/2017

Curso de procesamiento del

lenguaje natural

Cesar.Aguilar72@gmail.com

2

Análisis de frases con NLTK (1)

Como hemos señalado en clases anteriores, el análisis sintáctico de un texto

es una tarea que podemos emprender usando y combinando criterios

lingüísticos y estadísticos, creando así métodos híbridos eficaces.

3

Análisis de frases con NLTK (2)

Ahora, como hemos señalado también antes, existen dos tipos de objetos

sintácticos que podemos analizar: frases y oraciones. Los métodos y técnicas

que se ocupan para hacer análisis de frase se les agrupa usualmente con el

término chunking (literalmente, trozado o partición de oraciones en frases):

4

Análisis de frases con NLTK (3)

La partición de una oración en frases es parte de un criterio jerárquico

sencillo de deducir: lo que queremos identificar son combinaciones de

palabras que, gramaticalmente, cumplan un rol como núcleo de una frase, o

como modificador ligado a dicho núcleo. Los mejores candidatos son las

frases nominales (NPs):

5

Implementando un chunker (1)

Una vez hecho esto, podemos analizar la siguiente oración, la cual cuenta

con etiquetas morfosintácticas:

import nltk, re, os

Veamos ahora cómo podemos programar un analizador de frases con NLTK,

importando las siguientes librerías:

sentence01 = [("the", "DT"), ("little", "JJ"), ("yellow",

"JJ"), ("dog", "NN"), ("barked", "VBD"), ("at", "IN"),

("the", "DT"), ("cat", "NN")]

6

Implementando un chunker (2)

¿Qué obtenemos con esto?:

1. Una estructura arbórea, en donde se indica con paréntesis cuáles son las

frases que cumplen con el patrón que establecimos en nuestra gramática.

2. El gráfico de un árbol sintáctico, el cual representa la estructura sintáctica

de nuestra oración.

grammar01 = "NP: {<DT>?<JJ>*<NN>}”

cp = nltk.RegexpParser(grammar01)

result01 = cp.parse(sentence01)

print (result01)

result01.draw()

Ahora, escribamos el siguiente código:

7

Implementando un chunker (3)

El resultado es:

8

Si observan, nuestra gramática es una secuencia de etiquetas con

expresiones regulares, las cuales simplemente indican aquí:

1. Busca toda secuencia que inicie con un determinante (o DT), más

cualquier otra palabra subsecuente.

2. A esta cadena se debe ligar un adjetivo (o JJ), el cual puede tener

una recurrencia de 0 a infinito.

3. Finalmente, a esta secuencia se liga un nombre común (o NN).

Las reglas y patrones que podamos construir con nuestras

gramáticas pueden ser tan simples o complejos como lo creamos

conveniente. Veamos el siguiente ejemplo:

Implementando un chunker (4)

9

grammar02 = r”””

NP: {<DT|PP\$>?<JJ>*<NN>} # Frases que tengan determinante/posesivo,

adjetivo y nombre

{<NNP>+} # Frases con nombres propios

”””

cp = nltk.RegexpParser(grammar02)

result02 = cp.parse(sentence02)

print (result02)

result02.draw()

sentence02 = [("Rapunzel", "NNP"), ("let", "VBD"), ("down", "RP"),

("her", "PP$"), ("long", "JJ"), ("golden", "JJ"), ("hair", "NN")]

Y el resultado es:

Nuestra gramática va a ser la siguiente:

Implementando un chunker (5)

10

Implementando un chunker (6)

11

Implementando un chunker (7)

Las frases anteriores, claro

está, son ejemplos

simples.

¿Qué pasa con secuencias

más complejas? Veamos:

Text01 = '''

he PRP B-NP

accepted VBD B-VP

the DT B-NP

position NN I-NP

of IN B-PP

vice NN B-NP

chairman NN I-NP

of IN B-PP

Carlyle NNP B-NP

Group NNP I-NP

, , O

a DT B-NP

merchant NN I-NP

banking NN I-NP

concern NN I-NP

. . O

'''

12

Implementando un chunker (8)

Y el resultado es:

nltk.chunk.conllstr2tree(Text01, chunk_types=['NP']).draw()

Apliquen ahora la siguiente instrucción:

13

Implementando un chunker (9)

Como lo hemos comentado antes, NLTK cuenta con una serie de corpus

etiquetados que podemos aprovechar para hacer varias tareas. Una de ellas

es justo la detección de frases empleando estas técnicas de chunking. Por

ejemplo, tratemos de identificar frases que sigan la secuencia Verbo + TO +

Verbo en el Brown Corpus.

Para ello, requerimos de una gramática, así como importar el Brown Corpus

a nuestro intérprete:

cp = nltk.RegexpParser(‘CHUNK: {<V.*> <TO> <V.*>}’)

brown = nltk.corpus.brown

14

Implementando un chunker (10)

Ahora, lo que vamos a hacer es elaborar un ciclo, el cual nos

permita reconocer cuáles son las oraciones que, dentro del

Brown, cumplan con nuestra regla. Una vez que las

detectemos, las agruparemos en un listado que se desplegará

en pantalla. Veamos:

for sent in brown.tagged_sents():

tree = cp.parse(sent)

for subtree in tree.subtrees():

if subtree.label() == 'CHUNK': print (subtree)

15

Implementando un chunker (11)

Y el resultado final, si

confiamos en nuestro

proceso, son frases

verbales que dentro del

Brown sigan el patrón

Verbo + TO + Verbo :

Métodos de evaluación (1)

Tras haber hecho una exploración en el Corpus Brown, ahora

pasamos a implementar un método de evaluación estadístico,

con el fin de evaluar si nuestras gramáticas son eficaces o no

para localizar los patrones que buscamos.

Para esta tarea, vamos a ocupar un corpus etiquetado llamado

CoNLL 2000, el cual está seccionado en frases. Así, requerimos

de esta instrucción:

from nltk.corpus import conll2000

El resultado es:

print(conll2000.chunked_sents('train.txt')[99])

Veamos un fragmento del CoNLL 2000, usando esta

instrucción:

Métodos de evaluación (2)

El resultado lo vemos en la siguiente lámina:

cp = nltk.RegexpParser("")

test_sents = conll2000.chunked_sents('test.txt',

chunk_types=['NP'])

print (cp.evaluate(test_sents))

Una vez que hemos visto parte del contenido del CoNLL 2000,

implementemos el siguiente ciclo:

Métodos de evaluación (3)

Pregunta: ¿por qué nos da como resultado cero? ¿Qué es lo

que estamos buscando en este corpus?

Métodos de evaluación (4)

La regla que acabos de escribir nos permite localizar frases

nominales que estén conformadas por un número cardinal (CD),

un determinante (DT), un adjetivo (JJ) y nombre (NN).

Ahora, unamos esta gramática con nuestro código anterior, y

obtenemos:

grammar = r"NP: {<[CDJNP].*>+}"

La razón por la cual no nos presenta ningún resultado es

porque no hemos definido una gramática. Probemos con la

siguiente regla:

Métodos de evaluación (5)

grammar = r"NP: {<[CDJNP].*>+}"

test_sents = conll2000.chunked_sents('test.txt’,

chunk_types=['NP’])

cp = nltk.RegexpParser(grammar)

print (cp.evaluate(test_sents))

Nuestro código es:

Métodos de evaluación (6)

Las medidas que hemos generado indican lo siguiente:

1. El índice IOB indica el total de palabras que fueron

excluidas de nuestra gramática, porque no forman parte de la

estructura de una frase nominal.

2. El índice de Precision nos muestra el total de patrones que

mejor encuadran con nuestra regla sobre constitución de una

FN.

3. El índice de Recall indica el total de candidatos a FN que

hay en nuestro corpus.

4. El índice F-Measure establece un ajuste entre Precision y

Recall.

Métodos de evaluación (7)

NLTK para el español: esto es lo que hay (1)

Siendo demasiado francos, si bien NLTK cuenta con un corpus en español,

las colecciones de árboles sintácticos llamadas CESS Treebanks (que son

derivados del proyecto Freeling), en español y catalán, estos recursos no

permiten todavía desarrollar un proceso de etiquetado de nuevos

documentos, como pasa con el corpus Brown. Las razones son varias:

1. Los corpus CESS están diseñados para mostrar resultados respecto a las

consultas que hagamos en ellos, pero no permiten implementar algún

proceso de aprendizaje para un etiquetador en español.

2. Todavía no se ha desarrollado algún método en NLTK para entrenar un

etiquetador en español.

3. No hay un corpus etiquetado de referencia en español, el cual sea de libre

uso, y pueda formar parte de las librerías de NLTK.

4. No hay criterios unificados sobre el proceso de etiquetado de palabras en

español.

Incluso podemos graficar árboles sintácticos con cierto grado de

complejidad, digamos un parseo basado en gramática de

dependencias. Veamos la siguiente lámina:

Si probamos la demo que ofrece Freeling en línea, podemos ver que

se cuentan con algunos recursos para el etiquetado de oraciones,

p.e.:

NLTK para el español: esto es lo que hay (2)

NLTK para el español: esto es lo que hay (3)

Nos muestra el ejemplo de una oración:

from nltk.corpus import cess_esp

nltk.corpus.cess_esp.words()

Esto último sí podemos hacerlo desde NLTK: lanzar consultas al

corpus CESS en español, mostrar sus resultados, e incluso generar

árboles sintácticos con las oraciones que hay en tal corpus. Así, si

ocupan la instrucción:

['El', 'grupo', 'estatal', 'Electricit\xe9_de_France', ...]

Esto último sí podemos hacerlo desde NLTK: lanzar consultas al

corpus CESS en español, mostrar sus resultados, e incluso generar

árboles sintácticos con las oraciones que hay en tal corpus. Así, si

ocupan la instrucción:

NLTK para el español: esto es lo que hay (4)

[('El', 'da0ms0'), ('grupo', 'ncms000'), ...]

Nos arroja como resultado:

Tree01 = nltk.corpus.cess_esp.parsed_sents()[1].draw()

Finalmente, podemos generar un esquema arbóreo, seleccionado

alguna de las oraciones que cuenta este corpus. Usemos esta

instrucción, y veamos el resultado en la siguiente lámina:

Las etiquetas que ocupa este corpus son una variante del sistema de

anotación EAGLES,el cual ustedes ya conocen. Si escriben:

nltk.corpus.cess_esp.tagged_words()

NLTK para el español: esto es lo que hay (5)

A manera de comentario final: hay muchas cosas por hacer todavía

respecto al uso de NLTK para el procesamiento de corpus, pero lo

importante es que hay soluciones. ¿Qué posibles vías creen que puedan

ser útiles para aprovechar estos recursos para el análisis de textos en

español?

NLTK para el español: esto es lo que hay (6)

Blog del curso:

http://cesaraguilar.weebly.com/curso-de-

procesamiento-del-lenguaje-natural.html

Gracias por su atención