Versión anterior de este tutorial
Página principal del grupo GeNeura
Tutorial sobre metaheurísticas

Mapa autoorganizativo de Kohonen

J. J. Merelo

Los mapas autoorganizativos de Kohonen son un algoritmo, a veces agrupado dentro de las redes neuronales, que a partir de un proceso iterativo de comparación con un conjunto de datos y cambios para aproximarse a los mismos, crea un modelo de esos mismos datos que puede servir para agruparlos por criterios de similitud; adicionalmente, este agrupamiento se produce de forma que la proyección de estos datos sobre el mapa distribuya sus características de una forma gradual. El Mapa de Kohonen, SOM (self-organizing map, mapa autoorganizativo) o SOFM (self-organizing feature map, mapa autoorganizado de características) se usa para diferentes aplicaciones:

Los SOMs son algoritmos no-supervisados: eso quiere decir que no usan la etiqueta de clase de los datos para el entrenamiento; sin embargo, en la mayor parte de los casos se usa algún tipo de etiqueta para visualizar los datos correctamente. Se denominan también algoritmos competitivos porque en el entrenamiento se entrena una sola "neurona" de cada vez, lo cual significa que la representación de cada zona del espacio de entrada está concentrada por neuronas, no distribuida (como suele suceder en otras redes neuronales tales como el perceptrón multicapa).

Hasta el momento, ha habido cientos de aplicaciones de los mapas autoorganizativos de Kohonen, muchas de ellas en Biocomputación. En este tutorial se tratará de dar un enfoque práctico al uso de los mapas de Kohonen en biocomputación, aplicándolo a problemas comunes en el área y usando herramientas habituales en la misma

En los siguientes apartados trataremos de colocar el mapa de Kohonen en el contexto de otras familias de algoritmos, viendo qué añaden al concepto básico de cada uno de ellos, y cómo se puede usar para ese tipo de aplicaciones.

Los algoritmos de clasificación no supervisados son aquellos que no requieren etiquetado de cada uno de los vectores de entrada; se suelen llamar también algoritmos auto-asociativos, porque asocian entradas a ellas mismas. Una buena explicación de estos algoritmos se halla en la FAQ de redes neuronales.

El tipo más común de algoritmos de aprendizaje o clasificación no supervisada son los algoritmos de análisis de grupos o clustering; estos algoritmos tratan de dividir las muestras del conjunto de entrada en una serie de grupos con características comunes. Un algoritmo debe descubrir cuáles son estos clusters, pero también cuáles son las características que define ese cluster y cuántos clusters hay; pero éste último es un problema que no tiene solución fácil.

Dentro de las redes neuronales, uno de los métodos no supervisados más comunes es precisamente el SOM, pero hay otro método denominado aprendizaje hebbiano que usa una red monocapa, con pesos conectando las entradas a las salidas, y aumentarndo el valor de los pesos que unen a dos neuronas si se activan a la vez, y disminuir el valor si se activan de forma diferencial. Una red hebbiana se puede disponer en una sola capa o varias: las entradas se propagan a la capa interna, y a la salida, y tras la propagación, se cambian los pesos de la forma indicada. El aprendizaje hebbiano equivale a un análisis de componentes principales de las entradas, según ha sido probado recientemente.

Una red neuronal supervisada tal como el perceptrón multicapa se puede convertir en no supervisada usando las entradas como salidas; de esta forma, la capa interna extraerá los componentes principales de las entradas, y se podrá usar, por ejemplo, como memoria asociativa; o bien, analizando las activaciones de la capa interna, se pueden asignar diferentes grupos (clusters) a las entradas: los patrones de entrada/salida que provoquen unos patrones de activación similares pertenecerán al mismo grupo.

