La Regresión Multiclase con Python y Keras

En este tutorial veremos cómo implementar un clasificador multiclase usando Python y la librería Keras.

Para ello usaremos el set de datos “Iris”, que contiene 150 datos correspondientes a mediciones realizadas sobre la flor perteneciente a la especie Iris. Para cada uno de estos datos se realizaron las siguientes mediciones: longitud del sépalo, ancho del sépalo, longitud del pétalo y ancho del pétalo.

Al final del tutorial se encuentra el enlace para descargar el set de datos y el código fuente.

El set de datos

El set “Iris” fue creado en 1936 por el biólogo Ronald Fisher, y contiene 150 datos provenientes de tres variedades de flores de la especie Iris.

Los 150 datos de este set provienen de tres especies de flores: Iris setosa, Iris virginica e Iris versicolor.

Por su parte, cada uno de los datos está representado con cuatro características: longitud y ancho del pétalo, y longitud y ancho del sépalo. Para esta implementación usaremos sólo dos de estas características (la longitud y el ancho del sépalo).

El problema a resolver

Para clasificar el set de datos usaremos un modelo de Regresión Multiclase implementado en Keras.

Cada dato tendrá dos características de entrada (‘SepalLengthCm’, ‘SepalWidthCm’) y será clasificado en una de tres posibles categorías (‘Iris-setosa’, ‘Iris-versicolor’ o ‘Iris-virginica’).

En la figura de abajo se muestra la forma como están distribuidos los datos:

Como podemos ver, la categoría Iris setosa (en rojo) es fácilmente diferenciable. Por otra parte la frontera de decisión entre Iris versicolor (violeta) e Iris virginica (gris) no está claramente definida.

Veamos ahora cómo implementar y verificar el funcionamiento de este modelo de Regresión Multiclase en Keras.

Lectura y visualización del set de datos

La lectura de los datos (almacenados en formato .csv) la realizaremos usando la librería Pandas. En particular únicamente usaremos las columnas 1 (‘SepalLengthCm’), 2 (‘SepalWidthCm’) y 5 (‘Species’):

import pandas as pd
datos = pd.read_csv('Iris.csv',usecols=[1,2,5])

Los datos de entrada al modelo (X) así como la categoría a la que pertenece cada dato (Y) serán almacenados en arreglos de NumPy:

import numpy as np
X = datos.iloc[:,0:2].values
Y_str = datos.iloc[:,2].values

donde «Y_str» contiene el nombre de la categoría a la que pertenece cada dato.

Antes de graficar los resultados debemos representar estas categorías de forma numérica (Iris-setosa: categoría “0”; Iris-versicolor: categoría “1”; Iris-virginica: categoría “2”). Lo anterior se logra usando la función «LabelEncoder» de la librería scikit-learn:

from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
encoder.fit(Y_str)
Y_num = encoder.transform(Y_str)

siendo «Y_num» el arreglo NumPy con la representación numérica de las categorías para cada uno de los 150 datos.

A continuación debemos realizar el pre-procesamiento de los datos para poderlos introducir al modelo implementado en Keras.

Representación one-hot de los datos

«Y_num», el arreglo calculado anteriormente, contiene 150 etiquetas para cada uno de los datos de entrada.

Sin embargo, antes de realizar el entrenamiento del modelo, es necesario modificar la manera como están representadas estas categorías. En particular, cada una debe ser representada de una forma equivalente:

$$“0” \rightarrow (1,0,0)$$
$$“1” \rightarrow (0,1,0)$$
$$“2” \rightarrow (0,0,1)$$

La anterior representación recibe el nombre de one-hot, que es una forma de codificar variables categóricas, y que permite calcular correctamente la función de pérdida usada en la Regresión Multiclase.

Para obtener esta representación se requiere el módulo «np_utils» de Keras:

from keras.utils import np_utils
n_clases = 3
Y = np_utils.to_categorical(Y_num,n_clases)

donde «Y» es el arreglo que contiene las categorías codificadas correctamente.

Una vez realizado el pre-procesamiento, podemos implementar el modelo en Keras.

