REDES NEURONALES

ARTIFICIALES
(RNA)
Redes Competitivas
RNA: Kohonen
Clustering
Algoritmo, Implementacin y Ejemplo

Redes Competitivas (y cooperativas)

-Las neuronas compiten (y cooperan) unas con otras con el
fin de llevar a cabo una tarea dada
-Se pretende que cuando se presente a la red cierta
informacin de entrada, slo una de las neuronas de salida
de la red se active (alcance su valor de respuesta mximo)
-Las neuronas compiten para activarse quedando
finalmente una, como neurona vencedora y el resto quedan
anuladas y siendo forzadas a sus valores de respuesta
mnimos

Redes Competitivas (y cooperativas)

-El objetivo de este aprendizaje es categorizar los datos
que se introducen en la red (formar clusters)
-Informaciones similares son clasificadas en la misma
categora y por tanto deben activar la misma neurona de
salida
-Las clases o categoras son creadas por la propia red, por
lo que se trata de un aprendizaje no supervisado a travs
de las correlaciones entre los datos de entrada

Antecedentes
-Principios de 1959: Frank Rosenblatt cre un simple clasificador
(una red de aprendizaje no supervisado) basado en el Perceptrn, el
cual aprenda a clasificar vectores de entrada en dos clases con igual
nmero de rasgos
-Finales de los aos 60 y principios de los 70: Stephen Grossberg
introdujo redes competitivas. Algunos de los comportamientos tiles
obtenidos por l, fueron la supresin del ruido, aumento del
contraste y normalizacin de vectores
-1973: Christoph Von Der Malsburg introduce la regla del mapa de
organizacin propia, que permita a la red clasificar entradas en las
cuales las neuronas que estuviesen en un vecindario cercano a la
neurona ganadora, respondieran a entradas similares

Antecedentes (cont)
-Grossberg extendi el trabajo de Von Der Malsburg,
redescubriendo la regla Instar. Mostr que la regla Instar elimin la
necesidad de renormalizar los pesos, porque los vectores de pesos
que aprendan a reconocer vectores de entrada normalizados,
automticamente se normalizarn ellos mismos
-Tuevo Kohonen: Su mayor aporte ha sido en aplicaciones para
ingeniera y en descripciones de eficiencia matemtica de las redes.
Durante la dcada de los 70 Kohonen desarroll una versin
simplificada de la regla Instar, inspirada tambin en la red de Von
Der Malsburg y Grossberg, de esta forma encontr una manera muy
eficiente de incorporar topologa a una red competitiva

Redes Competitivas
-Cada neurona tiene asignado un peso total (neta: suma de todos los
pesos de las conexiones que tiene a su entrada)
-El aprendizaje afecta slo a las neuronas ganadoras en las que se
redistribuye el peso total entre sus conexiones y se sustrae una
porcin de los pesos de todas las conexiones que llegan a la neurona
vencedora, repartiendo esta cantidad por igual entre todas las
conexiones procedentes de unidades activas
-La variacin del peso de una conexin entre una unidad i y otra j
ser nula si la neurona j no recibe excitacin por parte de la neurona
i y se modificar (se reforzar) si es excitada por dicha neurona.

Red de Kohonen
-Existen evidencias que demuestran que en el cerebro hay neuronas
que se organizan en muchas zonas, de forma que las informaciones
captadas del entorno a travs de los rganos sensoriales se
representan internamente en forma de mapas bidimensionales.
-Aunque en gran medida esta organizacin neuronal est
predeterminada genticamente, es probable que parte de ella se
origine mediante el aprendizaje, esto sugiere que el cerebro podra
poseer la capacidad inherente de formar mapas topolgicos de las
informaciones recibidas del exterior
-A partir de estas ideas Tuevo Kohonen present en 1982 un sistema
con un comportamiento semejante, se trataba de un modelo de red
neuronal con capacidad para formar mapas de caractersticas de
manera similar a como ocurre en el cerebro

Topologa

Red de Kohonen
-Este modelo tiene dos variantes denominadas LVQ (Learning
Vector Quantization) y TPM (Topology Preserving Map) o SOM
(Self Organizing Map), ambas se basan en el principio de formacin
de mapas topolgicos para establecer caractersticas comunes entre
las informaciones (vectores) de entrada a la red, aunque difieren en
las dimensiones de stos, siendo de una sola dimensin en el caso de
LVQ y bidimensional mayor en la red SOM.
-Se distingue:
-Etapa de aprendizaje
-Etapa de funcionamiento

Etapa de Aprendizaje (no supervisado)

