Procesamiento de lenguaje natural y sus aplicaciones (II)

En el post anterior pudimos adentrarnos de manera breve al procesamiento de lenguaje natural, sus aplicaciones y diferentes enfoques que se han desarrollado. Tal vez en este punto, les quede la duda de cómo los ordenadores son capaces de procesar textos si estos solo entienden números. Veamos algunas formas sencillas para lograr la transformación de textos a números.

A modo de ejemplo, imaginemos que necesitamos predecir si podemos irradiar o no un cáncer de mama dado una base de datos de pacientes diagnosticados. De los pacientes se conocen datos como la edad (número entero), color de piel(negra, blanca, mestiza), y otros atributos. Algunos de estos atributos son numéricos y otros son categorías nominales similares a color de piel.

En la tabla de abajo les dejamos un ejemplo de cada uno de los pacientes en la base de datos:

En la tabla, se aprecia el conjunto de pacientes con sus atributos y la clase predictora ¿Irradiar?. Estamos en presencia de un problema de clasificación binaria que puede ser resuelto mediante algunos algoritmos de aprendizaje automático clásicos y muy conocidos. Entre estos algoritmos podemos hacer uso de: Support Vector Machine (SVM), Logistic Regression (LR), Multilayer Perceptron (MLP), Naive Bayes (NB) o Random Forest (RF). Los atributos nominales que aparecen en la tabla constituyen un problema similar que es tratado en NLP, llevar texto a números.

El proceso del aprendizaje automático

Estos algoritmos de aprendizaje automático durante el proceso de entrenamiento pueden aprender internamente que el valor 25 de la edad es menor que 50 o 40, o tal vez intuir que el 50 se aleja dos veces del valor. De alguna manera los números le dan información extra al algoritmo que apoya el proceso de inferencia, tal vez identifique alguna correlación entre la edad y el cáncer. Pero el algoritmo no sabe que el valor 25 es la edad, el valor 25 puede ser absurdamente el número de ojos que posee una persona, algo que es imposible, pero la máquina no sabe esto. Durante el aprendizaje, se logra una modificación de los parámetros internos del modelo, de manera tal que mejora el desempeño del algoritmo.

Ahora, ¿qué pasa con los valores que son nominales como el Tamaño del tumor, Color de piel, etc.? Estos valores tienen un dominio que son diferentes categorías que se le asignan al paciente en el atributo. Por ejemplo, el Color de piel toma valores como negra, mestiza y blanca. Como se aprecia no son números y de alguna manera se le debe decir al algoritmo a qué distancia está blanca, de negra o de mestiza. Para ello se realiza un proceso de transformación de los datos que nos permite llevarlos a números.

Transformación de textos a índices

Un ejemplo de transformación es discretizar la variable color de piel, donde podemos por orden de aparición o teniendo en cuenta el orden alfabético, asignar un número comenzando de 0 a N-1, siendo N el número de posibles categorías del atributo nominal.

Por ejemplo, blanca toma el valor 0, mestiza 1 y negra 2, y donde quiera que aparezca el valor toma su índice:

Transformación de textos a One-hot encoding

Otro enfoque que da más información y se puede aprovechar para representar el atributo como un vector es la transformación One-hot encoding. Esta consiste en crear un vector N-dimensional con todos los elementos en 0 y en 1 según el índice donde aparece el posible valor en el espacio de valores.

De manera análoga si tratamos con capitales del mundo, nuestra transformación se vería como sigue:

Ambas transformaciones son maneras válidas para preprocesar nuestros textos y convertirlos en números para que nuestros algoritmos funcionen.

De la teoría a la práctica

Veamos algunos ejemplos de cómo lograr las transformaciones de textos antes descritas, haciendo uso de las bibliotecas NLTK (Natural Language Toolkit) y Keras de Python.

Dado el texto de entrada: «Si no lo puedes explicar de forma simple, no lo entiendes suficientemente bien.»

Vamos a obtener las dos transformaciones:

1. Importamos las bibliotecas y métodos necesarios de Keras y NLTK.

Con Tokenizer podemos discretizar y con el método to_categorical podemos hacer One-hot encoding

import nltk
from keras.utils import to_categorical
from keras.preprocessing.text import Tokenizer

2. Convertimos el texto en un arreglo o vector separando las palabras por espacio.

paragraph = "Si no lo puedes explicar de forma simple, 
no lo entiendes suficientemente bien."
paragraph_array_sequences = nltk.word_tokenize(paragraph)
print(paragraph_array_sequences, "\n")

# Salida: 
['Si', 'no', 'lo', 'puedes', 'explicar', 'de', 'forma', 
'simple', ',', 'no', 'lo', 'entiendes', 'suficientemente',
'bien', '.'] 

3. Creamos un Tokenizer para discretizar el texto.
El método fit_on_texts crea internamente el diccionario de palabras únicas que aparece en el texto, el orden de las palabras en el diccionario determina el índice en la transformación. Todas las palabras se convierten a minúsculas.

tokenizer = Tokenizer()
tokenizer.fit_on_texts(paragraph_array_sequences)
sequences=tokenizer.texts_to_sequences(paragraph_array_sequences)
print(sequences, "\n")

# Salida: 
[[3], [1], [2], [4], [5], [6], [7], [8], [], [1], [2], 
[9], [10], [11], []] 

Cabe resaltar que texts_to_sequences ignora los signos de puntuación como el «.» y la «,» que contiene el texto por lo que aparecen como arreglos vacíos.

4. Obteniendo la transformación a índices final sin los signos de puntuación.

transformation = [token[0] for token in sequences if len(token)>0]
print(transformation, "\n")

# Salida:
[3, 1, 2, 4, 5, 6, 7, 8, 1, 2, 9, 10, 11] 

5. Reutilizamos la transformación anterior para obtener el One-hot encoding en forma de matriz.

one_hot=to_categorical(transformation)
print(one_hot)

# Salida:
[[0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]
  [0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]

Con esto ya hemos aprendido a transformar textos a una forma numérica que la máquina puede interpretar y en este punto aplicar nuestros algoritmos. Aunque existen otras formas para enriquecer más la información del texto de manera numérica teniendo en cuenta la distribución de las palabras o su contexto. Esperamos que le haya sido de utilidad este post.