I N D I C E

lntroducclon 1

PARTE 1. RED DE HOPFIELD .......................................................................... 2

La Red Binaria de Hopfield: Estructura Básica ....................................... 3

El Procedimiento de Actualizaci6n ...................................... ........... ......... 4

Convergencia .............................................................................................. S

Aplicacion de Hopfield : Reconocedor de Patrones .............................................. 7

., ...........................................................................................................

., Descripcmn Funcional ................................................................................ 7 -

Programa de la aplicación de Hopfield ..................................................... 9

PARTE II. RED RETRO PROPAGACI~N ........................................................ 25 ., Propagaclon hacia adelante ....................................................................... 29

Aplicacion de la Red Retro Propagación .............................................................. 32

Descripuon Funcional 32 ., ................................................................................ Especificación de la Arquitectura de l a s redes .......................................... 32

Funciones de la apllcaclon 33

Programa de la aplicación de Retro Propagacih ..................................... 34

. . e ..........................................................................

Los sistemas neuronales artificiales toman su nombre dc las c6lulas nerviosas dentro del cerebro. Aunque una gran park dc detalles biol6gicos son eliminados en los modelos computacionales, los sistemas ncuronales mantienen gran parte de la cstructura del cerebro para proporcionar conocimiento andlogamenre al trabajo biol6gico de m a neurona. Asf estos modelos contribuyen a los importantes rctos cicntfficos (cl cercbro comprcndiendose a si mismo).

Los sistemas neuronales proporcionan un efectivo accrcamicnto a un amplio campo de aplicaciones. Los sistemas neuronales resuelven problemas quc involucran patrones, mapeo de patrones, krminaci6n de patrones y claificaci6n de patrones (los patrones pueden ser completados con un sistema neuronal que ha sido adiestrado o educado para recordar los modelos completos); pueden ser aplicados para trasladar imsgenes, predicci6n de negocios, mapeo de imiígenes visuales a comandos rob6ticos

Las Redes Neuronales utilizan una estructura de procesamiento paralelo que tiene un gran número de elementos de procesamiento (neuronas) y muchas interconexiones entre ellos, estos elementos de procesamiento son demasiado simples como la CPU. Dentro de una red neuronal cada elemento de procesamiento esa ligado a muchos de sus vecinos (normalmente cientos o miles), a s € que hay muchas m& interconexiones que elementos de procesamiento.

-

Las redes neuronales existen en nuestra imaginaci6n y es inexorable desear comprenderlas, y en suma obtener una nueva íitileria tecnol6gica, con la cual podemos hacer computadoras con la capacidad de producir aproximaciones adecuadas a problemas anteriormente irresolubles.

PARTE 1

PAgioa 2

Por medio de una publicaci6n John Ilopfield introduce en 1982 la arquitectura de una red a la cual pone su apcllido. En tCrminos claros y simples, describe como la capacidad computacional puede ser construida de componentes similarcs a las ncuronas. Describe una aplicacidn (Memoria Asociada) yuc pucde ser implementada con csta red, y dcmuestra la optimizacibn de problemas quc n o pueden ser resucltos por m6todos tradicionales. La aparici6n de la red de Hopfield renov6 el inter& entusiasta por las redes neuronalcs.

La red binaria de Hopfield tiene una capa simple de elementos de procesamicnto; cada elemento de procesamiento tiene una "valor de activaci6n" o "cstado" que es binario (uno de dos valores posibles). Aqui usaremos cl estado binario O y 1 (La red trabaja de la misma manera si se utilizan los valores de +1 y -1, pero se requiere de pequeñas modificaciones en la red).

Toda la red es considerada para tener un "estado" en cada momento. El estado es un vector de ceros y unos. Cada entrada en el vector corresponde a un elemento de procesamiento individual en la red. Asf en un momento dado, el estado total de la red esta representado por el vector : -

u = ( UI,U2,U3 ,... yu,,) = (+ + - ... +)

Este vector representa una red de n elementos de procesamiento, donde el elemento i tiene el estado U i ; en esta notaci6n, un + representa un elemento de procesamiento con el valor binario 1, y un - representa un elernento de procesamiento con un valor de O. La figura 1 muestra el diagrama de elementos de procesqiento en una red de Hopfield, junto con un ejemplo de estados. El estado de la red puede cambiar al determinar los valores de los elementos individuales modificados. Los elementos de procesamiento en la red de

