Mapas autoorganizativos: Una guía intuitiva con ejemplos en Python

Configurar el entorno para SOM

Antes de construir el SOM, tenemos que preparar el entorno con los paquetes necesarios. 

Instalar bibliotecas Python 

Necesitamos estos paquetes: 

• MiniSom es una herramienta de Python basada en NumPy que crea y entrena SOMs. 
• NumPy se utiliza para acceder a funciones matemáticas como dividir matrices, obtener valores únicos, etc. 
• matplotlib se utiliza para trazar diversos gráficos y diagramas para visualizar los datos. 
• El paquete datasets de sklearn se utiliza para importar conjuntos de datos sobre los que aplicar el SOM .
• El paquete MinMaxScaler de sklearn normaliza el conjunto de datos .

El siguiente fragmento de código importa estos paquetes: 

from minisom import MiniSom
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.preprocessing import MinMaxScaler

Preparar el conjunto de datos

En este tutorial, utilizamos MiniSom para construir un SOM y luego lo entrenamos con el conjunto de datos canónico IRIS. Este conjunto de datosconsta de 3 clases de plantas de iris. Cada clase tiene 50 instancias. Para preparar los datos, seguimos estos pasos: 

• Importa el conjunto de datos Iris de sklearn,
• Extrae los vectores de datos y los escalares objetivo. 
• Normaliza los vectores de datos. En este tutorial, utilizamos el MinMaxScaler de scikit-learn. 
• Declara un conjunto de etiquetas para cada una de las tres clases de plantas Iris. 

El siguiente código implementa estos pasos: 

dataset_iris = datasets.load_iris()
data_iris = dataset_iris.data
target_iris = dataset_iris.target
data_iris_normalized = MinMaxScaler().fit_transform(data_iris)
labels_iris = {1:'1', 2:'2', 3:'3'}
data = data_iris_normalized
target = target_iris

Implementación de mapas autoorganizativos (SOM) en Python

Para implementar un SOM en Python, definimos e inicializamos la malla antes de entrenarla con el conjunto de datos. A continuación, podemos visualizar las neuronas entrenadas y el conjunto de datos agrupados. 

Definir la malla SOM

Como ya se ha explicado, un SOM es una red de neuronas. Con MiniSom podemos crear cuadrículas bidimensionales. Las dimensiones X e Y de la cuadrícula son el número de neuronas a lo largo de cada eje. Para definir la malla SOM, también tenemos que especificar:

• Las dimensiones X e Y de la cuadrícula
• El número de variables de entrada: es el número de filas de datos. 

Declara estos parámetros como constantes de Python:

SOM_X_AXIS_NODES  = 8
SOM_Y_AXIS_NODES  = 8
SOM_N_VARIABLES  = data.shape[1]

El código de ejemplo que aparece a continuación ilustra cómo declarar la rejilla utilizando MiniSom:

som = MiniSom(SOM_X_AXIS_NODES, SOM_Y_AXIS_NODES, SOM_N_VARIABLES)

Los dos primeros parámetros son el número de neuronas a lo largo de los ejes X e Y, y el tercer parámetro es el número de variables. 

Declaramos otros parámetros e hiperparámetros al crear la malla SOM. Los explicaremos más adelante en el tutorial. De momento, declara estos parámetros como se muestra a continuación: 

ALPHA = 0.5
DECAY_FUNC = 'linear_decay_to_zero'
SIGMA0 = 1.5
SIGMA_DECAY_FUNC = 'linear_decay_to_one'
NEIGHBORHOOD_FUNC = 'triangle'
DISTANCE_FUNC = 'euclidean'
TOPOLOGY = 'rectangular'
RANDOM_SEED = 123

Crea un SOM utilizando estos parámetros:

som = MiniSom(
        SOM_X_AXIS_NODES,
        SOM_Y_AXIS_NODES,
        SOM_N_VARIABLES,
        sigma=SIGMA0,
        learning_rate=ALPHA,
        neighborhood_function=NEIGHBORHOOD_FUNC,
        activation_distance=DISTANCE_FUNC,
        topology=TOPOLOGY,
        sigma_decay_function = SIGMA_DECAY_FUNC,
        decay_function = DECAY_FUNC,
        random_seed=RANDOM_SEED,
        )

