SELF-ORGANIZING MAPS · 2014-06-30 · En particular, se tiene como objetivo encontrar la correspondencia entre los productores y los clusters caracterizados mediante redes de tipo

Universidad de Chile

Facultad de Ciencias Físicas y Matemáticas

Departamento de Ingeniería Eléctrica

EL4106 – Inteligencia Computacional

INFORME TAREA N°5

SELF-ORGANIZING MAPS

Nombre Alumno : Sebastián Gálvez

Profesor : Javier Ruiz del Solar

Profesor Auxiliar : Daniel Herrmann

Felipe Valdés

Fecha : 30/06/2014

Santiago, Chile.

Contenido

Contenido ............................................................................................. II

Índice de Figuras y Tablas ............................................................................... III

1. Introducción .................................................................................... 1

2. Desarrollo ..................................................................................... 2

2.1. Teoría ........................................................................................................ 2

2.2. División de Base de Datos ...................................................................... 3

2.3. Estructuras de datos e inicialización red SOM ...................................... 4

2.4. Entrenamiento, Labeling y Clasificación ............................................... 6

2.5. Visualización y Resultados ..................................................................... 7

Red SOM Rectangular, Vecindad tipo ‘bubble’. ........................................ 8

Red SOM Rectangular, Vecindad tipo ‘gaussian’. .................................... 8

Red SOM Rectangular, Vecindad tipo ‘ep’. ............................................... 9

Red SOM Rectangular, Vecindad tipo ‘cutgauss’. .................................... 9

Red SOM Hexagonal, Vecindad tipo ‘bubble’. ........................................ 10

Red SOM Hexagonal, Vecindad tipo ‘gaussian’. ..................................... 10

Red SOM Hexagonal, Vecindad tipo ‘cutgauss’. .................................... 11

Red SOM Hexagonal, Vecindad tipo ‘ep’. ................................................ 11

2.6. Normalización ......................................................................................... 12

3. Conclusiones ..................................................................................14

4. Anexos ...........................................................................................15

5. Bibliografía .....................................................................................21

Índice de Figuras y Tablas

Figura 1: U-Matrix para grilla rectangular ........................................................................... 3

Figura 2: Mapa de Sammon para datos de entrenamiento. ............................................... 4

Figura 3: Tipos de Lattice para la red SOM. ....................................................................... 5

Figura 4: U-matrix, grilla etiquetada y matriz de confusión para red SOM rectangular con

vecindad tipo ‘bubble’. Porcentaje correctamente clasificados: 64.11%. ............................ 8


vecindad tipo ‘gaussian’. Porcentaje correctamente clasificados: 68.10%. ........................ 8


vecindad tipo ‘bubble’. Porcentaje correctamente clasificados: 65.86%. ............................ 9


vecindad tipo ‘cutgauss’. Porcentaje correctamente clasificados: 70.90%. ........................ 9

Figura 8: U-matrix, grilla etiquetada y matriz de confusión para red SOM hexagonal con

vecindad tipo ‘bubble’. Porcentaje correctamente clasificados: 69.76%. .......................... 10


vecindad tipo ‘gaussian’. Porcentaje correctamente clasificados: 68.16%. ...................... 10


vecindad tipo ‘cutgauss’. Porcentaje correctamente clasificados: 70.23%. ...................... 11


vecindad tipo ‘ep’. Porcentaje correctamente clasificados: 75.91%. ................................. 11

Figura 12: Mapa de Sammon para datos de entrenamiento normalizados ....................... 12

Figura 13: U-Matrix coloreada, malla etiquetada y matriz de confusión para red SOM

rectangular con vecindad tipo ‘bubble’, usando datos normalizados. ............................... 13


hexagonal con vecindad tipo ‘ep’, usando datos normalizados. ....................................... 13

EL4106 – Self-Organizing Maps

U. de Chile. FCFM. DIE ~1~

Introducción

1. Introducción

El objetivo general de esta tarea consiste en utilizar el algoritmo de clustering

SOM, analizando su desempeño para distintos parámetros de entrenamiento. Para

esto se utilizará la base de datos Wine Data Set, que forma parte del UC Irvine

Machine Learning Repository. Esta base de dato contiene 13 características

fisicoquímicas medidas para 178 muestras de vino, las cuales son:

1) Alcohol

2) Malic acid

3) Ash

4) Alcalinity of ash

5) Magnesium

6) Total phenols

7) Flavanoids

8) Nonflavanoid phenols

9) Proanthocyanins

10)Color intensity

11)Hue

12)OD280/OD315 of diluted wines

13)Proline

La base de datos contiene información de vinos Italianos, producidos en la

misma región, pero por 3 productores distintos. Cada productor produce un tipo de

vino distinto.

En particular, se tiene como objetivo encontrar la correspondencia entre los

productores y los clusters caracterizados mediante redes de tipo SOM (Self-

Organizing Maps). Para esto se utilizará un programa en Matlab que utilice la

herramienta SOM toolbox de Helsinki University of Technology. Cuya documentación,

manuales y archivos se encuentran disponibles en: http://www.cis.hut.fi/somtoolbox/ .

http://www.cis.hut.fi/somtoolbox/



Desarrollo

2. Desarrollo

2.1. Teoría a) Self-Organizing Maps (SOM) o Mapas de Kohonen

Una red SOM permite realizar clustering sobre un conjunto de datos de manera tal que permite realizar un mapeo a una baja dimensionalidad (2D o 3D) para visualizar cómo se agrupan los vectores prototipo y posteriormente realizar cuantización vectorial en el espacio de características. El entrenamiento de este tipo de redes es no supervisado, lo que permite completa automatización del mismo una vez que se definen los parámetros que debe fijar el diseñador. El algoritmo de aprendizaje secuencial consiste en presentar ejemplos, buscar el prototipo más cercano y actualizar su posición en el espacio de características, junto a la de sus vecinos en el espacio de prototipos. Para realizar una buena estructura SOM se debe fijar inicialmente su topología, ya que los prototipos se pueden almacenar en distintas topologías de grillas, por ejemplo, hexagonales o rectangulares. Además, es fundamental definir qué tipo de vecindad se utilizará para determinar qué vectores deben actualizar su posición junto al prototipo más cercano a un dato, por lo cual se define la función de vecindad h, la cual puede ser de diversos tipos (gaussiana, cilíndrica, etc.) y debe contar con un radio inicial e ir disminuyendo a medida que se avanza en el entrenamiento hasta un radio final. Al igual que en el método K-means, también se deben determinar las posiciones iniciales de los vectores prototipo, que generalmente se hace de manera aleatoria. Por último, también se debe determinar la tasa de aprendizaje y la función según la cual cambia en cada instancia del entrenamiento, se recomienda comenzar con un valor cercano a 1 e ir disminuyéndola a medida que avanza el tiempo para refinar el aprendizaje.

b) Labeling y U-matrix Una vez que ya se ha entrenado una red SOM, a cada vector prototipo le puede ser asignado una etiqueta que finalmente representará al cluster en el que se encuentra y permitirá realizar clasificación. Para realizar este etiquetado o labeling, es fundamental identificar las nuevas relaciones geométricas que adoptó la red SOM al ser entrenada, en cuanto a que sus vectores prototipos se encontrarán distanciados entre ellos de manera no uniforme. Para esto se define una matriz que muestra información de las distancias de los vectores prototipo, en base a la información de posiciones y vecindad de la grilla, esta matriz es conocida como U-matrix. En la



Desarrollo

Figura 1 se observa un ejemplo de matriz U, en escala de grises, donde los puntos más oscuros denotan una mayor separación entre los vectores prototipo.

2.2. División de Base de Datos El programa generado en el archivo “separacion.m” contiene un script que

carga la base de datos usando el comando “load Base_de_Datos_Tarea5” y divide la base de datos en los conjuntos de entrenamiento y prueba, para finalmente guardar un archivo “Conjuntos_Separados.mat” que contiene las matrices “entren”, ”labels_entren”, ”prueba”, ”labels_prueba” y “headers”.

El script de Matlab identifica los conjuntos de datos de distinto productor y extrae aleatoriamente datos para formar el conjunto de prueba según el parámetro “pr_rate”, que en este caso se dio como valor 0.4, para obtener el 40% de los datos para prueba. Luego, del conjunto original se restan estos datos para obtener el conjunto de entrenamiento. El desempeño muestra que la representatividad y la proporción de clases se mantiene en niveles similares como muestra Tabla 1.