Hopfield estan totalmente interconectados (cada elemento esta conectado con cada uno de los demb elementos). En realidad las conexiones son "dirigidas", y cada par de elementos de procesamiento tiene una conexi6n en cada direcci6n (ver la figura 1). Esta topologia de interconexiones hace la red "recursiva" porque las salidas de cada elemento alimenta entradas de otros elementos en la misma capa. Como veremos, esta organizacidn recursiva intenta permitir a la red un relajamiento en un estado estable en la ausencia de entradas externas.

Phgina 3

Cada interconexih tienc un pcso awcido (cstc pcso es un valor escalar), Denotaremos con Ti; el peso del clc~ncnro j al clemcnto i. En la rcd de Hopfield, el peso Tji y el Ti tienen el mismo valor, por consipicnic :

T.. = T.. I' 'J

El aniílilisis matcmfitico demuestra que cuando esta igualdad es verdadera, la red es capaz de converger - conseguir eventualmente en un estado estable-. La convergencia de la red es necesaria para representar computacionalmente tareas como optimizaci6n y memoria asociativa. Muchas redes con pesos diferentes (Tjj # TJ tambien convergen afortunadamente.

Elgura 2.

La figura 2 muestra un &todo alternativo de dibujar las interconexiones: los eleme,ntos de procesamiento aparecen en una fila y las interconexiones en una matriz dc trabajo. Note que con n elementos, hay n(n-1) interconexiones. Cada peso de la conexi6n es un punto interconectado en la matriz. El peso es representado por un circulo sombreado en la correspondiente interconexi6n (n6tese que en i=j no hay interconexi6n). El peso de1 elemento i al j se muestra debajo del elementoj donde la linea debajo del elemento j intercepta la linea del

elemento original i . Los pesos de las conexiones son el inicio de una aplicaci6n en. particular.

EL PROCEDIMIENTO DE ACTUALIZACI~N

Inicialmente, la red es asociada a un estado para cada elemento de procesamiento. Un procedimiento de actualimci6n es aplicado a los elementos de la red de Hopfield en el cual un elemento es actualizado a la vez. El procedimiento de actualizaci6n afecta el estado de cada elemento, cambiando a cada momento el resto de la red. La actudizaci6n de los elementos de procesamiento se continúan haciendo hasta lue no puedan hacerse mas cambic

La figura 3 ilustra los procesos bhicos realizados por una red binaria de Hopfield durante el proceso de actualizacih de los elementos. Cada neurona toma la suma de los pesos de las entradas, de acuerdo a la siguiente ecuaci6n :

n si = x u j Tjj (1)

i=l i$j

.I >

Cuando esta suma es calculxi;1, la C V ~ I U ~ L C ~ O I I dc los clcmentos de procesamiento puede scr mayor o menor quc cero. Si I n S U I ~ L ~ cs menor que ccm, entonces la salida dcl elemento es un conjunto de +l's. Si la suma es nmor que cero, la salida de la unidad es un conjunto de ceros. En ternlinos matemdticos :

Un sistema para el proceso de actualimci6n consiste en actualizar los elementos en serie, repitiendo la secuencia hasta lograr un estado estable. Los mccanisrnos de actualizacidn propuestos por Hopfield no son simples. L a actualimci6n al azar tiene ventajas en la implementaci6n (cada elemento puede generar las siguientes actualizaciones) y en la funcidn (la actualimci6n lleva a la red a un estado estable).

Normalmente, muchas actualizaciones tienen que ser realizadas para todos los. elementos de procesamiento antes de que la red alcance un estado estable. Hopficld en 1982 demostr6 que esta red alcanza eventualmente dicho estado estable.

La actualizacidn al azar utilizada en la red de Hopfield proporciona una diferencia importante entre esta y otros paradigmas. Otros paradigmas en redes neuronales tienen a lo m& una capa de elementos de procesamiento actualizando al mismo tiempo (o casi al mismo tiempo). En contraste, la actualizaci6n bincrona de la red de Hopfield es casi igual a la realidad biol6gica.

CONVERGENCIA

Cada estado de la red de Hopfield tiene un valor de "energia" asociado. Este valor es definido como :

1 n E = - 5 Ti, ujui (3)

j i i$j La ecuaci6n se refiere a una "energid", aunque no crea energia en realidad como

un sistema fisico. La funci6n energia en la ecuaci6n (3) es una funci6n objetivo que es minimizada por la red.

Las siguientes actualizaciones de la red de Hopfield provocan una "convergencia": procedimiento en el cual la energia total de la red cada vez es menor. Eventualmente la red provoca un estado estable; en este estado estable, la energfa es mfnima. Esta energfa minima puede ser local o global.

Es posible demostrar que a cada momento un elemento de procesamiento es actualizado. La energia de la red es la misma o se decrementa. El resultado del procedimiento de actualizaci6n intenta dejar siempre menos o igual energia en la red para converger a un minimo.

PAgina 5

Sup,oniendo que cl elcnlento j 1:s cl prhxinlo clcmcnto dc prvccsamicnto para ser actualizado; entonces, la porcidn dc E afcctada por cl clcmcnto dc proccsamicnto j es - I dada por : I

1 n Ej = - 5 T..u.u.

I' J 8 (4) ; i&j

la cual rearreglando queda :

Cuando el elementoj es actualizado, si allf no es cambiado su estado, entonces la energfa Ej es la misma. Si hay cambio en el estado, entonces la di€ercncia cn Ej es :

1 n A E j E . Jnueva - E,vieja= - 5 Au, T,i ui (6)

i i#j

donde AU. U . - ~j . .

J = Jnueva vteJa

si uj cambia de O a 1, entonces : n

i

despues de la actualizaci6n de acuerdo con la ecuaci6n (2). Reacomodando la ecuaci6n (6), obtenemos:

A E j ' O Si ujcambia de l' a O, entonces :

n

i

despues de la actualizaci6n en (2). Reordenando valores en al ecuacidn (6), obtenemos :

A E j < O

puesto que AEjes el producto de tres números negativos. hi, .el cambio en E es siempre negativo o cero no importando que cambios haya en el estado del elemento j en la actualizaci6n. La red es garantizada para converger con E tomando valores mis y m& bajos hasta que la red alcanza un estado estable.

Pdgina 6

I

El número mAximo de Patrones que pucdc memorizar una Red de Hopfield cs de 0.15N donde N es el numero de elementos dc procesamiento de la Red. Este resultado fue obtenido experimentalmente por Hopfield en 1982. En dicho expcrimento, los I

patrones se gcneraron aleatoriamcntc y sc: almacenaron cn una red de Hopfield. 1

El menu esta construido de tal manera que el usuario dice su nplicaci6n completa con solo recorrer cada una de las opciones del menú de arriba hacia abajo. Ademas; cada una de l a s opciones cuenta con ayuda, la cual se activa pulsando la tecla FI.

Las opciones dcl menú tambiCn se pucden activar oprimiendo l a lctra que esta resaltada en cada una de las opciones. "

Se utiliza la tecla "ESC" para regresar al menú anterior (en el caso de la opci6n de consulta que tiene un submenu).

OPCIONES DEI, MENU -

Listar Arauitecturas Existentes

Muestra las arquitecturas existentes en el drive indicado por la opci6n de directorio; esto es, permite al usuario consultar las arquitecturas que se tienen en el directorio de trabajo.

Crear Nueva Arauitectura

Permite al usuario Crear una Nueva Arquitectura; proporcionando el nombre de la arquitectura y la-Longitud de los Patrones a guardar.

Meter Patrones

Permite al usuario introducir los Patrones (cadenas de O's y 1's) a una arquitectura que de antemano se haya creado.

L a longitud de los Patrones es la establecida al Crear la arquitectura.

Amender

En esta opci6n, el programa "Memoriza los Patrones" de la arquitectura proporcionada; generando la Matriz de Pesos que sera utilizada en la Consulta.

Pilgina 7

Consultar "

Aquf el usuario puede efectuar dos tipos de Consultas :

1) Lote : Varios Patrones.