Creación del modelo

En primer lugar definimos las dimensiones de cada dato de entrada y de la salida. Adicionalmente reiniciamos la semilla del generador aleatorio para la reproducibilidad del entrenamiento («np.random.seed»):

np.random.seed(1)
input_dim = X.shape[1]     # Dimensión de entrada: 2
output_dim = Y.shape[1]    # Dimensión de salida: 3

A continuación, creamos el contenedor y agregamos elementos al modelo usando los módulos «Sequential» y «Dense» de Keras, así como el método «add»:

from keras.models import Sequential
from keras.layers import Dense

modelo = Sequential()
modelo.add(Dense(output_dim, input_dim=input_dim, activation='softmax'))

donde en la última línea hemos definido la función de activación softmax («activation = ‘softmax'») requerida por el algoritmo de Regresión Multiclase.

Por último, definamos el optimizador Gradiente Descendente y su tasa de aprendizaje (0.1). Adicionalmente, especificamos la función de error (entropía cruzada) y la métrica de desempeño (exactitud):

from keras.optimizers import SGD

sgd = SGD(lr=0.1)
modelo.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

Una vez creado el modelo, podemos realizar el aprendizaje de los parámetros.

Entrenamiento

En esta etapa usaremos un total de 2000 iteraciones y un «batch_size» igual al número total de datos (150).

El modelo se entrena usando el método «fit»:

n_its = 2000
batch_size = X.shape[0]
historia = modelo.fit(X,Y,epochs=n_its,batch_size=batch_size,verbose=2)

Cuando ejecutamos el código veremos que la exactitud del clasificador varía desde un 33% en la primera iteración hasta un 80% en la última.

Veamos en detalle cuáles son los resultados de este entrenamiento y el desempeño del modelo.

Resultados

En primer lugar analicemos el comportamiento de la pérdida y de la exactitud del modelo a medida que avanzan las iteraciones:

Se evidencia que hay una reducción del error y un aumento en la precisión del clasificador a medida que se incrementa el número de iteraciones.

Por otra parte, en la figura de abajo se muestran las fronteras de decisión obtenidas al final del entrenamiento:

Podemos observar que los datos correspondientes a la categoría “0” son clasificados con una alta precisión. De hecho, tan solo hay un error, correspondiente al punto rojo ubicado en la región de color morado.

Finalmente, la clasificación de las categorías “1” y “2” tiene una menor precisión, debido a que estas no son linealmente separables. Lo anterior pone en evidencia una de las principales limitaciones de la Regresión Multiclase, que permite obtener únicamente fronteras de decisión lineales.

Enlace de descarga set de datos y código fuente

▼ El notebook y el set de datos de este tutorial

Conclusión

En este tutorial hemos visto un ejemplo de implementación del algoritmo de Regresión Multiclase en Keras.

Y como lo acabamos de analizar, se trata de un algoritmo que arroja fronteras de decisión lineales. Así que si tenemos un set de datos más complejo que el usado en este tutorial, es decir con fronteras de decisión no lineales, tendremos que recurrir a modelos más sofisticados como las Redes Neuronales para lograr clasificar correctamente los datos.

Si te interesa aprender cómo funcionan estas Redes Neuronales y ver de forma práctica cómo usarlas para resolver diferentes tipos de problemas, te invito a darle una mirada al curso Fundamentos de Deep Learning con Python disponible en la Academia Online.

Así que para finalizar, resumamos los aspectos más importantes a tener en cuenta con respecto a esta Regresión Multiclase:

• El módulo «LabelEncoder» de la librería scikit-learn permite convertir las etiquetas de salida del formato string a una representación numérica.
• Posteriormente, las etiquetas de salida obtenidas son transformadas al formato one-hot usando el módulo «np_utils» de Keras.
• Los módulos «Sequential» y «Dense» permiten crear el contenedor y los elementos característicos del modelo.
• Finalmente, es importante observar que las fronteras de decisión son lineales, lo cual es una limitación del algoritmo de Regresión Multiclase. Es por este motivo que la exactitud del clasificador no supera el 80%.