apunteredesneuronales_parte2

Introduccin a las Redes Neuronales: Parte 2Red de Perceptrones

Dr. Ing. Marcelo RiskInstituto Tecnolgico de Buenos Aires

ndice1. Introduccin 1

2. El perceptrn a partir de un combinador lineal adaptativo 4

3. Implementacin de una red neuronal 83.0.1. Cdigo fuente de NEURAL3.H . . . . . . . . . . . . . . . . . 83.0.2. Cdigo fuente de NEURAL3.CPP . . . . . . . . . . . . . . . . 11

3.1. Ejemplo de identificacin de patrones con redes neuronales . . . . . . 233.1.1. OCHO.TXT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.1.2. SEIS.TXT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.1.3. CINCO.TXT . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.1.4. SEIS2.TXT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.1.5. Cdigo fuente de NUMERO.CPP . . . . . . . . . . . . . . . . 24

1. IntroduccinLas redes neuronales (RN) se basan en la interconexin de neuronas artificiales,

y en el caso de las RN artificiales (RNA) en la interconexin de perceptrones, elcual modeliza una neurona natural, en el presente trabajo utilizaremos el modelo deneurona denominado clasificador no lineal [5, 4, 1].

Las RNA son mquinas o software que modelan la forma en la cual el cerebrodesarrola una tarea. Las RNA son una clase de mtodos estadsticos para el pro-cesamiento de informacin, compuestas por una cantidad importante de unidadessimples de procesamiento, denominadas neuronas, las cuales interactuan entre s.

Las RN naturales estn presentes en el sistema nervioso de humanos, animales,insectos, etc, tienen la habilidad de reconocer patrones, y desarrollar tareas comple-jas, en forma muy especializada [3, 2].

El cuadro 1 muestra comparaciones de performance, tales como velocidad deprocesamiento, cantidad de neuroras-compuertas, peso, consumo de energa y unejemplo de pasos necesarios para el procesamiento de la visin.

1

Cuadro 1: Comparaciones de performance y consumos entre el cerebro humano ylas computadoras.

Cerebro humano ComputadoraVelocidad procesamiento 103ms (0.25 MHz) 109ms (2.5 GHz)Neuronas-compuertas 109 con 103 conexiones c/u 50 millonesPeso 1.5 kg kgs a tonsConsumo 1016 Joule 106 JouleProcesamiento de la visin 100 pasos billones de pasos

Las RNA heredan la terminologa de las redes naturales, provenientes de la bio-loga, el cuadro 2 muestra las correspondencias entre dichos trminos y los corres-pondientes a la estadstica.

Cuadro 2: Correspondencia entre la terminologa de las RNA y la estadstica.

RNA EstadsticaNodos de entrada Variables independientesNodos de salida Variables dependientesAprendizaje ParametrizacinPesos Parmetros

La figura 1 muestra en el panel izquierdo: neurona cerebral, gran cantidad dedendritas (entradas de informacin), y axn (salida) simple; mientras en el panelderecho: neurona motora, con menos dendritas, y salida mielinizada (aislada).

Ms all del alcance de este apunte, en muchos libros es posible encontrar elparadigma de las redes neuronales, pero podemos decir que los atributos ms im-portantes de las redes neuronales es el aprendizaje y la generalizacin.

El aprendizaje es el proceso por el cual se le presenta a la red neuronal uno ovarios patrones con sus salidas deseadas (tantos como sea posible), determinndo-se un conjunto de entrenamiento, con dicho conjunto y mediante un algoritmo deoptimizacin se ajustan los coeficientes de la red.

Una vez entrenada la RNA, se puede probar la respuesta de la misma aplicndolepatrones distintos a los del entrenamiento, verificando si la respuesta fue correctaen la mayora de los casos, entonces se puede decir que se obtuvo un entrenamientogeneral.

2

Figura 1: Panel izquierdo: neurona cerebral, gran cantidad de dendritas (entradasde informacin), y axn (salida) simple; panel derecho: neurona motora, con menosdendritas, y salida mielinizada (aislada).

3

2. El perceptrn a partir de un combinador linealadaptativo