Cada uno de los patrones quc crearon la Red es aplicado a la misma; generandose I o no el reconocimiento de cada uno dc ellos.

1) lnteractiva : Un Patr6n a la vez.

A partir de un Patr6n de entrada que se aplica a la Red de Hopfield activa en ese momento; la Red regresara un patr6n, el cual es el Patr6n Aplicado (Patrbn Reconocido) o un Patr6n Aproximado (Patr6n no Reconocido o Espurio).

Directorio

Permite al usuario cambiar de Drive y Directorio, eligiendo el PATH de trabajo.

Terminar la Sesión -

Finaliza la Sesi6n de Trabajo. Al termino de la Sesi6n se regresara al directorio y Drive inicial (Solo si es posible).

IBROfl,CJ'O TKRMIflM,. JJ

W D mURONAI, M i J1OI'JJJJSJ.D

Descripcion : El programa Miliza la E D NEURONAL DE HOFELD para resolver el problema de RECONOCER PAI'RONES.

La red formada consta de capas (layers) y elementos de procesamienlo (neuronas).

La red puede reconocer patrones de ceros y unos que el usuario le de. Los datos que requiere una red se guardan en los archivos con extensiones:

.PES (Mauiz de pesos)

.ARQ (Ndmero de entradas (neuronas))