-Se fijan los valores de las conexiones. Las neuronas de la capa de
salida compiten por activarse y slo una de ellas permanece activa
ante una determinada informacin de entrada a la red, los pesos de
las conexiones se ajustan en funcin de la neurona que haya
resultado vencedora.
-Se presenta a la red los vectores de entrada (entrenamiento) para
que sta establezca en funcin de la semejanza entre los datos, las
diferentes categoras, que serviran durante la fase de
funcionamiento para realizar clasificaciones de nuevos datos que se
presenten a la red.
-Los valores finales de los pesos de las conexiones entre cada
neurona de la capa de salida con las de entrada se correspondern
con los valores de los componentes del vector de aprendizaje que
consigue activar la neurona correspondiente.

Etapa de Aprendizaje
EL aprendizaje no concluye despus de presentarle una vez todos
los patrones de entrada, sino que habr que repetir el proceso varias
veces para refinar el mapa topolgico de salida, de tal forma que
cuantas ms veces se presenten los datos, tanto ms se reducirn las
zonas de neuronas que se deben activar ante entradas parecidas,
consiguiendo que la red pueda realizar una clasificacin mas
selectiva
Zona de Vecindad: Es la zona de vecindad, o vecindario alrededor
de la neurona vencedora i*, los pesos de las neuronas que se
encuentren en esta zona a la que se le dar el nombre de X(q), sern
actualizados junto con el peso de la neurona ganadora

Algoritmo de Aprendizaje
Partimos de:
M: Neuronas de salida organizadas bidimensionalmente. Se
determinan las distancias entre cada una de ellas en el espacio
bidimensional
N: Neuronas de entrada (N rasgos)
O: Conjunto de objetos del entrenamiento (O1, O2, .. OP). Cada
objeto es un vector de N componentes (rasgos)
W: Matriz de pesos MxN ( NxM)

Algoritmo de Aprendizaje
1) Se inicializan los pesos (Wij) con valores aleatorios pequeos y
se fija la zona de vecindad entre las neuronas de salida.
2) Se presentan a la red todos los objetos del entrenamiento
(k=1 hasta P) :

Ok = (r1, r2, .., rN)

Ok El Objeto que se presenta
(r1, r2, .., rN) Rasgos del objeto

Algoritmo de Aprendizaje
3) Para el objeto Ok se determina la neurona vencedora de la capa
de salida:
Es aquella neurona cuyo vector de pesos W (pesos de las
conexiones entre esa neurona y cada una de las neuronas de la capa
de entrada) sea el ms parecido al vector de entrada (Distancia
Euclidiana (sin raz))

Se determina el menor de los di. Con lo cual determinamos

la neurona ganadora (i).

Algoritmo de Aprendizaje
4) Se actualizan los pesos de las conexiones entre:
-Las neuronas de entrada y la neurona ganadora (i)
-Las neuronas de entrada y las neuronas vecinas de la ganadora

w(q)= w(q-1) + a(q) ( Oiv - w(q-1) )

Se aplica para todas las neuronas que estn en la vecindad de la
ganadora . El tamao de la vecindad se puede reducir en cada
iteracin del proceso de ajuste de los pesos, con lo que el conjunto
de neuronas que pueden considerarse vecinas cada vez es menor; sin
embargo en la prctica es habitual considerar una zona fija en todo
el proceso de entrenamiento de la red

Algoritmo de Aprendizaje
Zona de Vecindad
Puede variarar mantenerse
fijo durante todo el entrenamiento
q: Indica la iteracin
a(q): Coeficiente de aprendizaje para esa iteracin. Es un valor
mayor a 0 y menor que 1, que va disminuyendo a medida que
aumente la cantidad de iteraciones. Usualmente se utilizan las
fmulas:
a(q) = 1/q

a(q) = a0 * (1 q/MAX_ITERACIONES)
a0 = 0.2 0.1

Algoritmo de Aprendizaje
5) El proceso debe repetirse (una nueva iteracin), volviendo a
presentar todo el juego de patrones de aprendizaje (el conjunto O de
objetos) hasta obtener la salida deseada.
______________________________________________________
En general lo que hace una red de Kohonen es realizar una tarea de
clasificacin, puesto que la neurona de salida activada ante una
entrada, representa la clase a la que pertenece dicha informacin de
entrada, adems ante otra entrada parecida se activa la misma
neurona de salida, u otra cercana a la anterior debido a la semejanza
entre las clases, as se garantiza que las neuronas topolgicamente
prximas sean sensibles a entradas fsicamente similares; por esta
causa la red es especialmente til para establecer relaciones,
previamente desconocidas, entre conjuntos de datos