Clase Conjunto

Productor 1 [%]

Productor 2 [%]

Productor 3 [%]

Conjunto Original 33.15 39.89 26.97

Conjunto Prueba 33.80 39.44 26.76

Conjunto Entrenamiento 32.71 40.19 27.10 Tabla 1: Representatividad de conjunto original y sus separaciones en prueba y entrenamiento

Y se logró que la proporción de conjuntos fuera la pedida. En este caso se logró que el conjunto de prueba fuera 39.89% de los datos, lo que corresponde a 71 muestras.

Figura 1: U-Matrix para grilla rectangular



Desarrollo

2.3. Estructuras de datos e inicialización red SOM

En el archivo “tarea5.m” se desarrolla un script con distintos bloques de

código utilizados, el cual se puede ver completamente en la sección de Anexos.

En primer lugar, se cargan los conjuntos de entrenamiento y prueba del

archivo “Conjuntos_Separados.mat” generado por el script “separacion.m”, y se

extraen variables como número de datos de entrenamiento e índices que separan

los distintos productores. Luego, se inicializan las estructuras de datos para el SOM

Toolbox a utilizar, mediante las instrucciones:

somData_en=som_data_struct(entren,'labels',en_labels_som,'comp_names',headers); somData_pr=som_data_struct(prueba,'labels',pr_labels_som,'comp_names',headers);

Antes de inicializar la red SOM y configurar los distintos parámetros, se utiliza

una herramienta llamada “mapa de Sammon”, el cual permite visualizar en cierto

grado la orientación que poseen los datos proyectados en el plano bidimensional,

con el objetivo de ajustar las dimensiones de la grilla de manera más adecuada, ya

que una grilla cuadrada no siempre es lo más adecuado. En la Figura 2 se observa

el mapa de Sammon para los datos de entrenamiento, donde claramente se observa

que los datos varían con un rango a razón 7:10 aproximadamente.

En base a esta observación, considerando que idealmente el número de

vectores prototipo debe ser inferior al número de datos de entrenamiento, esto es,

MxN < 107, se determinó que la red SOM se construya con un tamaño 6x10,

utilizando 60 vectores prototipo, formando una grilla rectangular.

Figura 2: Mapa de Sammon para datos de entrenamiento.



Desarrollo

Para la primera prueba se determinaron los parámetros de la red y de

entrenamiento como se muestra en el siguiente bloque de instrucciones:

som_M=6; som_N=10; %MxN a_init=1; a_type='inv';%linear/power/inv radius=[5 1]; %radius_init radius_final epochs=1000; soMap = som_randinit (somData_en,'msize',[som_M som_N]); latt='rect'; %rect/hexa vecindad='bubble'; %cutgauss/gaussian/bubble/ep

La variable “latt” hace referencia al “lattice” o tipo de grilla donde se guardan

los vectores prototipo, la cual puede ser hexagonal o rectangular, como se muestra

en la Figura 3.

En una primera instancia se prueba con la red rectangular, sin embargo, se

sabe que la malla hexagonal es menos sesgada a las direcciones vertical y

horizontal, por lo que permite una inspección visual más adecuada.

Se utilizan 1000 épocas de entrenamiento, con 107 datos por época, por lo

que hay un total de 107000 pasos para el entrenamiento, lo cual permite una buena

precisión estadística que se traduce en un ajuste muy fino de los prototipos sin

aumentar de sobremanera el tiempo del mismo.

En cuanto al radio de la vecindad, se plantea que se inicie con un valor 5 y

que termine en 1, para que al comienzo se ordenen rápidamente los vectores y en

las etapas finales se refine el ordenamiento.

Figura 3: Tipos de Lattice para la red SOM.



Desarrollo

2.4. Entrenamiento, Labeling y Clasificación

Se define la estructura de entrenamiento, junto a los parámetros definidos anteriormente mediante las instrucciones: somTrain = som_train_struct (soMap,'dlen',N_en,'algorithm','sec');

somTrain = som_set(somTrain,'neigh',vecindad,'trainlen',...

epochs,'radius_ini',radius(1),'radius_fin',radius(2),...

'alpha_ini',a_init,'alpha_type',a_type);

Y luego se entrena usando el algoritmo de entrenamiento secuencial:

[soMap, sT_par]= som_seqtrain(soMap,somData_en,somTrain)

Posteriormente se realiza el labeling para etiquetar los vectores prototipo de la

red mediante la función soMap = som_autolabel(soMap,somData_en,'vote'), la cual usa el modo „vote‟ en vez del „add‟ como pide el enunciado debido a que el modo „vote‟ asigna automáticamente el label más frecuente o con más votos en cada nodo, que es lo que se pide finalmente, y es más directo que utilizar „add‟ y luego buscar el label con más votos en cada nodo manualmente. A pesar de esto, existen nodos que quedaron sin etiquetar, los cuales se dejan así, ya que la clasificación con redes SOM permite esto para una cierta fracción de los nodos. Una vez etiquetados los nodos de la red según el productor de vino al que corresponden, se clasifican los datos de prueba mediante el siguiente bloque de instrucciones: [bmus qe]=som_bmus(soMap,somData_pr); pr_real=cell2mat(somData_pr.labels); pr_classified=num2str(zeros(length(bmus),1)); for i=1:length(bmus) if ~isempty(soMap.labels{bmus(i)}) pr_classified(i)=soMap.labels{bmus(i)}; else if bmus(i)==1 if ~isempty(soMap.labels{bmus(i)+1}) pr_classified(i)=soMap.labels{bmus(i)+1}; else pr_classified(i)=sprintf('%i',randi([1 3])); end else if

~isempty(soMap.labels{bmus(i)+1})&&~isempty(soMap.labels{bmus(i)-1}) aux=[soMap.labels{bmus(i)-1} soMap.labels{bmus(i)+1}]; pr_classified(i)=aux(1,randi([1 2])); else pr_classified(i)=sprintf('%i',randi([1 3])); end end end end



Desarrollo

Este método asigna la etiqueta del Best Matching Unit (BMU) para cada dato de prueba, si es que ese nodo está etiquetado. Si no, se elige aleatoriamente entre los dos nodos inmediatamente vecinos según el orden definido en la estructura del mapa SOM, los cuales generalmente se condicen con el productor verdadero. En el eventual caso de que alguno de sus dos vecinos tampoco esté etiquetado, simplemente se le otorga un productor aleatorio. Finalmente se calcula una matriz de confusión utilizando las etiquetas verdaderas del productor de cada muestra del conjunto de prueba, obteniendo un porcentaje de muestras correctamente clasificadas al promediar los valores relativos de la diagonal de la matriz.

2.5. Visualización y Resultados Para visualizar la organización de la red SOM y el etiquetado de la misma se utiliza la función “som_show” y “som_show_add” con distintas modalidades, lo cual permite mostrar una U-matrix coloreada según los vectores prototipo etiquetados para cada productor, y la malla con las etiquetas de los labels más votados en los nodos etiquetados. A continuación se muestran los resultados para distintas combinaciones de los parámetros de entrenamiento y de topología de la red. Para realizar un análisis un tanto más simplificado, se mantienen constantes el tamaño, el radio inicial y final de la red, número de épocas, la tasa de aprendizaje inicial y la función de aprendizaje, como se inicializó en la sección 2.3. Es decir, se evaluarán diferencias en los resultados para distintos tipos de vecindad y organización de la malla de la red.



Desarrollo

Red SOM Rectangular, Vecindad tipo „bubble‟.

En la Figura 4 se observan la matriz U, la matriz de confusión y la grilla con

etiquetas asignadas para este caso. Si bien el rendimiento de clasificación es

relativamente bajo, se observa que la red SOM diferencia en cierto grado los clusters

asociados a cada productor, cumpliendo su objetivo.

Red SOM Rectangular, Vecindad tipo „gaussian‟.

En este caso el rendimiento mejora en un 4% como muestra la Figura 5.


vecindad tipo „bubble‟. Porcentaje correctamente clasificados: 64.11%.


vecindad tipo „gaussian‟. Porcentaje correctamente clasificados: 68.10% .



Desarrollo

Red SOM Rectangular, Vecindad tipo „ep‟.

En la Figura 6 se ve que el rendimiento de clasificación es muy parecido al

caso con vecindad tipo „bubble‟.

Red SOM Rectangular, Vecindad tipo „cutgauss‟.

En la Figura 7 se observa que este tipo de vecindad, a pesar de presentar