Los métodos no supervisados se suelen usar en lo denominado análisis de datos exploratorio, es decir, en una fase del análisis de los datos, cuando no se sabe de antemano cuáles son los grupos naturales que se forman, y se quiere visualizar la abundancia y la relación que hay entre los grupos "naturales"; se puede decir que una de sus principales aplicaciones es la visualización de datos multidimensionales, porque un algoritmo no supervisado actúa como una proyección de un espacio multidimensional a otro de dimensiones visualizables. También se pueden usar como fase inicial de algoritmos de aprendizaje supervisados: un algoritmo como el k-medias o el mismo SOM se pueden usar para inicializar algoritmos de aprendizaje supervisado tales como el LVQ (Learning Vector Quantization).

Como al mapa de Kohonen no le falta más que el volante forrado de leopardo, también puede usarse para proyección multidimensional, como hemos visto que sucede con los algoritmos de aprendizaje no supervisado. En realidad, es un método de proyección no lineal; los métodos lineales, tales como el análisis de componentes principales, tratan de hallar un subespacio de pocas dimensiones que contenga la máxima varianza de la muestra de entrada; una vez hallado, se pueden proyectar las muestras sobre ese espacio, y usarlas para clasificación supervisada. El Análisis de Componentes Principales proyecta el conjunto de datos a un espacio de dimensión inferior que incluya la mayor parte de la variancia de la muestra, idealmente tanta como sea posible.

Sin embargo, no siempre se puede proyectar linealmente a unas pocas dimensiones, y hay que usar sistemas de proyección no lineal. Uno de ellos es el denominado escalado multidimensional (Multidimensional scaling, MDS), que usa las distancias entre los diferentes elementos de la muestra y trata de proyectarlos a un espacio de dimensión inferior, habitualmente dos. Este algoritmo trata de mantener las relaciones topológicas, igual que lo hace el algoritmo denominado mapa de Sammon, un algoritmo que proyecta a dos dimensiones un conjunto de datos n-dimensional, manteniendo las relaciones métricas (es decir, lo que esté cerca en n-dimensiones debe estar también cerca en 2 dimensiones).

Últimamente han surgido algoritmos más potentes, como el análisis de componentes curvilíneos, desarrollado a partir del mapa de Kohonen, y que mejora el mapa de Sammon en el sentido que favorece la reproducción de distancias cortas en la proyección con respecto a las distancias largas. Esta proyección multidimensional permite visualizar los datos con mucha más facilidad, y al eliminar componentes innecesarios, permite aplicarle algoritmos de clustering o clasificación mucho más fácilmente.

Tras esta introducción y contextualización, vamos a ver exactamente cómo funciona el mapa de Kohonen, y como podemos usarlo.

Contenido de esta sección
  • Introducción teórica
  • Preprocesado de los datos
  • Implementación

Un mapa de Kohonen es un conjunto de vectores de dimensión n distribuidos habitualmente en una retícula bidimensional (aunque nada impide que se distribuyan en 3 o más dimensiones). Para cada vector (al que a veces llamaremos nodo o neurona) se define un vecindario: cada vector puede tener 8 vecinos (es decir, una retícula rectangular) o 6 (retícula hexagonal). Hay razones teóricas para preferir una u otra; mientras que la más popular es la rectangular, la hexagonal tiene una base teórica más sólida.

[Vectores dispuestos hexagonalmente] [Vectores dispuestos de forma rectangular]

La vecindad tiene otro parámetro: la forma de la función por la que se cambian los valores de los vectores que hay en ella: una forma tipo gaussiana (gaussian) hara que el cambio de valores disminuya con la distancia, mientras que una forma tipo burbuja (bubble) cambiará de la misma forma todos los vectores que pertenezcan a la vecindad.

Para entrenar un mapa de Kohonen, primero hay que tener un conjunto de datos, que se dividirá en tres conjuntos: entrenamiento, prueba y validación. El de entrenamiento servirá precisamente para eso, el de prueba para seleccionar un mapa entre varios, y el de de validación, posteriormente, para establecer el error final, que es el que vale. Generalmente se entrena el mapa hasta alcanzar algún criterio, y se establece su error de test o prueba usando el conjunto correspondiene; esto se repite durante un número predeterminado de veces, tras los cuales se escoge el mapa con el error de prueba menor; sobre este mapa se establecerá el error de validación usando el conjunto correspondiente. Esta es solo una de las formas posibles de entrenar un mapa. Para establecer el error total de un mapa con unos parámetros determinados, se puede usar otra metodología diferente llamada dejar-k-fuera (leave-k-out): se divide el connunto de datos en k partes, se usan k-1 para entrenamiento, y una para prueba; el procedimiento se repite para las k partes en las que se ha dividido el conjunto de entrenamiento.