Inicializar las neuronas

El comando anterior crea un SOM con pesos aleatorios para todas las neuronas. Inicializar las neuronas con pesos extraídos de los datos (en lugar de números aleatorios) puede hacer que el proceso de entrenamiento sea más eficaz. 

Cuando se utiliza MiniSom para crear un Mapa Autoorganizado (SOM), hay dos formas de inicializar los pesos de las neuronas en función de los datos:

• Inicialización aleatoria: Los pesos iniciales de las neuronas se extraen aleatoriamente de los datos de entrada. Para ello, aplicamos la función .random_weights_init() al SOM .
• Inicialización del PCA: La inicialización del Análisis de Componentes Principales (ACP) utiliza los componentes principales de los datos de entrada depara inicializar los pesos. Los pesos iniciales de las neuronas abarcan los dos primeros componentes principales. Esto suele conducir a una convergencia más rápida. 

En esta guía, utilizamos la inicialización PCA. Para aplicar la inicialización PCA a los pesos SOM, utiliza la función .pca_weights_init() como se muestra a continuación:

som.pca_weights_init(data)

Entrenamiento del SOM

El proceso de entrenamiento actualiza los pesos del SOM para minimizar la distancia entre las neuronas y los puntos de datos. 

A continuación, explicamos el proceso de entrenamiento iterativo:

• Inicialización: Los vectores de peso de todas las neuronas se inicializan, normalmente con valores aleatorios. También es posible inicializar los pesos muestreando la distribución de los datos de entrada.
• Selección de entrada: Se selecciona (aleatoriamente) un vector de entrada del conjunto de datos de entrenamiento.
• Identificación de la BMU: La neurona con el vector de pesos más cercano al vector de entrada se identifica como la BMU. 
• Actualización del barrio: La BMU y sus neuronas vecinas actualizan sus vectores de peso. El ritmo de aprendizaje y la función de vecindad deciden qué neuronas se actualizan y en qué medida. En el paso de iteración tdado el vector de entrada xel vector peso de la neurona i como w_ila tasa de aprendizaje (t)y la función de vecindad h_bi (esta función cuantifica el grado de actualización de la neurona i dada la neurona BMU b), la fórmula de actualización del peso de la neurona i se expresa como
• Tasa de decaimiento de la tasa de aprendizaje y radio de vecindad: Tanto la velocidad de aprendizaje como el radio de vecindad disminuyen con el tiempo. En las primeras iteraciones, el proceso de entrenamiento realiza ajustes mayores en un vecindario más amplio. Las iteraciones posteriores ayudan a afinar los pesos realizando cambios más pequeños en los pesos de las neuronas adyacentes. Esto permite que el mapa se estabilice y converja. 

Para entrenar el SOM, presentamos el modelo con los datos de entrada. Podemos elegir uno de los dos enfoques para hacerlo: 

• Elige muestras al azar de los datos de entrada. La función .train_random() pone en práctica esta técnica .
• Recorre secuencialmente los vectores de los datos de entrada. Esto se hace utilizando la función .train_batch().

Estas funciones aceptan como parámetros los datos de entrada y el número de iteraciones. En esta guía utilizamos la función .train_random() . Declara el número de iteraciones como una constante y pásalo a la función de entrenamiento: 

N_ITERATIONS = 5000
som.train_random(data, N_ITERATIONS, verbose=True)  

Tras ejecutar el script y completar el entrenamiento, aparece un mensaje con el error de cuantización:

quantization error: 0.05357240680504421 

El error de cuantización indica la cantidad de información que se pierde cuando el SOM cuantiza (reduce la dimensionalidad) los datos. Un error de cuantización grande indica una mayor distancia entre las neuronas y los puntos de datos. También significa que la agrupación es menos fiable. 