traslape entre los Productores 2 y 3, obtiene el mejor rendimiento neto para la red

con malla rectangular, logrando un 70.9%.


vecindad tipo „cutgauss‟. Porcentaje correctamente clasificados: 70.90%.

Figura 6: U-matrix, grilla etiquetada y matriz de confusión para red SOM rectangular con vecindad

tipo „bubble‟. Porcentaje correctamente clasificados: 65.86%.



Desarrollo

Red SOM Hexagonal, Vecindad tipo „bubble‟.

En la Figura 8 se ve que a contraste con la topología rectangular, una red

SOM con malla hexagonal logra mejores resultados para clasificación, llegando a un

rendimiento de 69.76%.

Red SOM Hexagonal, Vecindad tipo „gaussian‟.

Como muestra la Figura 9, se obtiene un rendimiento de 68.16%, muy similar

al caso anterior. Se identifica gran traslape entre productores 2 y 3.

Figura 8: U-matrix, grilla etiquetada y matriz de confusión para red SOM hexagonal con vecindad

tipo „bubble‟. Porcentaje correctamente clasificados: 69.76%.


vecindad tipo „gaussian‟. Porcentaje correctamente clasificados: 68.16%.



Desarrollo

Red SOM Hexagonal, Vecindad tipo „cutgauss‟.

En este caso, como se ve en la Figura 10, este tipo de vecindad obtiene un

70.9% de datos clasificados correctamente.

Red SOM Hexagonal, Vecindad tipo „ep‟.

En la Figura 11 se ve que el rendimiento de clasificación es el mejor logrado,

llegando a un 75.91%, a pesar de que aún existe un cierto grado de traslape entre

las zonas de los productores 2 y 3 en la U-Matrix.


vecindad tipo „cutgauss‟. Porcentaje correctamente clasificados: 70.23%.

Figura 11: U-matrix, grilla etiquetada y matriz de confusión para red SOM hexagonal con vecindad

tipo „ep‟. Porcentaje correctamente clasificados: 75.91%.



Desarrollo

2.6. Normalización Realizando una normalización según la varianza al incorporar las líneas de

código para las estructuras de datos de entrenamiento y prueba:

somData_en=som_normalize(somData_en,'var'); somData_pr=som_normalize(somData_pr,'var');

En primer lugar, se observa en la Figura 12 que el mapa de Sammon cambia

drásticamente, observándose una distribución bastante simétrica y cuyo rango en

ambas direcciones es muy similar. En base a esto, se utilizará un tamaño de red

igual a 8x8, usando 64 vectores prototipo.

Luego, manteniendo el resto de los parámetros, se evaluaron los mismos

casos que antes, llegando a que los mejores rendimientos para una malla

rectangular se logran usando una vecindad tipo „bubble„, obteniendo un 94.95%

como se ve en la Figura 13 y para una malla hexagonal con vecindad tipo „ep„,

logrando clasificar correctamente 93.21% de los datos de prueba, mostrado en la

Figura 14, aunque cabe destacar que para vecindad tipo „cutgauss‟ también se

obtuvo resultados muy cercanos.

Para la malla rectangular para las otras funciones de vecindad, en promedio

se logró un rendimiento del orden de 88%, mientras que el promedio para la malla

hexagonal fue de 87% aproximadamente.

Se observa que al normalizar los datos, el rendimiento de clasificación

aumenta considerablemente, esto debido a que las variables de las características

poseen rangos de órdenes de magnitud muy distintos, alterando la importancia que

se le da a una característica al medir distancias euclidianas.

Figura 12: Mapa de Sammon para datos de entrenamiento normalizados



Desarrollo

En resumen, el mejor clasificador logrado se obtiene para una red SOM

rectangular con vecindad tipo „bubble‟ al ser entrenada y probada con datos

normalizados según varianza, logrando un rendimiento de 94.95%.


rectangular con vecindad tipo „bubble‟, usando datos normalizados.


hexagonal con vecindad tipo „ep‟, usando datos normalizados.



Conclusiones

3. Conclusiones