Rara vez los conjuntos sirven tal como los dan; suelen tener la mala costumbre de tener valores en escalas muy diferentes, variabilidades muy diferentes, e incluso algunos resulta que son categóricos. Por eso, normalmente, previamente al entrenamiento, hay que realizar algún tipo de preprocesamiento, para que todas las variables tengan aproximadamente el mismo rango y la misma desviación estándar. La forma más segura es hacer lo siguiente:

Otros preprocesos posibles son aplicar logaritmos, en caso de que el rango de variación pase por varios órdenes de magnitud, o restar el mínimo y dividir por el rango de variación, para dar diferentes variables en el rango [0,1]. Aún así, cuando se trata de variables con distribución muy desigual, los modelos que se van a hallar no son excesivamente buenos, y habría que someterlos a algún preproceso adicional, que será totalmente heurístico (es decir, con un alto porcentaje de cocina), y que incluirá eliminación de algunas variables, proceso estadístico del conjunto resultante y ejecuciones preliminares del algoritmo. La mayoría de los programas estadísticos que trabajan con algoritmos de este estilo incluyen una fase de preprocesamiento automático, que es suficiente en muchos casos.

Lo importante del preproceso es no desvirtuar las relaciones métricas entre los diferentes valores de los componentes, que pueden dar lugar a artefactos en los resultados del algoritmo. Por ejemplo, si las categorías de una variable categórica son totalmente diferentes, el vector que represente cada categoría tendrá que hacerse de forma que la distancia a todas las demás sea la misma. Sin embargo, con variables que tengan una distancia "natural", por ejemplo, variables del tipo mediano, pequeño, grande, habrá que convertirlas a números enteros, o a puntuaciones que guarden esa misma relación. Una vez más, aquí juega la experiencia y un cierto grado de cocina.

Luego, dependiendo de la aplicación, se hacen más análisis sobre los resultados. Una de las herramientas de análisis que se puede aplicar es el ya mencionado mapa o proyección de Sammon, una herramienta de proyección bidimensional para poder visualizar un conjunto de muchas dimensiones en solo dos, lo que permite descubrir agrupamientos "naturales" del conjunto de datos; es una alternativa al mapa de Kohonen. También se suele usar para proyectar las neuronas del mapa de Kohonen en sí, dándote una idea de cuáles son los clusters que forman los vectores que a su vez forman el mapa de Kohonen. En el paquete SOM_PAK se incluye sammon, un programa que permite calcular el mapa de Sammon desde la línea de comandos a partir de un conjunto de datos. Con lo que hay que tener más cuidado es con el runlength, el número de iteraciones del algoritmo. Si se pasa uno quedará un mapilla bastante mísero. El número correcto dependerá del problema, pero un número adecuado puede ser 10. Uno de los principales problemas del mapa de Sammon es que es muy sensible a los datos que trillan fuera de parva, así que habrá que eliminarlos uno por uno antes de tener algo decente.

Ejercicios

  1. Instalar algún paquete que incluya el mapa autoorganizativo de Kohonen, como por ejemplo, el SOM_PAK.
  2. Crear en Perl (o en cualquier otro lenguaje de programación) un conjunto aleatorio, con 10 variables, una de las cuales es categórica con 3 categorías, otra son números reales entre 0 y 10000, y el resto son números aleatorios entre -10 y 10. Crear un programa para preprocesar este conjunto, o bien usar los programas de normalización y preprocesado de las herramientas del servidor GEPAS.
  3. Aplicar el mapa de Sammon sobre el conjunto anterior, para ver su proyección. Aplicarlo también sobre un conjunto de datos ya estructurado (el incluido como ejemplo en el paquete SOM_PAK puede servir, o bien, una vez más, uno de los incluidos en GEPAS), para apreciar visualmente el agrupamiento logrado por la proyección.
  4. Usar alguno de los sitios on-line que aplican el mapa de Kohonen: GEPAS o SOMCD. En el primero, usar el conjunto de datos creado anteriormente para ver resultados de clustering. En el segundo, usar el ejemplo para calcular los valores de estructura secundaria de una proteina a partir de los datos de dicroismo circular ejemplo u obtenidos de otro sitio.