Implementacin
NF: Nmero de filas de neuronas
NC: Nmero de columnas de neuronas
TN: Total de neuronas (NF*NC)
TO: Total de objetos del entrenamiento
TR: Total de rasgos
RNA[TN][TR]: Pesos de las neuronas a cada rasgo
Objetos[TO][TR]: Objetos del entrenamiento
Distancias[TN][TN]: Distancias entre las neuronas
Radio: Radio para determinar la vecindad de neuronas (en base a
las distancias)
Vecindad[TN]: Vecindad de la neurona ganadora
Clases[TN]: Clases formadas al terminar el entrenamiento

Implementacin (funciones)
void
int
int
int
int

IniciaRNA()
IniciaEntrenamiento()
Entrena( int Obj )
EntrenaSiguiente()
EntrenaTodo()

float
void
float
int
float

calc_Distancia( int N1, int N2 )

calc_Vecindad( int N1, float R )
calc_Neurona( int N1, float Rasgo[] )
calc_Ganadora( int Obj )
calc_Alfa( int q )

Implementacin (funciones)
void

IniciaRNA()

-Calcula los pesos iniciales (W[TN][TR])

-Calcula las distancias entre las neuronas
de salida Distancias[TN][TN]
-Inicializa el Radio para el clculo de la
vecindad
-Inicializa otras variables (Iteracion,
nClases, etc)

int

IniciaEntrenamiento()

-Inicia la variable Iteracion en 1

Implementacin (funciones)
int EntrenaTodo()
{
IniciaEntrenamiento();
while ( Iteracion > 0 )
EntrenaSiguiente();
}
return nClases;
}

Implementacin (funciones)
int

EntrenaSiguiente()

-Entrena la Red con el siguiente Objeto de

la muestra
-Verifica si es necesario comenzar una
nueva iteracin, en cuyo caso calcula un
nuevo valor para Alfa (calc_Alfa)
-Si se concluyeron todas las iteraciones,
determina las clases que se han formado.

Implementacin (funciones)
int Entrena( int Obj )
{
int g, i, k;
g = calc_Ganadora( Obj );
calc_Vecindad( g, Radio );
for ( i = 0; i < nVecindad; i++ )
{
for ( k = 0; k < TR; k++ )
RNA[ Vecindad[i] ].W[k] += Alfa *
( Objetos[Obj][k] - RNA[ Vecindad[i] ].W[k] );
}
return g;

Implementacin (funciones)
int calc_Ganadora( int Obj )
{
int i, menorInd;
float menorValor;
menorInd = 0;
menorValor = calc_Neurona( 0, Objetos[Obj] );
for ( i = 1; i < TN; i++ )
{
float n;
n = calc_Neurona( i, Objetos[Obj] );
if ( n < menorValor ) {
menorValor = n;
menorInd = i;
}
}
return menorInd;
}

Implementacin (funciones)
float calc_Neurona( int N1, float Rasgo[] )
{
float d, res;
int k;
res = 0;
for ( k = 0; k < TR; k++ )
{
d = RNA[N1].W[k] - Rasgo[k];
res += d*d;
}
return res;
}

Implementacin (funciones)
float calc_Distancia2( int N1, int N2 )
{
return Distancias[N1][N2];
}
void calc_Vecindad( int N1, float R )
{
int i;
nVecindad = 0;
for ( i = 0; i < TN; i++ )
if ( calc_Distancia2( N1, i ) <= R )
Vecindad[nVecindad++] = i;
}

Implementacin (funciones)
float calc_Distancia( int N1, int N2 )
{
int i; float res, d;
res = 0.0;
for ( i = 0; i < 3; i++ ) {
d = RNA[N1].pos[i]-RNA[N2].pos[i];
res += d*d;
}
return sqrt(res);
}
float calc_Alfa( int q )
{
return 0.1*(1-(float)q/MAX_ITERACION);
}

Ejemplo:
-Red de Kohonen con 6x6 neuronas en la capa de salida
-38 Objetos (1 rasgo)
3.5, 4, 20,17, 1.4, 11.9, 19.7, 2, 18, 0.1, 3.1, 11.7, 19, 0,
1.7, 11.8, 18, 11.6, 17.5, 1.5, 11, 18, 11.3, 20, 10.1, 1.6,
19, 11.7, 18.7, 10.3, 11.2, 2.1, 18.2, 10.5, 0.6, 10, 20, 1.0
-Representan notas de estudiantes (0 a 20)
-No sabemos cmo se agrupan

Ejemplo:
Resultado: 3 Clases (Neuronas 0, 2 y 35)