.APR (Patrones a memoriSu)

Datos necesarios para la construcci6n de una red:

1 .- El nombre del problema o aplicaci6n. 2.- Indicar la longitud de los patrones. 3.- Número de patrones que va a contener el problema 4.- Una serie de patrones de ceros y unos.

NOTAS : 1.- Los patrones que utiliza la red son cadenas de UNOS y CEROS. 2.- Todos los patrones de un problema deben ser de la misma

3.- El numero maxim0 de'patrones que puede tener un problema

4.- La longitud maxima que pueden tener los patrones es de 150

* Cuestiones de Metnoria.

lorlgitud.

son 60 *.

caracteres *.

PROFESOR : Rene Mackinney Romero. .

ALUMNOS : Arturo Galván Roque. 86328836.

Alfred0 Gonzsllez Velez. 853227384.

#include <stdlib.h> ##include <stdio.b ##include <string.b #include an3th.b

#include <ctype.b #include "co1ores.h" Mefine pos-x-menspal 5

PAgina 9

#define x-ayu #dcfinc y-ayu

#define vent-ayud #define menu-ppal #define menu-cons #define menulong #define vent-arq #define arqs-cxi #define name-arq #define nume-Ion #define arqs-pat #define numegat #define acep-pat #define paw-rec #define paw-sal #define despgat #define vent-dir #define maw-ent #define matr-sal

#define num-arqs #define nun-paw #define Ion-arq #define max-ite #define mh-arqs #define ext-arq #define ext-pat #define e x t p s

15 8

1 2 3 I

4 5 6 7 8 9 10 11 12 13 14 15 16 17

10 13 8 30 "ARQS,HOP/CAT" ".ARV

. ..

".APR" ".PES"

r

/* constantes fundamjntales */

#define MAXLONG 140 /* nút$ero m s b o de longitud de patrones en lectura en Matriz */ #define MAXLONLIN 60 /* n*ero m k w o de longitud de patrones en lectura en linea */ #define MAXCOL 40 /* núm ro mhirqo de columnas de la matriz de captura de patrones */ #define MAXREN 20 /* n t h 'e ro rnbimo de renglones de la matriz de captura de patrones *I #define MAXPATRON 60 /* númbro m W o de patrones a memorizar */ #define FIN 2

typedef smct { char pW1; char ind;

1 opts;

extern char titO,dir-inicu,nomgr@bl]; extern char !lag,*su,*mem;

void -(void);

Pagina 10

A l I

" a c ,