Una vez el conjunto está bien preprocesadito, en un formato que sea el adecuado para pasárselo al programa correspondiente, viene el entrenamiento en sí, y la arquitectura de la red elegida (hexagonal o cuadrada). En dos palabras, consiste en lo siguiente:

animación de entrenación de un mapa de Kohonen con colorines

Normalmente el entrenamiento se divide en dos fases: una primera en la que la vecindad disminuye, y cuya longitud viene a ser entre 5 y 10 veces el tamaño del conjunto de entrenamiento (una vez más, regla de cocina), y una segunda en la que la vecindad permanece fija (a veces llamada fase de autoorganización), que suele durar entre 50 y 100 veces el tamaño del conjunto de entrenamiento.

La tasa de cambio de los vectores ganadores y su vecindad también varía durante el entrenamiento; tiene al principio un valor, y va disminuyendo hasta ser cero al final de la fase. Normalmente, para la primera fase se suele usar una tasa del orden de 0.1, y para la segunda, valores bastante menores (la décima parte, aproximadamente; aunque todas estas cantidades son recetillas de usuario habitual que pueden variar ligeramente en algún problema en particular).

Veamos como se haría una sesión de entrenamiento con el programa vfind. Primero hay que preparar los dos ficheros de entrenamiento y prueba, diauxic.trn y diauxic.tst. Son ficheros con columnas de datos separadas por espacio o tabulador, la etiqueta de clase al final, y una línea inicial que indica cuántas columnas son, de esta forma:

7 -1.23 -0.81 1.79 0.78 -0.42 -0.69 0.58 YGR138C -1.76 -0.94 1.16 0.36 0.41 -0.35 1.12 YPR156C -2.19 0.13 0.65 -0.51 0.52 1.04 0.36 YOR230W2 ...

Ya está todo listo para el entrenamiento (en este caso, nos saltaremos el fichero de validación, aunque para medir realmente el error de generalización habría que usarlo) usando directamente vfind, que es más o menos interactivo y va haciendo solo las diferentes pruebas y llamando en cada una de ellas a todas las fases del entrenamiento:

[jmerelo@localhost bioinfo]$ vfind This program will repeatedly run the initialization, training and testing cycle for Self-Organizing Map algorithm. // Varios párrafos de rollete After the answers have been given the training begins and depending on the size of problem it may take a long time. Give the number of trials: 10 Give the input data file name: diauxic.trn Give the input test file name: diauxic.tst Give the output map file name: diauxic-0.map Give the topology type: hexa Give the neighborhood type: gauss Give the x-dimension: 12 Give the y-dimension: 8 Give the training length of first part: 3000 Give the training rate of first part: 0.1 Give the radius in first part: 8 Give the training length of second part: 30000 Give the training rate of second part: 0.01 Give the radius in second part: 1 0/ 0 sec. ............................................................ 0/ 0 sec. ............................................................ 0/ 0 sec. ............................................................ 10: 2.044475 0/ 0 sec. ............................................................ 1/ 1 sec. ............................................................ 0/ 0 sec. ............................................................ 9: 2.029348 // así hasta 10, contando para abajo 2: 2.050182 0/ 0 sec. ............................................................ 0/ 0 sec. ............................................................ 0/ 0 sec. ............................................................ 1: 2.047696 Smallest error with random seed 4: 2.028520