Visualización de las neuronas SOM 

Ahora tenemos un modelo SOM entrenado. Para visualizarlo, utilizamos un mapa de distancias (también conocido como U-matrix). El mapa de distancias muestra las neuronas del SOM como una cuadrícula de celdas. El color de cada célula representa su distancia a las neuronas vecinas. 

El mapa de distancias es una cuadrícula con las mismas dimensiones que el SOM. Cada celda del mapa de distancias es la suma normalizada de las distancias (euclidianas) entre una neurona y sus vecinas. 

Accede a SOM distance map utilizando la función .distance_map(). Para generar la matriz U, seguimos estos pasos:

• Utiliza pyplot para crear una figura con las mismas dimensiones que el SOM. En este ejemplo, las dimensiones son 8x8. 
• Traza el mapa de distancias con matplotlib utilizando la función .pcolor(). En este ejemplo, utilizamos gist_yarg como esquema de color. 
• Muestra el colorbar, un índice que asigna diferentes colores a diferentes valores escalares. En este caso, como las distancias están normalizadas, los valores escalares de distancia van de 0 a 1. 

El código siguiente implementa estos pasos: 

# create the grid
plt.figure(figsize=(8, 8))
#plot the distance map
plt.pcolor(som.distance_map().T, cmap='gist_yarg') 
# show the color bar
plt.colorbar()
plt.show()

En este ejemplo, la matriz U utiliza un esquema de colores monótono. Se puede entender siguiendo estas pautas:

• Los tonos más claros representan neuronas muy próximas entre sí, y los más oscuros, neuronas más alejadas unas de otras. 
• Los grupos de tonos más claros pueden interpretarse como agrupaciones. Los nodos oscuros entre los conglomerados pueden interpretarse como los límites entre conglomerados. 

Figura 1: Matriz U del SOM entrenado en el conjunto de datos Iris (imagen del autor)

Evaluación de los resultados de la agrupación SOM

La figura anterior ilustraba gráficamente las neuronas del SOM. En esta sección, mostramos cómo visualizar la forma en que el SOM agrupó los datos. 

Identificación de agrupaciones

Superponemos marcadores sobre la matriz en U anterior para denotar qué clase de planta Iris representa cada célula (neurona). Para ello:

• Como antes, crea una figura de 8x8 utilizando pyplot, traza el mapa de distancias y muestra la barra de colores .
• Especifica una matriz de tres marcadores matplotlib, uno para cada clase de planta Iris. 
• Especifica una matriz de tres códigos de color matplotlib, uno para cada clase de planta Iris.
• Traza iterativamente la neurona ganadora para cada punto de datos:
• Determina la (coordenadas de la) neurona ganadora para cada punto de datos utilizando la función .winner(). 
• Traza la posición de cada neurona ganadora en el centro de cada celda de la cuadrícula. w[0] y w[1] dan las coordenadas X e Y de la neurona, respectivamente. Se añade un valor de 0,5 a cada coordenada para trazarla en el centro de la celda. 

El código siguiente muestra cómo hacerlo:

# plot the distance map
plt.figure(figsize=(8, 8))
plt.pcolor(som.distance_map().T, cmap='gist_yarg') 
plt.colorbar()
# create the markers and colors for each class
markers = ['o', 'x', '^']
colors = ['C0', 'C1', 'C2']
# plot the winning neuron for each data point
for count, datapoint in enumerate(data):
    # get the winner
    w = som.winner(datapoint)  
    # place a marker on the winning position for the sample data point
    plt.plot(w[0]+.5, w[1]+.5, markers[target[count]-1], markerfacecolor='None',
             markeredgecolor=colors[target[count]-1], markersize=12, markeredgewidth=2)
plt.show()

La imagen resultante se muestra a continuación: 

Figura 2: Matriz U superpuesta con marcadores de clase (imagen del autor)

Según la documentación del conjunto de datos Iris, "una clase es linealmente separable de las otras 2; estas últimas no son linealmente separables entre sí". En la matriz U anterior, estas tres clases están representadas por tres marcadores: triángulo, círculo y cruz. 