int Aprendi?aje(char,cl~ar,cl~ar); void Crca-Arq(ch,char); void Captura-Patrones(char,clm); void Lee_Mauiz(cIxu [],char); void cursor(cku,char,char *,char *); void Lect-LongPatr(char [],int *&a void Memo-Patrontvoid); void Recupcra(char [],cliar [I); void Cons-lnt(char); void Cons-Pato; void Aprende(); void Guarda-Pesostvoid); void Lxc-Arq(char [I); void Arqs-Exisrs(char,cha,char); void k-Pesos(void); void Mete-Patrones(char,char); void Carga-Patrones(); int Menu(char,char,char,Opcs 0 , c h int Lee-Dato(char 0,char.char.char.c void Desp_Opcs_Menu(char,~ar,cha void Captllfa_Text(in~in~in~infintir void DespIiega_Ayuda(cha,char); void Despliega_Texto(char,char); void Lin-x_y(char x,char,char,char *, ##include "glob-path"

int pesos[MAXLONG]~AXLONG

I* Variables para caract

typedef stnrct{

] Cadena;

Cadena patrslMAxpATRONl;

int longitud;

char patron[MAXLONG+l];

char lin_ma~num,col,n~ren; int patrones; char nom-prob[lon-arq+l];

I* apunta FILE *filel,*file2,*file3;

*,char *,char *,char,cl~ar);

ar,char,char,char); char,Opcs n,char *,char *); 1;

I* arreglo de apuntadores que controlara los renglones de la matriz de pesos */

tilizadas en el aprendizaje y la consulta izar una red de Hopfield particular */

I* arreglo con los patrones a memorizar (y para la consulta) *I

I* longitud de los patrones de entrada. Ademas define el tamaño de la matriz (cuadrada de pesos). */

I* cantidad de patrones a memorizar *I /* nombre de un problema particular *I

res para la manipulacion de ficheros *I

Pagina 11

{ char car,nombrc[lon-arq+ 1J.i;

Pos-Window(num-ven,x,y); Tils-Window(" Esc=Fín "," Arquitec ");

gctcho; Venma(O,O.O,""); 1

else { do { for(i4; icnum-afqs; ++i)

i f (!feof(file2))

-

else break;

fclose(file2); 1

Desuipcion : Permite al (una nueva red); el nombre del problema y la longitud de los del problema es guardado en el archivo "HOP-ARQS.CAT.

void Crea-Arq(char x,char y) {

int temp-lon,exist;

temp[O]=lO'; cprintf(" Arquitectura : "); do

else { exist=O;

"".

do ( fsccmf(file2," - .if (!strcmp(lemp,nombre))

) while (!feof(file2)); I fclose(file2); ~

1 1

while*((lemp[0)==10"11 exist) && flpg); if (flag)

{ sp~U(fnombre,"%s%s",temp,c~t-arq); Lecr-~ngPatr(ternp,sremp-l~,&~rn- if (flag)

I Ventana( 1 ,O,O," Creando la E3 clura if ((file2 = fopcn(fnombre,"w"r= NI

{ Error(0," No se puede abrir el Arch else

{ fprintf(file2,"%d %c %d %flln",ten - fclose(file2);

P Coloca el nombre de la red ab el fich if ((file2=fopen(arch-arqs,'I/a")) = :

{ Error(0,'' No se puede ahif el A else

{ fprintf( file2,"%sb",tem)p); fclo: 1

Ventana(O,O,O,""); - 1

1 Current-Window(); clrscro; Clo: if (flag) { sucpy(nomgrob,temp); ,longitud

num-col=tem-col; nuq-ren=te ) I* CreaArq */ . -3ec ' ,

FUNGI<

Description : Perinite al usupio met sea en Linea o en Matriz.

void Lect-~ng_Patr(temp,tem_looi,tem-~~ char tempU; iot *km-lon; char *tem-cap,*tem_col,*tem-i n,x,y;

{ char aux~lon[3],aux~co1[3J,aux JF ' en[3],op #definen 2 ' !

Mefine d3 18

"Captura en Matriz",l2};1, P Desp-Opcs-Menu(menu-lonlong,x,Si(ji3,An;" while (opc)

Opcs ArrO={"Captura en Linea"4 '2.

I la Red %s",tqmp); 1)

%S ",fnombre)l; flag=O; )

de nombres *I' AL, 1 ro %S ",fnomtin); flag=O; }

lc2); }

IJindow0; np-bn; lin-mpt=tem-cap; en; 1

,ect-Long_P/ltrO

1 longitud de los patrones para ser capturados ,sea ya

PAgina 13

switch(opc) { case 1: Pos-Window(nun~e-lon,x+2,y

cprintf(" Longitud de los I%~lroncs

selcursor(1); Lec-Dato(aux-lon, *tem-lon=abs(atoi(aux-lon)); if (*lem-lon>MAXLONLIN &

{ *temlon=O; Error(0," ) while ((aux-lon[O]==70' II *LCI CumenlWindowO; clrscro; *tern-cap='L'; *Lem-col=*tem-rc

case 2: Pos~Window(nume~lon,x+2,y

"

",~cmp);

do {

",temp); ~

cprintf(" Matriz del Patron de ( do { *tern-lon=O;

do I setcursor( 1);

. *tern-col=abs(atoi(aux,col)); if (*tern-cobMAXCOL &&

{ *tem-col=O; Error(0,"

} while ((aux~col[O]==lO II * if (flag)

",MAXCOL); }

{ do { I

setcursor( 1); Lee-Dato(au$

if (*tem-ren>MAMZEN

i

{ *ternwren=@ ",MAXREN); 1

if (*tem-lon>MAXLONG

*tem-lon=O; } 1

} while (*tern-lon==O && flag){ Current-Windowo; clrsc1-0; 1 * tem-cap='"; break; ~

} if (flag) ope@ else flag=l; 1 ~

Current-Window(); clrscr0; 1 close-U

- L o

i

,l. I , 1 ,ty*,~); setcursor(()); I

dc los Pauones = %d ",MAXLONLIN); ]

:-Widdlow();

Esc=Cancela "," Arquitectura %S

; au~,?on[O]=aux~col[O]=aux~rcn[O]=lO';

M, 1,1: I~,w,o); sctcursor(0); ~

una lbpgitud de Columnas en la Matriz = %d ~,

&=o) k& flag);

-

,2,29,1 , , l . 1 ,'N.O); setcursor(0);

.S) ixima~ Longitud de Renglones en la Matriz = %d

-ren+O) && flag);

as)

, " i

I Long! de los Patrones = %d ",*tern-lon,MAXLONG);

,e-WibpowO; I

OW(); I I

1 ;

I

I

Pagina 14

Descripcion : Lee del <non problema.

void Lee-Arq(char nom-arq[]) .[

int c; char horn[ 13 1;

sprinU(fnom,"%s%s",nom,arq,ext. if (( file1 = fopen(fnom,"r")) == N

{ Emr(0," No Existe la Arquitecl else

{ fscanf(filel,"%d %c %d %d,& fclose(file1); )

) /* Lee-Arq */

Descripci6n : Permite al us6 <nom-prob>.APR.

void Mete-Pauones(char x,char y) t char temp[lon_arq+l],fnombre[l3: int ij,c,exist,temp_pat;

Pos-Window(arqs-pat,x,y); Tits-! strcpy(temp,nom-prob); wring( do

{ setcursor( 1); Lee-Dato(temp.8,

if ((file2=fopen(arch-arqarsq"f": { Error(0," No se puede abri

else { exist=O;

if (flag)

do { fscanf(file2,"%sb",nomi if (!sacmp(temp,nombre)

} while (!feof(file2)); fclose(file2); if (!exist) Error(0," Arquitc

1 1

while ((temp[O]=lO II !exist) &&

if (flag) Lcc-Arq(tcmp); if (flag)

. Ji

{ sprintf(fnombre,"%s~s",~mp,c~ if ((filel=fopcn(fnombrc,"w")) =:

{ EIYM(O,"NO se pude abrir el else

{ Pos-Window(nwne_~at,x.t13 ",longitud);

cpfintf(" N" de Patrones Entrar

sclcursor( 1); Lcc-Dato(aux- tcmpgat=abs(atoi(aux-pat): if (kmp-pat > MAXPATRC

{ ternp-pat=O; Error(0," Ni ] while ((auxgat[O]==lO II tc

if (flag)

do t

{ patrones=abs(atoi(aux_pat): Captura-Patrones(x,y+4); if (flag) { Venlana(l,O,18," Insem

fpr"tf(filel,"%'od",patn for (i=O; i c patrones; +-I sleep( 1); ' Venma(O.0.

' 1 I

fclose(file1); Current-Windowo; clrsc 1

1 CurrentWindowO; c h a o ; if (flag) strcpy(nomgrob,temp);

) /* Mete-Patrones */

F1

Descripci6n : Captura de los 1

void Captura.-Patrones(char x,char y { register int i j ;

char aux [ 151; ++x; switchOhunat) { case z': Recreate-Window(ace

Pos_Window(acepgat,(6 if (longitud > 5) Tits-WiE else Tits-Windol for (i=O; iqtrones; ++i)i for ( i a . icpatrones;) { cprintf(" PatronN"%)

.

*

setcursor(0); switcb(flag)

if (!flag) break;

if (num-col c 8)

else Recreate-Window(ma if (25-y > nurnfeni-4)

Pos-Window(matr-ent, else Pos-Window(matr-en for (i=O; kpatrones; +-ti)

{ for (i=O; jclongitud; + for (i=O; kpatrones;)

Kecreal.e-Window(ma

Lce”auiz@atrs[i].pa

{ case -115: if (i > O) case -111: if (i <pa

if (!flag) break; Current-Windowo; c

break;

for(j=O; j<num-ren; ++j)

for(i=@printf(”bb “); icnum-cc ~ntf(”%c”,pauon~num_col*.

x=y=2; i=j=O; gotoxy(x+i,y+j); sctcursor( 1); while(bmd && flag) { let=getch(); if ( let=’O II lel==’l’ II le1 =32) b if (!b && let!=O && let!=13 && I

{ sound(2000); delay( 100); noso if (iscntrl(1et) && let==O) { lel=getch();

switch (let) { case 71: --j; -4 ; cursor(x,y,&i case 72: --j; cursor(x,y,&i, case 73: --j; ++i; cursor(x,y,& case 75: 4 ; cursor(x,y,&i, case 77: ++i; cursor(x,y,& case 79: ++j; -4 ; cursor(x,y,& case 80: ++j; cursor(x,y,&. case 81: ++j; ++i; cursor(x,y,( case -1 1 1: if (func) flag=let; ba case -115: if (func) flag=let; ba

1 - 1

else switch (let) { case 13: band=O; case 27: flag=& band*; default: if (let=’O II let :

palron[num-col*j+ else if @atron[num-co

let=patron[num- else let=palron[nun

gotoxy(x+i,y+j); putcl 1

1. setcurs0r(0);

1

void cursor(char x,char y,char *i,cha

if (*id) { *i=num-col-1; --(*j); if else if (*i>num-col-l) { *i=O; ++(

else if (*j<O) { *j=num-ren-1; - else if (*j>num-ren-l) { *j=

{

gotoxy(x+*i,y+*j); 1

b

) I

PAgina 18

-._

IS pone cri la matriz de pesos.

Arq. %S ",nom-prob); 1

Matriz de pesos "); }

rificar si es 6 no reconocido por la red

PAgina 2 1

s-Window(aux,””);

Pagina 23

Descripcion : ata funcion st

La salida es calculada utilizar parte de Memo-PauonO.

Esta funcion tambien puede (cuando la consulta es intcractiva).

void Recupera(char enlradan,char si

{ register int i j ;

int retorna,numjte=0; in1 SFIAXLONG]; char nsalida[MAXLONG+l]

sucpy(sal ida,ent ;

do { /* calcula la salida de sucpy(nsalida,salida); for (id; jciongitud; j++) - for (i=SU]=O, klongitud; i+

Su] += (2 * (salida[i]- ++num-ite; for +O; jclongitud; j++)

if (Su] >= O) salidati] = else salidab] = 'o'

/* Comparando con la salic if (!strcmp(dlda,nsalida) II !S@(

retoma=FIN, else retorna = O;

1 while (retorna != FIN); } /* Recupera */

ser) los pauoncs que aprendio en I;

nw l ) :

c el usuario IC dc desde el tccladc

*ma&)

I

Wgina 24

CIÓN

Pdgina 25

Una simulacidn anima

actualizacidn. Las 2 rejas re cuadro determinamos el valor

porque cada tipo de parhetro

Una red retro propag

En cada presentacidn, los pes la red y la salida objeto. Un pares de patrones) es utiliza DespuCs de que la enseñanza

Forward' (hacia adelante) seg propagaciones son realizad propagacidn hacia adelante capa de entrada de la red, y hacia adelante por medio d

........ ...... De'.&m, R ....... ..... .....

:.:

me. m10

0.75 ; 1.00

0.25 : 0.50

om : 0.25

mles de :tivocibo

es y los pesos. Los cuadros de niento con diferentes valores de sos, con el sombreado de cada erconexi6n. La escala numCrica Ir de actualizaci6n y sus pesos,

do aprendizaje supervisado. La apareado con una salida objeto). ir la diferencia entre la salida de In conjunto de entradas .objeto; R presenta a la red a menudo. iento de la red es comprobado.

n comprende una propagaci6n Retroward (hacia at&). Ambas Itado durante la enseñanza. La de un patron de entrada para la dores de activacidn propagando cada capa siguiente, todos los mces aplican la funcidn senoidal

Phgina 28

16n de los patrones de salida de es calculado. Calcula entonces :tualiza los pesos, comenzando as capas de atrb por medio de corrigc los pesos haciendo que

l dc procesamiento es utilizado )r grande de 6 indica que una lcja la dirccci6n en la cual los

LANTE

ltando un patron a la red. Cada 'ector. DespuCs de actualizar la an los pesos de la propagaci6n S capas.

".ci .. . . ... . .... ..:. . ......... .... . . .. . . ..:. . .. . .., . .. : .: . . ... ... .

KSJ .... ...... ,:..:. . .... ..:i .. ... . . . . . . .

...

lacia adelante. I ropagaci6n hacia adelante. Los

3 de procesamiento y wji es el lrocesamiento j (el elemento de xesamiento 39. DespuCs de que calcular F(Sj). La funci6n F es

n sus puntas, y tiene un rapid0

Pagina 29

lcmcnto de procesamiento j ,

tda son un caso especial; estos 50s dc entrada, solo toman el

~ de procesamiento extra como muestra la fig 8 y 9). Estos

tctuaci6n de l. Cada elemento esamiento de la siguiente capa pagacidn Retro-Error.

I

que el resultado se mejore I

rcionan un "umbral" eficiente. e con un termino constante en :noidal. Esto es equivalente a or ejemplo, suponiendo que el igual a 1.0 y su peso es:

?tos de procesamiento de la fig la suma que llega al elemento

loidal f(2) (ver fig loa) y la .e C trasladada la grflka a la ' de la curva senoidal, del valor ;o extra proporciona un umbral elemento de procesamiento j

PAgina 30

La red esta formada por

C.- Constante d

X.- Posici6n de

V.- Velocidad 1

Fuerza : Fuerza aplicada por 1 tratar de mantener e

Grado : Indica el ndmero de

red aleatoriamen

GUARDAR : Guarda el estado

CARGAR: Recupera un esta

SALIR: Finalizaci6n de 1

# LSTENTOS: Indica el n~mero

TIEMPO: Indica el tiempo de los intentos.

;nan aleatoriamentc.

;lMis.

'ntal.

zrtical.

(izquierda 6 derecha), para

palito (con respecto a la

i)N

zando todos las variables de la

ver a presionar "Alto".

ca, permitiendo ver en detalle )r la foca y los cambios en las

intentos, matriz de pesos).

i6n (#intentos, matriz de pesos) :ho estado.

tr la foca para equilibrar el

quilibrio el palito en cada uno

Pggina 33

.

URONAI, DE RETROPI10 oblcma dc ADIESl'RAR A UNA RDO UN PALITO SOBRE SU

110s de procesamiento (neuronas).

alcs) :uronas))

i n Roque 86328836.

talez Velez 85327384.

Pagina 34

1

I

para construir la red , y hace una

le se almacenara la informacion dc la

PAgina 36

I

de atributos de entrada,el numero L estructura de la red.

Pagina 37

IN : p

:d utili

-

I

, umbr

e s a l i d

unid I

** cac bral *'

k[m-

lidad I

nplo i

cap3

-

-

" i

ropagacion bottom-up del patron dc

I

*/

3 cap aril*/

ultima capa esc. = sal*/

Mgina 38

I

a red y los almacena en variables

a ra verificar el adiestramiento.

PAgina 40

red de la send de error en cl

1 4 6 2 5 9

PAgina 41

( *(salidas[m-l]+n ))

/** reuop: cambio dC los pesos **

for ( m = 1 ; m < cap-escs+2; m++ ) { for ( n = O; n < uni-capas[nl]; n t c ) { for ( p = O; p < uni_capas[m-l]; p++ { offset = ( uni-capas[m-11) * n + p; *( pcsoslm-l]+offset ) += *( d e l k

1 1 I* retrop: calculando el error de ejenl err-ejemp[i] = 0.0; for ( m = O; m < uni-capas[cap-escs+ {

err-ejemp[i] += fabs(( sal-esp[i][m 1 err-red += err-ejemp[i] * .err-ejemp[ 1

/** reudp: error de sistema normali

err-red = 0.5 * err-red 7 ejemps;

I* Liberando memoria: delb e m */

free( delts); free( em);

I** retrop: Actualizando la salida co

for ( i = desde0; i < hastan; i++ ) pqW(i);

I* Liberando memoria: sals *I

/* free( sals ); *I

guarda_pesoso; free( pess 1; } /* reuopropag */

PftSina 42

is y umbrales aprendidios durante el @s.da1 . I

" i creada durante el aprendizaje.

Phgina 43