En primer lugar, se logró implementar los mapas auto-organizativos que realizaron clustering exitosamente, esto gracias a la utilización del SOM Toolbox desarrollado por Helsinki University of Technology. En segundo lugar, se pudo identificar la importancia de la normalización de los datos para implementar este tipo de algoritmo de clustering, debido a que las distancias euclidianas utilizadas se ven considerablemente afectadas cuando existen variables de características con órdenes de magnitud muy diferentes al resto. En este sentido, se logró aumentar el rendimiento máximo de clasificación en un 20%, llegando al mejor clasificador para una red SOM rectangular con vecindad tipo „bubble‟. Se puede concluir que los parámetros de entrenamiento y topología de una red SOM son muy determinantes para el nivel de ordenamiento deseado en el espacio de salida, por lo que conviene ayudarse de herramientas como los mapas de Sammon para determinar las dimensiones de la malla, y de heurísticas conocidas para configurar las tasas de aprendizaje y el radio de la vecindad. Además, una conclusión interesante del trabajo realizado es que a partir de las redes SOM, se permite visualizar de manera intuitiva en un plano 2D la organización de los distintos clusters de los datos, los cuales pueden ser coloreados según la clase a la que pertenecen, haciendo más fácil la visualización de los vectores prototipo asociados a cada cluster. Finalmente, se concluye que fue posible caracterizar los 3 clusters asociados a los productores, en cuanto se logró una clasificación utilizando el mapa SOM con un alto porcentaje de datos clasificados correctamente.



Anexos

4. Anexos

A continuación se muestran los códigos contenidos en cada uno de los archivos

entregados en la tarea.

“separacion.m”

load Base_de_Datos_Tarea5

data=muestras; productor=double(cell2mat(labels))-48;

N=length(data(:,1)); nfeats=13; % n° de caracteristicas nc=3; % n° de clases pr_rate=0.4; % Entrenamiento (60%)... Prueba(40%) %Uno los datos con las clases en una sola matriz, para asociar los %índices de las filas a cada clase distinta. newdata=[data,productor];

%ordeno y obtengo los índices de las muestras de cada clase. [aux ind]=sortrows(newdata,14); szs=zeros(1,nc); ind_bord=zeros(1,nc); %debo encontrar los indices de los que efectivamente pertenecen a cada %clase, para guardarlos en una matriz y luego separarlos. for i=1:nc auxaux=(aux(:,nfeats+1)==i); ind_aux=find(auxaux,1,'last'); ind_bord(i)=ind_aux; szs(i)=sum(auxaux(:)); %también calculo cuántos hay por clase. end clear auxaux;

%Se quiere pr_rate% de los datos por cada clase para el conjunto de prueba pr_szs=round(szs.*pr_rate); ind_bord_pr=cumsum(pr_szs);%esto me sirve para saber cuántos datos

seleccionar por cada clase en las iteraciones. sz_prueba=sum(pr_szs); %tamaño total del conjunto de prueba. prueba=zeros(sz_prueba,nfeats+1); r_vec=zeros(sz_prueba,1); %vector que tendrá los indices seleccionados.



Anexos

%Selección de datos de prueba (20% por cada clase)

%primera iteración for i=1:ind_bord_pr(1) r=randi([1 ind_bord(1)]); while(find(r_vec==ind(r))) %selecciono un indice al azar dentro

del rango de la clase '1'. % y me aseguro que sea distinto a

alguno seleccionado. r=randi([1 ind_bord(1)]); end prueba(i,:)=newdata(ind(r),:); %guardo los datos y la clase a la que

pertenece el dato elegido en el conjunto de prueba r_vec(i)=ind(r); %guardo el indice para luego borrar ese dato del

conjunto y que lo que quede sea el de entrenamiento end % repito para el resto de las clases. for j=2:nc for i=(ind_bord_pr(j-1)+1):ind_bord_pr(j) r=randi([(ind_bord(j-1)+1) ind_bord(j)]); while(find(r_vec==ind(r))) r=randi([(ind_bord(j-1)+1) ind_bord(j)]); end prueba(i,:)=newdata(ind(r),:); r_vec(i)=ind(r); end end prueba2 = prueba(randperm(length(prueba(:,1))),:); %desordeno las

filas prueba=prueba2; clear prueba2;

%extraigo del conjunto original los datos utilizados para el conjunto de

prueba entren=newdata; entren(r_vec,:)=[]; sz_entren=length(entren(:,1));

%Verificar representatividad