Si a la salida del combinador lineal adaptativo se conecta un bloque de respuestaalineal, denominado cuantificador, tal como la funcin signo, que responde a lasiguiente expresin 1. {

y = +1 si x 0y = 1 si x < 0 (1)

El sistema completo, formado por un combinador lineal adaptativo y un elementoalineal a la salida de denomina adaline. En la figura 2 que sigue podemos apreciarel diagrama en bloques del adaline.

Pesos

Vector depatrn deentrada

Xk

X2k

X3k

Xnk

Xk

Wnk

W3k

W2k

W1k

Wk

X1k

SalidaLineal

SalidaBinaria(+1,-1)

2

Entrada deRespuesta Deseada

(seal de entrenamiento)

ErrorLineal

dk

sk

x0k

yk

k

+

-Algoritmo

LMS

-1

+1

Dispositivode umbral

Peso deumbral

=+1 Entrada de corte

ADALINE

Figura 2: Diagrama en bloques del adaline.

Note en la figura 2 la entrada x0k, siempre alimentada con un valor constante+1, con el propsito de controlar el umbral del cuantificador. Para el ajuste de loscoeficientes s puede utilizar el algoritmo de los cuadrados mnimos.

El adaline tiene la propiedad de separabilidad lineal, por ejemplo si analizamosun adaline con dos entradas, como lo muestra la figura 3, podemos apreciar que se

4

determina una recta de separacin en el espacio de las combinaciones de entrada,en este caso un plano.

X0 = +1

X1

X2

W0

W1

S(n)

W2

+1

-1

Y(n)

Figura 3: Diagrama en bloques del adaline de dos entradas.

La salida lineal S(n) tiene la siguiente expresin 2:

S(n) = W0 +X1(n)W1 +X2(n)W2 (2)

Si igualamos a cero la ecuacin 2, tenemos:

X2(n) = W1W2

X1(n) W0W2

(3)

La ecuacin 3 describe la recta que separa el plano de estados posibles de entrada,en la misma se pueden reconocer la pendiente m = W1

W2y la ordenada al origen

b = W0W2

. Las combinaciones de entrada por arriba de la recta de separacin generanuna salida de 1, y las combinaciones por debajo una salida de +1.

Entre las alternativas posibles para la eleccin del cuantificador, s encuentra lafuncin sigmoidea, la cual tiene la siguiente expresin 4:

Y (n) = SIG[S(n)] = tanh[S(n)] =1 e2S(n)1 + e2S(n)

(4)

En una implementacin prctica de una neurona, es conveniente incluir todaslas alternativas posibles de cuantificacin y clculo error, de manera de poder im-plementar ms de un algoritmo de optimizacin.

Por ejemplo si se utiliza en lugar del error lineal instantneo, el error a la salidadel cuantificador, el algoritmo de optimizacin de coeficientes se denomina regla delPerceptron, desarrollada por F. Rosenblatt.

La diferencia entre el error cuadrtico medio tomado de la salida lineal, con elerror tomado a la salida de la funcin sigmoidea es una respuesta ms abrupta porparte del error sigmoideo.

5

La eleccin por una u otra funcin de cuantificacin depende de muchos factores,entre ellos como se implementan dichos cuantificadores. Por ejemplo si se construyeuna red neuronal con hardware, es mucho ms fcil implementar la funcin signo(simplemente con un comparador analgico).

Otra alternativa es utilizar la funcin sigmoidea durante el entrenamiento, porquecon ella es posible llegar a mejores optimizaciones, para luego durante la operacinde la red utilizar la funcin signo. El diagrama en bloques completo de la neuronase muestra en la figura 4.

X1

X0 = +1

X2

X3

X4

W1W0

W2

e(n)

d(n)

S(n)

W3

W4- +

+1

-1

e1(n)

d1(n)

Y1(n) Y2(n)

- +

+1

-1

e2(n)

d2(n)

- +

Figura 4: Diagrama en bloques del adaline completo, con salidas y errores lineales,sigmoideos y signo.

En dicha figura 4 podemos apreciar que para cada error debe suministrarse lasalida deseada.

Cuando se conectan ms de una neurona, se conforma una red neuronal, esnecesario en la mayora de las aplicaciones conectar varias neuronas, debido a queaumenta notablemente la capacidad de reconocimiento de patrones.

Las redes neuronales se organizan en capas, formadas por una cantidad de neu-ronas cada una de ellas, generalmente son de dos o tres capas, denominndose lascapas en las cuales entra el vector de entrada y donde se genera el vector de salida,capas de entrada y salida, respectivamente; las capas restantes entre la entrada y lasalida se denominan capas ocultas.

La figura 5 muestra un diagrama general de una red neuronal de tres capas, noteque el vector de entrada ingresa a todas las neuronas de la primera capa, la cualgenera un vector de salida de dicha capa, que sirve para alimentar las neuronas de

6

la capa oculta, y as sucesivamente las seales conforman el vector de salida.

Vectorde entrada

Capade entrada

Capade salida

Capaoculta

Vectorde salida

Figura 5: Diagrama general de una red neuronal de tres capas.

Para el aprendizaje de una red neuronal, al igual que para una neurona simple,se puede utilizar el mtodo de cuadrados mnimos, pero es necesario tener en cuentapara la optimizacin de todos los pesos de todas las neuronas que conforman la red,el error producido a una salida deseada en el vector de salida.

Entre todos los mtodos que se han desarrollado hasta el momento, se destacael mtodo de retropropagacin, debido al impacto que gener en la bibliografaposterior.

El mtodo de retropropagacin busca propagar el error al valor deseado del vectorde salida, en sentido inverso al flujo de informacin a travs de la red neuronal; paralograr esto el error llega a las capas anteriores multiplicado por el peso de las capasposteriores.

Antes de comenzar el proceso de aprendizaje, generalmente se inicializan lospesos de todas las neuronas con valores aleatorios pequeos, despus comienza elaprendizaje, el cual puede durar una cantidad de iteraciones determinadas previa-mente, o bien buscar un error de salida mnimo, o ambos mtodos en caso de nolograr el error mnimo.

La figura 6 muestra el diagrama de una red neuronal de dos capas, con el mtodode retropropagacin, los bloques denominados SIG desarrollan la funcin sigmoidea,ecuacin 4, y el bloque denominado SIG desarrolla la ecuacin 5 dada a continua-cin:

SIG[S(n)] ={tanh[S(n)]}

{S(n)} = 1 {tanh[S(n)]}2 = 1 Y 2(n) (5)

De esta forma la ecuacin que optimiza los pesos por el mtodo de los cuadrados

7

mnimos queda expresada de la siguiente forma:

Wk(n+ 1) = Wk(n) 2ek(n)[1 Y 2(n)]Xk(n) (6)

3. Implementacin de una red neuronalUna red neuronal se forma a partir de la modelizacin de ua neurona, en el

listado que sigue se implement una neurona a travs de la clase CombinadorLinea-lAdaptativo, dentro de ella estn encapsuladas todas las propiedades necesarias parael funcionamiento de un objeto que maneja un vector de datos Xk, un vector de pe-sos Wk, y otras variables tales como el error Ek, la cantidad de elementos Cantidady el valor del coeficiente de velocidad de optimizacin , adems de las funcionesnecesarias para la carga de los vectores, el clculo de salida y la optimizacin de loscoeficientes del filtro.

Adems en dicho listado se encuentra la clase RedNeural, que conecta variasneuronas para formar una red de dos capas, en la primera capa se encuentran 100entradas a 5 neuronas, y en la segunda capa 3 neuronas. Para la optimizacin de lared neuronal se implement el mtodo de retropropagacin.

3.0.1. Cdigo fuente de NEURAL3.H

// NEURAL3.H

#include #include #include #include

class CombinadorLinealAdaptativo{public:

float *Xk;float *Wk;float Sk;float Ek;float Eks;float Ekd;float Dk;float Yk;float yk;float Alfa;int Cantidad;

CombinadorLinealAdaptativo();

8

X

+1

W0

10W

410

W11

0

W21

0

W31

0

S10

Alg

orit

mo

LM

S

SIG

SIG

+

X

+1

W0

11W

411

W11

1

W21

1

W31

1

S11

Alg

orit

mo

LM

S

SIG

SIG

+

X

+1

W0

12W

412

W11

2

W21

2

W31

2

S12

Y10 Y11

X

+1

W0

20W

420

W12

0

W22

0

S20

Alg

orit

mo

LM

S

SIG

SIG

+-

+

-

+

X

+1

W0

21W

421

W12

1

W22

1

S21

Alg

orit

mo

LM

S

SIG

SIG

+

Y1

Y0 d

1

d0

Y12

Alg

orit

mo

LM

S

SIG

SIG

+

X0 X1

X2 X3

Figura 6: Diagrama general de una red neuronal de tres capas.

9

CombinadorLinealAdaptativo( int n);~CombinadorLinealAdaptativo();

void Calcula( void);void CantidadSynapsis( int n = 50);void LlenaPesos( float *Array, int cantidad);void LlenaEntradas( float *Array, int cantidad);void LlenaPesos( float *Array);void LlenaEntradas( float *Array);void LlenaSalidaDeseada( float Salida);void LlenaAlfa( float a);

float MuestraSalidaLineal( void);float MuestraSalidaDigital( void);float MuestraSalidaSigmoidea( void);float MuestraErrorLineal( void);float MuestraErrorSigmoidea( void);float MuestraErrorDigital( void);void MuestraSet( void);

void CalculaNuevoSet( void);void CalculaNuevoSet( float ek);int GuardaPesos( char *name);int LeePesos( char *name);};

// Red Neuronal de dos capas

class Red Neural{public:

int NumberInputs;float deseada[4]; valores deseados

// Primera capaCombinadorLinealAdaptativo *C100;CombinadorLinealAdaptativo *C101;CombinadorLinealAdaptativo *C102;CombinadorLinealAdaptativo *C103;CombinadorLinealAdaptativo *C104;CombinadorLinealAdaptativo *C105;CombinadorLinealAdaptativo *C106;CombinadorLinealAdaptativo *C107;CombinadorLinealAdaptativo *C108;CombinadorLinealAdaptativo *C109;

10

CombinadorLinealAdaptativo *C110;CombinadorLinealAdaptativo *C111;CombinadorLinealAdaptativo *C112;CombinadorLinealAdaptativo *C113;CombinadorLinealAdaptativo *C114;CombinadorLinealAdaptativo *C115;CombinadorLinealAdaptativo *C116;CombinadorLinealAdaptativo *C117;CombinadorLinealAdaptativo *C118;CombinadorLinealAdaptativo *C119;// segunda capaCombinadorLinealAdaptativo *C20;CombinadorLinealAdaptativo *C21;CombinadorLinealAdaptativo *C22;CombinadorLinealAdaptativo *C23;

Red Neural();Red Neural( int inputs);~Red Neural();

void LlenaEntradas( float *d);void LlenaEntradas2( float *d);void CalculaNuevoSet( float *d);void CalculaNuevoSet2( float *d);

float MuestraSalidaDigital1( void);float MuestraSalidaDigital2( void);float MuestraSalidaDigital3( void);float MuestraSalidaDigital4( void);};

3.0.2. Cdigo fuente de NEURAL3.CPP

// NEURAL3.CPP

#include "neural3.h"#include

#define ALFAINICIAL 1e-3

CombinadorLinealAdaptativo::CombinadorLinealAdaptativo( int n){Alfa = ALFAINICIAL;Ek = 1.0;Dk = 1.0;

11

Eks = 1.0;Ekd = 1.0;Cantidad = n + 1;Xk = new float[Cantidad];Wk = new float[Cantidad];for( int j = 0; j < Cantidad; j++){

Xk[j] = 0.0;Wk[j] = float(random(1000))/10000.0;}

}

CombinadorLinealAdaptativo::CombinadorLinealAdaptativo(){Alfa = ALFAINICIAL;Ek = 1.0;Dk = 1.0;Eks = 1.0;Ekd = 1.0;}

void CombinadorLinealAdaptativo::CantidadSynapsis( int n){Cantidad = n + 1;Xk = new float[Cantidad];Wk = new float[Cantidad];for( int j = 0; j < Cantidad; j++){

Xk[j] = 0.0;Wk[j] = float(random(1000))/1000000.0;}

}

CombinadorLinealAdaptativo::CombinadorLinealAdaptativo(){delete Xk;delete Wk;}

void CombinadorLinealAdaptativo::LlenaPesos( float *Array, int Cantidad){for( int j = 0; j < Cantidad; j++)

Wk[j] = Array[j];}

void CombinadorLinealAdaptativo::LlenaPesos( float *Array){for( int j = 0; j < Cantidad; j++)

Wk[j] = Array[j];}

void CombinadorLinealAdaptativo::CalculaNuevoSet( void){

12

for( int j = 0; j < Cantidad; j++){Wk[j] = Wk[j] + Alfa*ek*Xk[j];}

}

void CombinadorLinealAdaptativo::CalculaNuevoSet( float ek){for( int j = 0; j < Cantidad; j++){

Wk[j] = Wk[j] + Alfa*ek*Xk[j];}

}

void CombinadorLinealAdaptativo::MuestraSet( void){cout

void CombinadorLinealAdaptativo::LlenaEntradas( float *Array){int j;for( j = 0; j < Cantidad; j++){

Xk[j] = Array[j];}

Calcula();}

void CombinadorLinealAdaptativo::LlenaSalidaDeseada( float Salida){Dk = Salida;}

void CombinadorLinealAdaptativo::LlenaAlfa( float a){if( a >= le-12 && a < 0.1)

Alfa = a;else

Alfa = le-12;}

float CombinadorLinealAdaptativo::MuestraSalidaLineal( void){return Sk;}

float CombinadorLinealAdaptativo::MuestraSalidaSigmoidea( void){return yk;}

float CombinadorLinealAdaptativo::MuestraSalidaDigital( void){return Yk;}

float CombinadorLinealAdaptativo::MuestraErrorLineal( void){return Ek;}

float CombinadorLinealAdaptativo::MuestraErrorSigmoidea( void){return Eks;}

float CombinadorLinealAdaptativo::MuestraErrorDigital( void){return Ekd;}

int CombinadorLinealAdaptativo::GuardaPesos( char *name){

14

ofstream A;A.open( name);if( !A)

return -1;A

C115 = new CombinadorLinealAdaptativo(NumberInputs);C116 = new CombinadorLinealAdaptativo(NumberInputs);C117 = new CombinadorLinealAdaptativo(NumberInputs);C118 = new CombinadorLinealAdaptativo(NumberInputs);C119 = new CombinadorLinealAdaptativo(NumberInputs);//C20 = new CombinadorLinealAdaptativo(20);C21 = new CombinadorLinealAdaptativo(20);C22 = new CombinadorLinealAdaptativo(20);C23 = new CombinadorLinealAdaptativo(20);}

// Red Neuronal de dos capas

RedNeural::RedNeural( int inputs){NumberInputs = NumberInputs;C100 = new CombinadorLinealAdaptativo(NumberInputs);C101 = new CombinadorLinealAdaptativo(NumberInputs);C102 = new CombinadorLinealAdaptativo(NumberInputs);C103 = new CombinadorLinealAdaptativo(NumberInputs);C104 = new CombinadorLinealAdaptativo(NumberInputs);C105 = new CombinadorLinealAdaptativo(NumberInputs);C106 = new CombinadorLinealAdaptativo(NumberInputs);C107 = new CombinadorLinealAdaptativo(NumberInputs);C108 = new CombinadorLinealAdaptativo(NumberInputs);C109 = new CombinadorLinealAdaptativo(NumberInputs);C110 = new CombinadorLinealAdaptativo(NumberInputs);C111 = new CombinadorLinealAdaptativo(NumberInputs);C112 = new CombinadorLinealAdaptativo(NumberInputs);C113 = new CombinadorLinealAdaptativo(NumberInputs);C114 = new CombinadorLinealAdaptativo(NumberInputs);C115 = new CombinadorLinealAdaptativo(NumberInputs);C116 = new CombinadorLinealAdaptativo(NumberInputs);C117 = new CombinadorLinealAdaptativo(NumberInputs);C118 = new CombinadorLinealAdaptativo(NumberInputs);C119 = new CombinadorLinealAdaptativo(NumberInputs);//C20 = new CombinadorLinealAdaptativo(20);C21 = new CombinadorLinealAdaptativo(20);C22 = new CombinadorLinealAdaptativo(20);C23 = new CombinadorLinealAdaptativo(20);}

RedNeural::~RedNeural(){delete C100;

16

delete C101;delete C102;delete C103;delete C104;delete C105;delete C106;delete C107;delete C108;delete C109;delete C110;delete C111;delete C112;delete C113;delete C114;delete C115;delete C116;delete C117;delete C118;delete C119;

delete C20;delete C21;delete C22;delete C23;}

void RedNeural::~RedNeural( float *d){C100->LlenaEntradas( d, NumberInputs);C101->LlenaEntradas( d, NumberInputs);C102->LlenaEntradas( d, NumberInputs);C103->LlenaEntradas( d, NumberInputs);C104->LlenaEntradas( d, NumberInputs);C105->LlenaEntradas( d, NumberInputs);C106->LlenaEntradas( d, NumberInputs);C107->LlenaEntradas( d, NumberInputs);C108->LlenaEntradas( d, NumberInputs);C109->LlenaEntradas( d, NumberInputs);C110->LlenaEntradas( d, NumberInputs);C111->LlenaEntradas( d, NumberInputs);C112->LlenaEntradas( d, NumberInputs);C113->LlenaEntradas( d, NumberInputs);C114->LlenaEntradas( d, NumberInputs);C115->LlenaEntradas( d, NumberInputs);C116->LlenaEntradas( d, NumberInputs);C117->LlenaEntradas( d, NumberInputs);

17

C118->LlenaEntradas( d, NumberInputs);C119->LlenaEntradas( d, NumberInputs);

float salida[20];salida[0] = C100->MuestraSalidaSigmoidea();salida[1] = C101->MuestraSalidaSigmoidea();salida[2] = C102->MuestraSalidaSigmoidea();salida[3] = C103->MuestraSalidaSigmoidea();salida[4] = C104->MuestraSalidaSigmoidea();salida[5] = C105->MuestraSalidaSigmoidea();salida[6] = C106->MuestraSalidaSigmoidea();salida[7] = C107->MuestraSalidaSigmoidea();salida[8] = C108->MuestraSalidaSigmoidea();salida[9] = C108->MuestraSalidaSigmoidea();salida[10] = C110->MuestraSalidaSigmoidea();salida[11] = C111->MuestraSalidaSigmoidea();salida[12] = C112->MuestraSalidaSigmoidea();salida[13] = C113->MuestraSalidaSigmoidea();salida[14] = C114->MuestraSalidaSigmoidea();salida[15] = C115->MuestraSalidaSigmoidea();salida[16] = C116->MuestraSalidaSigmoidea();salida[17] = C117->MuestraSalidaSigmoidea();salida[18] = C118->MuestraSalidaSigmoidea();salida[19] = C119->MuestraSalidaSigmoidea();

C20->LlenaEntradas( salida, 20);C21->LlenaEntradas( salida, 20);C22->LlenaEntradas( salida, 20);C23->LlenaEntradas( salida, 20);}

void RedNeural::LlenaEntradas2( float *d){C100->LlenaEntradas( d, NumberInputs);C101->LlenaEntradas( d, NumberInputs);C102->LlenaEntradas( d, NumberInputs);C103->LlenaEntradas( d, NumberInputs);C104->LlenaEntradas( d, NumberInputs);C105->LlenaEntradas( d, NumberInputs);C106->LlenaEntradas( d, NumberInputs);C107->LlenaEntradas( d, NumberInputs);C108->LlenaEntradas( d, NumberInputs);C109->LlenaEntradas( d, NumberInputs);C110->LlenaEntradas( d, NumberInputs);C111->LlenaEntradas( d, NumberInputs);C112->LlenaEntradas( d, NumberInputs);

18

C113->LlenaEntradas( d, NumberInputs);C114->LlenaEntradas( d, NumberInputs);C115->LlenaEntradas( d, NumberInputs);C116->LlenaEntradas( d, NumberInputs);C117->LlenaEntradas( d, NumberInputs);C118->LlenaEntradas( d, NumberInputs);C119->LlenaEntradas( d, NumberInputs);

float salida[20];salida[0] = C100->MuestraSalidaDigital();salida[1] = C101->MuestraSalidaDigital();salida[2] = C102->MuestraSalidaDigital();salida[3] = C103->MuestraSalidaDigital();salida[4] = C104->MuestraSalidaDigital();salida[5] = C105->MuestraSalidaDigital();salida[6] = C106->MuestraSalidaDigital();salida[7] = C107->MuestraSalidaDigital();salida[8] = C108->MuestraSalidaDigital();salida[9] = C108->MuestraSalidaDigital();salida[10] = C110->MuestraSalidaDigital();salida[11] = C111->MuestraSalidaDigital();salida[12] = C112->MuestraSalidaDigital();salida[13] = C113->MuestraSalidaDigital();salida[14] = C114->MuestraSalidaDigital();salida[15] = C115->MuestraSalidaDigital();salida[16] = C116->MuestraSalidaDigital();salida[17] = C117->MuestraSalidaDigital();salida[18] = C118->MuestraSalidaDigital();salida[19] = C119->MuestraSalidaDigital();

C20->LlenaEntradas( salida, 20);C21->LlenaEntradas( salida, 20);C22->LlenaEntradas( salida, 20);C23->LlenaEntradas( salida, 20);}

void RedNeural::CalculaNuevoSet( float *d){// optimizacion por el metodo LMSfloat error[20];float salida[20];

// La informacion se propaga a traves de la redLlenaEntradas( d);

// Comienza la optimizacion

19

salida[0] = deseada[0] - C20->MuestraSalidaSigmoidea();salida[1] = deseada[1] - C21->MuestraSalidaSigmoidea();salida[2] = deseada[2] - C22->MuestraSalidaSigmoidea();salida[3] = deseada[3] - C23->MuestraSalidaSigmoidea();

salida[0] = salida[0]*(1.0- (C20->MuestraSalidaSigmoidea();*C20->>MuestraSalidaSigmoidea()));




C20->CalculaNuevoSet( salida[0]);C21->CalculaNuevoSet( salida[0]);C22->CalculaNuevoSet( salida[0]);C23->CalculaNuevoSet( salida[0]);

error[0] = salida[0]*C20->Wk[0] + salida[1]*C21->Wk[0]+ salida[2]*C22->Wk[0] + salida[3]*C23->Wk[0];













error[13] = salida[0]*C20->Wk[13] + salida[1]*C21->Wk[13]

20

+ salida[2]*C22->Wk[13] + salida[3]*C23->Wk[13];error[14] = salida[0]*C20->Wk[14] + salida[1]*C21->Wk[14]






+ salida[2]*C22->Wk[19] + salida[3]*C23->Wk[19];

error[0] = error[0]*(1.0- (C100->MuestraSalidaSigmoidea()*C100->MuestraSalidaSigmoidea()));















error[0] = error[0]*(1.0- (C115->MuestraSalidaSigmoidea()

21

*C115->MuestraSalidaSigmoidea()));error[0] = error[0]*(1.0- (C116->MuestraSalidaSigmoidea()




*C119->MuestraSalidaSigmoidea()));

C100->CalculaNuevoSet( error[0]);C101->CalculaNuevoSet( error[1]);C102->CalculaNuevoSet( error[2]);C103->CalculaNuevoSet( error[3]);C104->CalculaNuevoSet( error[4]);C105->CalculaNuevoSet( error[5]);C106->CalculaNuevoSet( error[6]);C107->CalculaNuevoSet( error[7]);C108->CalculaNuevoSet( error[8]);C109->CalculaNuevoSet( error[9]);C110->CalculaNuevoSet( error[10]);C111->CalculaNuevoSet( error[11]);C112->CalculaNuevoSet( error[12]);C113->CalculaNuevoSet( error[13]);C114->CalculaNuevoSet( error[14]);C115->CalculaNuevoSet( error[15]);C116->CalculaNuevoSet( error[16]);C117->CalculaNuevoSet( error[17]);C118->CalculaNuevoSet( error[18]);C119->CalculaNuevoSet( error[19]);}

float RedNeural::MuestraSalidaDigital1( void){return C20->MuestraSalidaDigital();}



float RedNeural::MuestraSalidaDigital4( void){

22

return C23->MuestraSalidaDigital();}

3.1. Ejemplo de identificacin de patrones con redes neuro-nales

En el ejemplo que sigue a continuacin se busca la identificacin de patrones porparte de una redes neuronal R. Dicha red es de dos capas, con un vector de entradade 100 elementos, y con 5 neuronas en la primera capa y 3 en la segunda, formandoas un vector de salida de tres elementos.

La red R se entrena con tres patrones, que corresponden a los nmeros 6, 8 y 5,los cuales forman una grilla de 10 por 10 elementos, buscando las salidas deseadas[-1,1,1,-1], [1,1,-1,-1] y [1,-1,1,-1], respectivamente.

A continuacin se pueden apreciar las grillas correspondientes a los nmeros 8,6, 5 y 6 con ruido.

3.1.1. OCHO.TXT

0 0 0 0 0 0 0 0 0 00 0 10 10 10 10 10 0 0 00 0 10 0 0 0 10 0 0 00 0 10 0 0 0 10 0 0 00 0 10 10 10 10 10 0 0 00 0 10 0 0 0 10 0 0 00 0 10 0 0 0 10 0 0 00 0 10 10 10 10 10 0 0 00 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0

3.1.2. SEIS.TXT

0 0 0 0 0 0 0 0 0 00 0 10 0 0 0 0 0 0 00 0 10 0 0 0 0 0 0 00 0 10 0 0 0 0 0 0 00 0 10 10 10 10 10 0 0 00 0 10 0 0 0 10 0 0 00 0 10 0 0 0 10 0 0 00 0 10 10 10 10 10 0 0 00 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0

23

Por otro lado la red R2 se entrena con las grillas de los nmeros 5 y 6, buscandolas salidas deseadas (1,1,1) y (-1,-1,-1) respectivamente.

Las grillas se encuentran en archivos de texto, con los elementos de la mismaseparados por tabulador y retorno de carro, como se muestra a continuacin:

3.1.3. CINCO.TXT

0 0 0 0 0 0 0 0 0 00 0 10 10 10 10 10 0 0 00 0 10 0 0 0 0 0 0 00 0 10 0 0 0 0 0 0 00 0 10 10 10 10 10 0 0 00 0 0 0 0 0 10 0 0 00 0 0 0 0 0 10 0 0 00 0 10 10 10 10 10 0 0 00 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0

3.1.4. SEIS2.TXT

0 10 0 0 0 0 0 0 0 00 0 10 0 0 0 10 0 10 00 0 10 0 0 0 0 0 0 00 0 10 0 0 0 0 0 0 00 0 10 10 10 10 10 10 0 00 0 10 0 0 0 10 0 0 00 0 10 0 0 0 10 0 0 00 10 10 10 10 10 10 0 0 00 0 0 10 0 0 0 0 0 00 0 0 0 0 0 10 0 0 0

3.1.5. Cdigo fuente de NUMERO.CPP

// NUMERO.CPP

#include "neural3.h"#include #include #include

float numero[10][10];

24

float *num1 = new float[100];float *num2 = new float[100];float *num3 = new float[100];float *num4 = new float[100];

void main( void){

RedNeural R(100); // 100 entradas, 10 x 10 pixelsint j, k, l:

// para entrenar la red, leemos dos numeros, 8 y 6// Lee numero 8ifstream numero1;numero1.open("OCHO.TXT");l = 0;for( j = 0; j < 10; j++){

for( k = 0; k < 10; k++){numero1 >> numero[j][k];cout

num3[l++] = numero[j][k];}

cout > numero[j][k];cout

apunteredesneuronales_parte2

Documents