El entrenamiento en su primera fase presenta 5 veces aproximadamente el conjunto y 50 en la segunda, y el resto de los parámetros son más o menos estándar. Se escoge la vecindad hexagonal y gaussiana, y un mapa rectangular 12x8, que suele dar mejores resultados. Finalmente, el resultado, es decir, el mapa entrenado se coloca en diauxic-0.map, que vamos a usar más adelante para el resto del análisis.

Lo siguiente es calibrar el mapa, es decir, etiquetar cada uno de los vectores/neuronas del mapa con los datos con los cuales se empareja mejor. Así tendremos una idea de cómo se reparte el mapa, y qué zonas corresponden a qué clase. Se usa para ello vcal, otro de los programas del SOM_PAK.

[jmerelo@localhost bioinfo]$ vcal -din diauxic.trn -cin diauxic-0.map -cout diauxic-0.cod 0/ 0 sec. ............................................................

-din va seguido del fichero de datos que vamos a usar para etiquetar, y -cin del fichero que contiene el mapa entrenado. El nombre del fichero de resultado sigue a -cout, y será igual que el fichero de mapa, salvo que cada vector/neurona irá etiquetado con el vector del fichero de entrada más cercano. Si queremos que lo etiquete con todos los vectores (lo que puede ser más conveniente en la visualización), lo haremos así:

[jmerelo@localhost bioinfo]$ vcal -din diauxic.trn -cin diauxic-0.map -cout diauxic-0.cod -numlabs 0 0/ 0 sec. ............................................................

que dará un resultado con esta pinta:

7 hexa 12 8 gaussian -0.853981 -0.744614 -0.45114 -0.434369 -0.467948 1.95614 0.995996 YDR272W YBR241C YCL035C YHR104W YIL113W YIL162W YJL144W YKL151C YLL023C YLR270W YML004C YMR030W YNL274C YNR073C YOL071W YOR052C YOR220W YJL141C YLR216C YBR214W YBR280C YGR130C YHR195W YMR311C YOL032W -0.879933 -0.796584 -0.535498 -0.433268 -0.302109 1.89136 1.05583 YDR031w YER035w YER182w YGL199C YJL151C YKL193C YMR170C YNL045W YNL115C -0.949535 -0.886507 -0.664024 -0.321382 -0.0876627 1.75738 1.15087 YBR149W YNL015W YNL055C YBL038W YBR269C YDL004W YDR277C YGR248W YPL004C ...

es decir, una primera línea que contiene la dimensión (7), la disposición de los vectores (hexa), el tamaño x e y, y finalmente el tipo de vecindad, seguidos a partir de la línea 2 por los dos componentes de cada vector y todas las etiquetas de todos los vectores del conjunto de entrenamiento que caen, o están más cerca de, ese vector/neurona en particular.

Finalmente, ya podemos representar gráficamente este mapa entrenado, usando umat sobre el mapa calibrado:

[jmerelo@localhost bioinfo]$ umat -fontsize 0.3 -cin diauxic-0.cod -ps -o diauxic-0.ps

lo que finalmente debería dar como resultado algo así mapa entrenado

con una división clara entre dos clusters (a un lado y otro de la banda gris), cuya explicación se deja al lector.

El entrenamiento consiste, evidentemente, en un procedimiento iterativo de minimización del error cuadrático medio; por lo tanto, cuanto menor sea este error, mejor. Sin embargo, tampoco conviene que sea demasiado pequeño, porque se estaría produciendo un sobreentrenamiento; se habla de sobreentrenamiento cuando el modelo que se está entrenando memoriza el conjunto, comportándose bien para él, pero sin extraer el modelo subyacente, y, por tanto, generalizando mal para muestras del mismo conjunto no vistas anteriormente. Como regla adicional para evitar el sobreentrenamiento, el modelo (en este caso el mapa de Kohonen) no debe tener más de 0.1 veces el número de parámetros en el conjunto de entrenamiento, es decir, no superar el 10% de su tamaño. En algunas aplicaciones, sin embargo, el mapa de Kohonen puede ser incluso mayor que el conjunto de entrenamiento; pero hay que evitar un error cuadrático medio igual a 0, que sería indicativo de este sobreentrenamiento.