%calculo cantidad de datos por clase en cada conjunto [aux ind]=sortrows(prueba,14); [aux2 ind2]=sortrows(entren,14); ver_szs_prueba=zeros(1,nc); ver_szs_entren=zeros(1,nc); for i=1:nc auxaux=(aux(:,nfeats+1)==i); auxaux2=(aux2(:,nfeats+1)==i); ver_szs_prueba(i)=sum(auxaux(:)); %calculo cuántos datos hay por clase

en el conjunto de prueba construido. ver_szs_entren(i)=sum(auxaux2(:)); %y cuántos por clase en el conjunto

de entrenamiento end clear auxaux; clear auxaux2;



Anexos

%verifico proporciones parecidas por clase en ambos conjuntos. (DESCOMENTAR %PARA VERIFICAR) % % repr_total=szs./N % repr_prueba=ver_szs_prueba./sz_prueba % repr_entren=ver_szs_entren./sz_entren % % %verifico proporción 80/20 de los datos en cada conjunto. % % sz_entren/N % sz_prueba/N

%Separo datos de información sobre la clase a la que pertenece cada uno.

labels_entren = entren(:,14); entren(:,14)=[]; labels_prueba = prueba(:,14); prueba(:,14)=[];

save('Conjuntos_separados.mat','entren','labels_entren','prueba','labels_pr

ueba','headers')

clear all;

“prodbordes.m”

function indbord=prodbordes(xlabels)

%retorna bordes que separan los 3 grupos distintos de labels %(requiere que estén ordenados)

ind1=find((xlabels==1),1,'last'); ind2=find((xlabels==2),1,'last'); ind3=find((xlabels==3),1,'last');

indbord=[ind1 ind2 ind3];

“tarea5.m”

% ********************* TAREA 5 ************************** set(0,'DefaultFigureColormap',gray)

clear all; close all; echo off;



Anexos

%% Cargar Conjuntos de datos separados y generar estructura de datos para

el toolbox

load Conjuntos_Separados; %entren, labels_entren, prueba,

labels_prueba, headers N_en=length(labels_entren); en_bord=prodbordes(labels_entren); en_labels_som=num2str(labels_entren); %str_array para argumento pr_labels_som=num2str(labels_prueba);

somData_en=som_data_struct(entren,'labels',en_labels_som,'comp_names',heade

rs);

somData_pr=som_data_struct(prueba,'labels',pr_labels_som,'comp_names',heade

rs);

%% Normalización somData_en=som_normalize(somData_en,'var'); somData_pr=som_normalize(somData_pr,'var');

%% Mapa de Sammon % <http://en.wikipedia.org/wiki/Sammon_mapping>

% %datos normalizados % norm_entren=som_normalize(entren,'var'); % P = sammon(norm_entren,2); %Permite ver la "orientacion" de los

datos % figure; % plot(P(:,1),P(:,2),'x') % title('Mapa de Sammon: Proyeccion no lineal 2D de los datos

normalizados')

% %datos sin normalizar % P = sammon(entren,2); %Permite ver la "orientacion" de los

datos % figure; % plot(P(:,1),P(:,2),'x') % title('Mapa de Sammon: Proyeccion no lineal 2D de los datos')

%% Inicializar red SOM % Cambiar parámetros de diseño AQUÍ som_M=8; som_N=8; %MxN // recomendado: 8x8 para Normalizado, 6x10 sin

normalizar. a_init=1; a_type='inv';%linear/power/inv radius=[5 1]; %radius_init radius_final epochs=1000; soMap = som_randinit (somData_en,'msize',[som_M som_N]); latt='hexa'; %rect/hexa vecindad='cutgauss'; %cutgauss/gaussian/bubble/ep



Anexos

%defino Grilla soMap = som_set(soMap,'neigh',vecindad,'lattice',latt);

%% Estructura de entrenamiento somTrain = som_train_struct (soMap,'dlen',N_en,'algorithm','sec');

%seteo parámetros de entrenamiento somTrain =

som_set(somTrain,'neigh',vecindad,'trainlen',epochs,'radius_ini',radius(1),

'radius_fin',radius(2),'alpha_ini',a_init,'alpha_type',a_type);

%% Entrenamiento

[soMap, sT_par]= som_seqtrain(soMap,somData_en,somTrain);

%% Labeling

soMap = som_autolabel(soMap,somData_en,'vote');

%% Visualizo warning('off','all'); % % U-mat % figure; % colormap(1-gray) % som_show(soMap,'umat','all') % colorbar %U-mat con hits en color + labels figure; colormap(1-gray) som_show(soMap,'umat','all','empty','Labels','subplots',[2 1]) som_show_add('label',soMap,'Textsize',8,'TextColor','r','Subplot',2) h1 = som_hits(soMap,somData_en.data(1:en_bord(1),:)); h2 = som_hits(soMap,somData_en.data(en_bord(1)+1:en_bord(2),:)); h3 = som_hits(soMap,somData_en.data(en_bord(2):en_bord(3),:)); som_show_add('hit',[h1, h2, h3],'MarkerColor',[1 0 0; 0 1 0; 0 0

1],'Subplot',1) if(som_M==8 && som_N==8) text(0,9.7,['\color{red}Productor 1' '\color{black}, '

'\color{green}Productor 2'... '\color{black}, ' '\color{blue}Productor 3'],'BackgroundColor',[1

1 1],... 'EdgeColor',[0 0 0],'Margin',5) else text(2,7.5,['\color{red}Productor 1' '\color{black}, '

'\color{green}Productor 2'... '\color{black}, ' '\color{blue}Productor 3'],'BackgroundColor',[1

1 1],... 'EdgeColor',[0 0 0],'Margin',5) end % Productor 1: ROJO Productor 2: VERDE Productor 3: AZUL colorbar

warning('on','all');



Anexos

%% Clasificación de Datos de prueba

[bmus qe]=som_bmus(soMap,somData_pr); pr_real=cell2mat(somData_pr.labels); pr_classified=num2str(zeros(length(bmus),1));

for i=1:length(bmus) if ~isempty(soMap.labels{bmus(i)}) pr_classified(i)=soMap.labels{bmus(i)}; else if bmus(i)==1 if ~isempty(soMap.labels{bmus(i)+1}) pr_classified(i)=soMap.labels{bmus(i)+1}; else pr_classified(i)=sprintf('%i',randi([1 3])); end else if

~isempty(soMap.labels{bmus(i)+1})&&~isempty(soMap.labels{bmus(i)-1}) aux=[soMap.labels{bmus(i)-1} soMap.labels{bmus(i)+1}]; pr_classified(i)=aux(1,randi([1 2])); else pr_classified(i)=sprintf('%i',randi([1 3])); end end end end

%% Generar matriz de confusión figure; colormap('jet'); C =confusionmat(pr_real,pr_classified); sC=sum(C); for i=1:3 C(:,i)=C(:,i)./sC(i); %normalizo la matriz de confusión end imagesc(C) axis('ij') colorbar; xlabel('Clases Verdaderas') ylabel('Clases Predichas') set(gca,'XTick',[1:3]) set(gca,'XTickLabel',['Productor 1';'Productor 2';'Productor 3']) set(gca,'YTick',[1:3]) set(gca,'YTickLabel',['Productor 1';'Productor 2';'Productor 3']) C1=sum(diag(C))/3 ; tt=sprintf('Matriz de Confusión: Porcentaje Clasificación correcta:

%.2f%%',C1*100); title(tt)



Bibliografía

5. Bibliografía

Presentación “EL4106 - Inteligencia Computacional – Self Organizing Map –

SOM Redes Auto-Organizativas de Kohonen”- Prof. Javier Ruiz del Solar-

Otoño 2014.

Presentación “EL4106 – Inteligencia Computacional – Performance

Evaluation” – Otoño 2014.

SOMToolboxManual – “SOM Toolbox for Matlab 5”- Esa Alhoniemi, Johan Himberg, Juha Parhankangas and Juha Vesanto - Laboratory of Information and Computer Science in the Helsinki University of Technology- 2005

http://www.cis.hut.fi/somtoolbox/

“Sammon mapping” - http://en.wikipedia.org/wiki/Sammon_mapping

http://www.cis.hut.fi/

http://www.cis.hut.fi/

http://www.hut.fi/

Documents

SELF-ORGANIZING MAPS · 2014-06-30 · En particular, se tiene como objetivo encontrar la correspondencia entre los productores y los clusters caracterizados mediante redes de tipo