Observa que no hay un límite claro entre los círculos azules y las cruces naranjas. Además, en muchas células se superponen dos clases en la misma neurona. Esto significa que la neurona es equidistante de ambas clases. 

Visualizar el resultado de la agrupación

Un SOM es un modelo de agrupación. Los puntos de datos similares se asignan a la misma neurona. Los puntos de datos de la misma clase se asignan a un grupo de neuronas vecinas. Trazamos todos los puntos de datos en la cuadrícula SOM para estudiar mejor el comportamiento de agrupación. 

Los pasos siguientes describen cómo crear este gráfico de dispersión:

• Obtén las coordenadas X e Y de la neurona ganadora para cada punto de datos. 
• Traza el mapa de distancias, como hicimos para la figura 1.
• Utiliza plt.scatter() para hacer un diagrama de dispersión de todas las neuronas ganadoras para cada punto de datos. Añade un desplazamiento aleatorio a cada punto para evitar solapamientos entre puntos de datos dentro de la misma celda.

Ejecutamos estos pasos en el código siguiente: 

# get the X and Y coordinates of the winning neuron for each data pointw_x, w_y = zip(*[som.winner(d) for d in data])
w_x = np.array(w_x)
w_y = np.array(w_y)
# plot the distance map
plt.figure(figsize=(8, 8))
plt.pcolor(som.distance_map().T, cmap='gist_yarg', alpha=.2)
plt.colorbar()
# make a scatter plot of all the winning neurons for each data point
# add a random offset to each point to avoid overlaps
for c in np.unique(target):
    idx_target = target==c
    plt.scatter(w_x[idx_target]+.5+(np.random.rand(np.sum(idx_target))-.5)*.8,
                w_y[idx_target]+.5+(np.random.rand(np.sum(idx_target))-.5)*.8,
                s=50, 
                c=colors[c-1], 
                label=labels_iris[c+1]
                )
plt.legend(loc='upper right')
plt.grid()
plt.show()

El siguiente gráfico muestra el diagrama de dispersión de salida:

Figura 3: Diagrama de dispersión de los puntos de datos dentro de las celdas (imagen del autor)

En el diagrama de dispersión anterior, observa que 

• Algunas células contienen puntos azules y naranjas. 
• Los puntos verdes están claramente separados del resto de los datos, pero los puntos azules y naranjas no están claramente separados. 
• Las observaciones anteriores coinciden con el hecho de que sólo uno de los tres grupos del conjunto de datos Iris tiene un límite claro. 
• En Figura 1los nodos oscuros entre los conglomerados (que pueden interpretarse como los límites entre conglomerados) coinciden con las celdas vacías del diagrama de dispersión.

Puedes acceder al código completo y ejecutarlo en este cuaderno DataLab. 

Ajuste del modelo SOM

Las secciones anteriores mostraban cómo crear y entrenar un modelo SOM y cómo estudiar los resultados visualmente. En esta sección, tratamos cómo ajustar el rendimiento de los modelos SOM. 

Hiperparámetros clave a ajustar

Como ocurre con cualquier modelo de aprendizaje automático, los hiperparámetros influyen considerablemente en el rendimiento del modelo. 

Algunos de los hiperparámetros importantes en el entrenamiento de los SOM son:

• El tamaño de la cuadrícula decide el tamaño del mapa. El número de neuronas de un mapa con un tamaño de cuadrícula de AxB es A*B. 
• La tasa de aprendizaje decide cuánto cambian los pesos en cada iteración. Fijamos la tasa de aprendizaje inicial, y ésta disminuye con el tiempo según la función de decaimiento. 
• La función de decaimiento decide en qué medida disminuye el ritmo de aprendizaje en cada iteración posterior.
• La función de vecindad es una función matemática que especifica qué neuronas deben considerarse vecinas de la BMU.
• La desviación típica especifica la dispersión de la función de vecindad. Por ejemplo, una función de vecindad gaussiana con una desviación típica elevada tendrá una vecindad mayor que la misma función con una desviación típica menor. Fijamos la desviación típica inicial, que disminuye con el tiempo según la función de decaimiento sigma. 
• El decaimiento sigma controla cuánto se reduce la desviación típica en cada iteración posterior.
• El número de iteraciones de entrenamiento decide cuántas veces se actualizan los pesos. En cada iteración de entrenamiento, los pesos de las neuronas se actualizan una vez. 
• La función distancia es una función matemática que calcula la distancia entre neuronas y puntos de datos.
• La topología decide la disposición de la estructura de la rejilla. Las neuronas de la rejilla pueden disponerse en forma rectangular o hexagonal. 

En la siguiente sección, discutiremos las directrices para establecer los valores de estos hiperparámetros. 

Impacto del ajuste de los hiperparámetros

Los valores de los hiperparámetros deben decidirse en función del modelo y del conjunto de datos. Hasta cierto punto, determinar estos valores es un proceso de ensayo y error. En esta sección, damos pautas para afinar cada hiperparámetro. Junto a cada hiperparámetro, mencionamos (entre paréntesis) las respectivas constantes Python utilizadas en el código de ejemplo.