Ejercicios

  1. Usar SOM_PAK sobre el conjunto de entrenamiento aleatorio creado anteriormente. Inicialmente usar el comando vfind, que va preguntando los diferentes valores. Posteriormente, crear un fichero de parámetros, y usadlo de la forma siguiente: vfind < fichero.param.
  2. Tomando alguno de los conjuntos de datos de GEPAS, aplicadle el mapa de Kohonen usando SOM_PAK. Estimad cuál es la mejor mezcla de parámetros usando como medida el error cuadrático medio.
  3. Aplicar el mapa de Sammon a los datos del Diauxic shift, tratando los outliers adecuadamente. Describir qué estructura tienen los datos. Aplicar posteriormente el mapa de Kohonen, y ver qué grupos se forman.
  4. Comparar los resultados obtenidos observando el UMatrix con los resultados de los algoritmos SOTA y SOMTree tal como aparecen en el GEPAS. ¿Cuántos clusters hay? ¿Cuántos se aprecian?

La última fase de análisis de datos usando el mapa de Kohonen consiste en el análisis de planos, que se hace mediante el programa planes, de forma similar a como hemos usado anteriormente umat, es decir, ver cómo se distribuyen los valores de cada uno de los componentes de los vectores del mapa a lo largo y ancho del mismo. Esta distribución permite dar reglillas sobre cuáles son los componentes más representativos en cada uno de los clusters, y qué valores de cada componente son los que los caracterizan. Los valores de los componentes se suelen representar sobre el propio mapa, con un tono oscuro indicando valores altos y un tono claro valores bajos, todo ello relativamente a los valores máximos y mínimos para cada componente.

Una forma de usarlo sería la siguiente:

[jmerelo@localhost bioinfo]$ planes -cin diauxic-0.cod

que produciría una serie de ficheros de postscript encapsulado (eps, se pueden usar directamente en LaTeX, por ejemplo), llamados diauxic-0_p<numero>.eps, donde número va desde 1 (primer componente) hasta el número de componentes total, que en este caso es 7

Montaje de los planos para  "diauxic
     shift"

En este caso, por ejemplo, se puede ver que el cluster a la izquierda del mapa corresponde a valores bajos de los tres primeros componentes, y altos de los tres últimos, y el cluster a la derecha justo al contrario. Lo que coincide más o menos con los diversos resultados obtenidos por GEPAS, en los que el mapa está dividido entre los que tienen los últimos componentes del vector mayores (abajo) y en los que los primeros componentes son mayores (arriba)

Ejercicios

  1. Sobre los datos de esporulación del GEPAS aplicar el mapa de Kohonen, extraer clusters usando el algoritmo UMatrix y finalmente, hacer un análisis por planos para caracterizar cada uno de los clusters.

Como para gustos hay colores, se pueden usar diferentes programas para trabajar con el mapa de Kohonen. Por ejemplo, si lo tuyo es el MATLAB, puedes usar la SOM toolbox, que funciona algo mejor en algunos casos, y te permite usar los resultados como estructuras propias para manipularlas luego mediante otros programas. Además, también incluye herramientas para hacer Curvilinear Component Analysis y análisis de componentes principales. Los ejercicios de arriba, alternativamente, se pueden hacer con esta herramienta.

Finalmente, Databionics es una herramienta bastante interesante, escrita en Java (se puede usar también desde Matlab), que implementa una variante del mapa de Kohonen denominada ESOM, o Emergent SOM. La principal diferencia es que usa muchas más neuronas que el SOM, y que los mapas son toroidales: las vecindades se extienden del borde de la derecha a la izquierda, y de arriba abajo; además, permite entrenar el mapa de varias formas, incluyendo un modo batch, que sólo cambia los vectores/neuronas cuando se ha presentado el conjunto de entrenamiento completo, para evitar inestabilidades durante el entrenamiento. Los ficheros se preparan de forma ligeramente diferente a como se hace para el SOM, pero, una vez hecho, obtenemos el siguiente resultado:

Diauxic shift con el databionics

En este caso, la interpretación es un poco más clara: habría que mirarlo como un mapa topográfico, con el color representando altura, y el color blanco mucha altura: habría tres zonas separadas por dos cordilleras, lo que nos da una perspectiva sobre el conjunto de datos más intersante. En todo caso, conviene visualizar los datos de varias formas para extrar la máxima información posible

Contenido de esta sección
  • Perl: Módulos Bio
  • Módulos AI::NeuralNet::Kohonen

Para integrar el mapa de Kohonen en una aplicación, se puede usar SOM_PAK como programa externo, pero siempre es más fácil disponer de un módulo accesible desde un lenguaje de programación tal como Perl. Perl, además, tiene una serie de módulos, agrupados dentro del espacio de nombres Bio, que sirven para manejar datos relacionados con biocomputación y acceder a bases de datos relacionadas con la misma. Estos módulos están accesibles desde CPAN, el sitio de los módulos en Perl, o bien desde el sitio de BioPerl, que incluye, por ejemplo, un manual para principiantes.

La serie de módulos Bio::DB sirve, por ejemplo, para acceder a bases de datos biológicas tales como GeneBank o SwissProt:

$seq_object = get_sequence('swissprot',"ROA1_HUMAN");

Estas secuencias se pueden manejar en una variedad de formatos diferentes, o realizarse una serie de operaciones sobre ellas: invertir, transformar de aminoácidos a proteinas y viceversa, o enviarse a una serie de sitios web tales como BLAST.

Para procesarlos necesitas convertirlos en un vector numérico; lo que no es baladí, porque estamos tratando con cadenas de caracteres. Se puede hacer de diferentes formas, dependiendo de los datos que tengamos:

Otra opción es usar otro tipo de algoritmo. Especialmente con secuencias, se ha usado mapas autoorganizativos para cadenas de símbolos, que sustituyen los vectores por cadenas, y aplican todos los algoritmos sobre las mismas: distancias, acercamiento, alejamiento. Aunque haya problemas de precisión, y de definición del espacio de búsqueda, siempre es mejor manejar la información en formato nativo que transformarla a un formato vectorial en el que se pierda información.

Finalmente, se pueden emplear para tratarlos con el mapa autoorganizativo de Kohonen, usando el módulo AI::NeuralNet::Kohonen. El módulo se instala de la forma habitual. Si se tiene acceso de administrador, se puede ejecutar directamente: perl -MCPAN -s shell cpan> install AI::NeuralNet::Kohonen que instalará el módulol y todas las dependencias necesarias.

La forma más simple de usarlo es la siguiente: $_ = AI::NeuralNet::Kohonen->new( map_dim_x => 39, map_dim_y => 19, epochs => 100, table => "R G B 1 0 0 0 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 1 1 "); $_->train; $_->save_file('mydata.txt'); exit;

Para tratar con secuencias biológicas, habría primero que tratarla para poderla meter en el argumento table de la red de Kohonen. El formato de salida es compatible con el SOM_PAK; y se puede usar también para aplicar los resultados una vez entrenada la red.

Ejercicios

  1. Recuperar un grupo de secuencias de ADN proteinas homólogas usando BioPerl, convertirlas en vectores (previa alineación), preprocesarlas (teniendo en cuenta medidas estándar de distancias entre nucleótidos), y aplicarles el mapa de Kohonen.

La red de Kohonen viene bien explicada en su propio libro, Self-Organizing Maps, de Teuvo Kohonen, aunque hace mucho énfasis en aspectos teóricos y poco en los prácticos. Visual Explorations in Finance: With Self-Organizing Maps (Springer Finance) by Guido J. Deboeck (Editor), Teuvo Kohonen (Editor) tiene un enfoque mucho más práctico, aunque está principalmente enfocado a información financiera.

Por último, un tutorial en castellano sobre uso de la red de Kohonen: uno en la Universidad de Cádiz, parte de una presentación y una pequeña introducción al mismo, parte de un curso sobre RNs para GNU/linux.