• Tamaño de la cuadrícula (SOM_X_AXIS_NODES y SOM_X_AXIS_NODES): El tamaño de la cuadrícula depende del tamaño del conjunto de datos. La regla general es que, dado un conjunto de datos de tamaño N, la cuadrícula debe contener aproximadamente 5*sqrt(N) neuronas. Por ejemplo, si el conjunto de datos tiene 150 muestras, la cuadrícula debe contener 5*sqrt(150) = aproximadamente 61 neuronas. En este tutorial, el conjunto de datos Iris tiene 150 filas y utilizamos una cuadrícula de 8x8. 
• Tasa de aprendizaje inicial (ALPHA): Una tasa más alta acelera la convergencia, mientras que las tasas más bajas se utilizan para ajustes más finos después de las primeras iteraciones. La tasa de aprendizaje inicial debe ser lo suficientemente grande como para permitir una adaptación rápida, pero no tanto como para sobrepasar los valores óptimos de peso. En este artículo, la tasa de aprendizaje inicial es 0,5. 
• Desviación típica inicial (SIGMA0): Determina el tamaño inicial o la extensión del barrio. Un valor mayor considera patrones más globales. En este ejemplo, utilizamos una desviación típica inicial de 1,5. 
• Para la tasa de desintegración (DECAY_FUNC ) y la tasa de decaimiento sigma (SIGMA_DECAY_FUNC ), podemos elegir entre uno de los tres tipos de funciones de decaimiento :
• Decaimiento inverso: Esta función es adecuada si los datos tienen patrones tanto globales como locales. En estos casos, necesitamos una fase más larga de aprendizaje general antes de centrarnos en los patrones locales. 
• Decaimiento lineal: Esto es bueno para conjuntos de datos en los que queremos una reducción constante y uniforme del tamaño del vecindario o de la tasa de aprendizaje. Esto es útil si los datos no necesitan mucho ajuste.
• Decaimiento asintótico: Esta función es útil si los datos son complejos y de alta dimensión. En estos casos, es mejor dedicar más tiempo a la exploración global antes de pasar gradualmente a detalles más finos. 
• Función de vecindad (NEIGHBORHOOD_FUNC): La elección por defecto de la función de vecindad es la función gaussiana. También se utilizan otras funciones, como se explica a continuación. 
• Gaussiano (por defecto): Se trata de una curva en forma de campana. El grado de actualización de una neurona disminuye suavemente a medida que aumenta su distancia a la neurona ganadora. Proporciona una transición suave y continua y preserva la topología de los datos. Es adecuado para la mayoría de los fines generales debido a su comportamiento estable y predecible.
• Burbuja: Esta función crea un barrio de anchura fija. Todas las neuronas dentro de este vecindario se actualizan por igual, y las neuronas fuera de este vecindario no se actualizan (para un punto de datos dado). Es computacionalmente más barato y más fácil de aplicar. Es útil para mapas más pequeños en los que los límites nítidos de los vecindarios no comprometen una agrupación eficaz. 
• Sombrero mexicano: Tiene una región central positiva rodeada de una región negativa. Las neuronas cercanas a la BMU se actualizan para acercarse al punto de datos, y las neuronas más alejadas se actualizan para alejarse del punto de datos. Esta técnica mejora el contraste y hace más nítidas las características del mapa. Como hace hincapié en los clusters distintos, es eficaz en tareas de reconocimiento de patrones en las que se desea una separación clara de los clusters.
• Triángulo: Esta función define el tamaño del vecindario como un triángulo, en el que la BMU tiene la mayor influencia. Disminuye linealmente con la distancia a la BMU. Se utiliza para agrupar datos con transiciones graduales entre conglomerados o características, como datos de imágenes, voz o series temporales, en los que se espera que los puntos de datos vecinos compartan características similares. 
• Función de distancia (DISTANCE_FUNC): Para medir la distancia entre las neuronas y los puntos de datos, podemos elegir entre 4 métodos:
• Distancia euclidiana (opción por defecto): Útil cuando los datos son continuos y queremos medir la distancia en línea recta. Se adapta a la mayoría de las tareas generales, especialmente cuando los puntos de datos están distribuidos uniformemente y relacionados espacialmente.
• Distancia coseno: Buena elección para texto o datos dispersos de alta dimensión en los que el ángulo entre vectores es más importante que la magnitud. Es útil para comparar la direccionalidad de los datos.
• Distancia a Manhattan: Ideal cuando los puntos de datos están en una rejilla o celosía (por ejemplo, manzanas de una ciudad). Es menos sensible a los valores atípicos que la distancia euclidiana.
• Distancia de Chebyshev: Adecuado para situaciones en las que el movimiento puede producirse en cualquier dirección (por ejemplo, distancias de tablero de ajedrez). Es útil para espacios discretos en los que queremos priorizar la máxima diferencia de ejes.
• Topología (TOPOLOGY): En una rejilla, las neuronas pueden disponerse en una estructura hexagonal o rectangular: 
• Rectangular (por defecto): cada neurona tiene 4 vecinas inmediatas. Es la opción adecuada cuando los datos no tienen una relación espacial clara. También es computacionalmente más sencillo. 
• Hexagonal: cada neurona tiene 6 vecinas. Ésta es la opción preferida si los datos tienen relaciones espaciales mejor representadas con una rejilla hexagonal. Éste es el caso de las distribuciones de datos circulares o angulares.
• Número de iteraciones de entrenamiento (N_ITERATIONS): En principio, tiempos de entrenamiento más largos conducen a errores más bajos y a una mejor alineación de los pesos con los datos de entrada. Sin embargo, el rendimiento del modelo aumenta asintóticamente con el número de iteraciones. Así, tras un cierto número de iteraciones, el aumento de rendimiento de las interacciones posteriores es sólo marginal. Decidir el número correcto de iteraciones requiere cierta experimentación. En este tutorial, entrenamos el modelo durante 5000 iteraciones. 

Para determinar la configuración adecuada de los hiperparámetros, recomendamos experimentar con varias opciones en un subconjunto más pequeño de datos.

Conclusión

Los mapas autoorganizados son una herramienta robusta para el aprendizaje no supervisado. Se utilizan para la agrupación, la reducción de la dimensionalidad, la detección de anomalías y la visualización de datos. Como conservan las propiedades topológicas de los datos de alta dimensión y los representan en una cuadrícula de dimensión inferior, los SOM facilitan la visualización e interpretación de conjuntos de datos complejos. 

Este tutorial trata los principios subyacentes de los SOM y muestra cómo implementar un SOM utilizando la biblioteca MiniSom Python. También demostró cómo analizar visualmente los resultados y explicó los hiperparámetros importantes utilizados para entrenar los SOM y ajustar su rendimiento.