parte 1 - TESIUAMI

INDICE
.,
lntroducclon ...........................................................................................................
1
PARTE 1. RED DE HOPFIELD ..........................................................................
2
La Red Binaria de Hopfield: Estructura Básica .......................................
El Procedimiento de Actualizaci6n ......................................
3
....................4
Convergencia ..............................................................................................
S
Aplicacion de Hopfield : Reconocedor de Patrones
..............................................7
., Funcional ................................................................................
Descripcmn
7
Programa dela aplicación de Hopfield .....................................................
9
PARTE
II.RED RETRO PROPAGACI~N........................................................
.,
Propagaclon hacia adelante.......................................................................
Aplicacion de la Red Retro Propagación ..............................................................
.,
Descripuon Funcional ................................................................................
Especificación de la Arquitectura de l a s redes ..........................................
de
.
-
25
29
32
32
32
la apllcaclon ..........................................................................
33
Programa de la aplicación de Retro Propagacih .....................................
34
Funciones
.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 efectivoaccrcamicnto a un amplio
campo de aplicaciones. Los sistemas neuronalesresuelvenproblemas quc involucran
patrones, mapeo de patrones, krminaci6n de patrones y claificaci6n de patrones (los
patronespueden ser completados con un sistemaneuronal que ha sido adiestrado o
educadopara recordar los modelos completos); puedenseraplicadosparatrasladar
imsgenes, predicci6n de negocios, mapeode imiígenes visualesa comandos rob6ticos
Las Redes Neuronales utilizan una estructura deprocesamiento 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 elementode procesamiento esa ligado a
muchosde sus vecinos (normalmente cientos o miles), a s € que hay muchas m&
interconexiones que elementos de procesamiento.
Las redes neuronales existen ennuestraimaginaci6n
y es inexorable desear
comprenderlas, y en suma obtener una nueva íitileria tecnol6gica, con la cual podemos
hacer computadoras con la capacidaddeproduciraproximaciones
adecuadas a
problemas anteriormente irresolubles.
PARTE 1
PAgioa 2
Por medio de una publicaci6n John Ilopfield introduce en 1982 la arquitectura
deunared a la cual pone su apcllido. En tCrminos claros y simples, describe como la
capacidad computacional puedeser 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 reddeHopfieldrenov6
el inter& entusiastapor las
redes neuronalcs.
La red binaria de Hopfieldtiene una capa simple deelementos de procesamicnto;
o "cstado" que es
cadaelemento de procesamientotieneuna"valordeactivaci6n"
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. Elestado 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 porel 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 enunared
de
Hopfield, junto con un ejemplo de estados. El
estado de la redpuedecambiar al determinar los
valores de los elementos individuales modificados.
Los elementos deprocesamiento
en la red de
Hopfield estan totalmente interconectados (cada elemento esta conectado con cada uno
de los demb elementos). En realidad las conexionesson"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" porquelas 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 valorescalar),
el peso del clc~ncnroj al clemcnto i. En la rcd de Hopfield, el peso
Denotaremos con Ti;
Tjiy el Titienen 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
memoriaasociativa.Muchasredesconpesosdiferentes
(Tjj# TJ tambienconvergen
afortunadamente.
La figura 2 muestra un &todo
alternativode dibujar lasinterconexiones:
los eleme,ntos de procesamiento aparecen en
una fila y las interconexiones en una matriz
dctrabajo. Note quecon n elementos,hay
n(n-1) interconexiones. Cada
peso
de
la
conexi6nes un puntointerconectadoen
la
matriz. El peso es
representado
por
un
circulo
sombreado
en
la
correspondiente
interconexi6n(n6teseque
en i=j no hay
interconexi6n). El peso de1 elemento i al j se
muestra debajo del elementoj donde la linea
Elgura 2.
debajo del elemento j intercepta la linea del
deuna aplicaci6nen.
elementooriginal i. Los pesosdelasconexionessonelinicio
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
deHopfielden
el cual un elemento es actualizado a lavez. El procedimientode
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
lueno 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 Idc
I los clcmentos de procesamiento
puede scr mayor o menor quc cero. Si I n S U I ~ cs
L ~menor que ccm, entonces la salida dcl
elemento es un conjunto de +l's. Si la suma es n m o r 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
enserie, repitiendo la secuencia hasta lograr un estado estable. Los mccanisrnos de
actualizacidnpropuestospor Hopfield nosonsimples. 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
1982demostr6 que esta red alcanza eventualmente dicho estadoestable.
Laactualizacidn al azar utilizada en la red de Hopfield proporciona una
en redes
diferencia importante entre esta y otros paradigmas.Otrosparadigmas
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 Hopfieldes casi igual a la realidad biol6gica.
CONVERGENCIA
Cada estado de la red de Hopfield tiene un valorde "energia" asociado. Este
valor es definido como :
n
1
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 porla 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 dcproccsamicnto j es
dada por :
n
1
Ej = - 5
T..u.u.
I' J 8
(4)
i&j
;
la cual rearreglando queda :
Cuando el elementoj esactualizado, 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 :
n
1
- E,vieja=
- 5 Au,
T,i ui
A E j E Jnueva
.
i
donde
i#j
-
~j . .
= Jnueva
vteJa
AU. U.
J
(6)
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:
AEj'O
Si ujcambia de l' a O, entonces :
n
i
despues de la actualizaci6n en (2). Reordenando valoresen al ecuacidn (6), obtenemos :
AEj<
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 alcanzaun estado estable.
Pdgina 6
-
I
I
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
patrones se gcneraron aleatoriamcntc y sc: almacenaron cn una red de Hopfield.
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 conayuda, 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 tienenen 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 losPatrones es la establecida al Crear la arquitectura.
Amender
En esta opci6n, el programa"Memoriza
los Patrones" de la arquitectura
proporcionada; generandola Matriz de Pesos que sera utilizada en la Consulta.
Pilgina 7
I
1
Consultar
"
Aquf el usuario puede efectuar dos tipos de Consultas :
1) Lote : Varios Patrones.
Cadauno de los patrones quc crearon la Red es aplicado a lamisma;generandose
o no el reconocimiento de cada uno dcellos.
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 regresaraun patr6n, el cual es el Patr6n Aplicado (Patrbn Reconocido)
o un Patr6n Aproximado (Patr6n no Reconocidoo Espurio).
Directorio
Permite al usuario cambiar deDrive 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).
I
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 deRECONOCER PAI'RONES.
La red formada consta de capas (layers) y elementos de procesamienlo
(neuronas).
La red puede reconocer patrones de cerosy unos que el usuariole 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 problemao 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 cerosy 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
lorlgitud.
3.- El numero maxim0 de'patrones que puede tenerun problema
son 60 *.
4.- La longitud maxima que pueden tener los patrones es de 150
caracteres *.
* Cuestiones de Metnoria.
#include <stdlib.h>
##include <stdio.b
##include <string.b
#include a n 3 t h . b
#include <ctype.b
#include "co1ores.h"
Mefine pos-x-menspal
PROFESOR :
Rene Mackinney Romero.
ALUMNOS :
Arturo Galván Roque.
86328836.
Alfred0 Gonzsllez
Velez.
853227384.
.
5
PAgina 9
#define x-ayu
#dcfinc y-ayu
15
8
#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
1
2
3
#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
10
13
8
30
"ARQS,HOP/CAT"
...
I
4
5
6
7
8
9
10
11
12
13
14
15
16
17
r
".ARV
".APR"
".PES"
/* constantes fundamjntales*/
#define MAXLONG 140 /* nút$ero m s b o delongituddepatronesenlecturaenMatriz
*/
#define MAXLONLIN 60 /* n*ero m k w o delongituddepatrones en lecturaenlinea */
#define MAXCOL
40 /* núm ro mhirqo de columnasdela matriz decapturadepatrones */
#define MAXREN
20 /* n t h ro rnbimo derenglonesde la matriz decapturadepatrones *I
#define MAXPATRON 60 /* númbro m W o de patrones a memorizar */
#define FIN
2
'e
typedef smct {
char pW1;
char ind;
1opts;
extern char titO,dir-inicu,nomgr@bl];
extern char !lag,*su,*mem;
void-(void);
Pagina 10
A
l
I
"ac,
int Aprendi?aje(char,cl~ar,cl~ar);
void Crca-Arq(ch,char);
void Captura-Patrones(char,clm);
voidLee_Mauiz(cIxu[],char);
void cursor(cku,char,char *,char *);
void Lect-LongPatr(char [],int *&a *,char *,char *,char,cl~ar);
voidMemo-Patrontvoid);
void Recupcra(char [],cliar [I);
voidCons-lnt(char);
voidCons-Pato;
voidAprende();
voidGuarda-Pesostvoid);
voidLxc-Arq(char [I);
void Arqs-Exisrs(char,cha,char);
void k-Pesos(void);
void Mete-Patrones(char,char);
voidCarga-Patrones();
int Menu(char,char,char,Opcs 0 , c h
ar,char,char,char);
intLee-Dato(char0,char.char.char.c
void Desp_Opcs_Menu(char,~ar,cha char,Opcs n,char *,char *);
void Captllfa_Text(in~in~in~infintir1;
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* arreglo de apuntadores que controlara
los renglones de la matriz de pesos */
I* Variables tilizadas en el aprendizajey la consulta
para caract izar una red de Hopfield particular */
typedef stnrct{
char patron[MAXLONG+l];
]
Cadena;
Cadena patrslMAxpATRONl;
longitud;
int
char lin_ma~num,col,n~ren;
patrones;
int
char
nom-prob[lon-arq+l];
FILE *filel,*file2,*file3;
I* arreglo con los patrones a memorizar
(y para la consulta)
*I
I* longitud de los patrones de entrada.
Ademasdefine el tamaño de la
matriz
(cuadrada
de
pesos).
*/
I* cantidad de patrones a memorizar *I
/* nombre de un problema particular *I
I* apunta 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;
1
Venma(O,O.O,"");
else
{ do { for(i4; icnum-afqs; ++i)
i f (!feof(file2))
else break;
fclose(file2);
1
Desuipcion : Permite al
problema
del loslongitud
de
y la
problema
archivo "HOP-ARQS.CAT.
void Crea-Arq(char x,char y)
{
int temp-lon,exist;
temp[O]=lO'; cprintf(" Arquitectura : ");
do
else
{ exist=O;
(una nuevadel
nombre
red); el
es
el guardado
en
".
-
do ( fsccmf(file2,"
(!strcmp(lemp,nombre))
.if
) while (!feof(file2));
fclose(file2);
I
~
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~,&~rnif (flag)
I
Ventana( 1,O,O," Creando la E3 clura
if ((file2 = fopcn(fnombre,"w"r= NI
{ Error(0," No se puede abrirel 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
)1
%S
Red %s",tqmp);
",fnombre)l; flag=O; )
de nombres *I'
AL,
1
ro %S ",fnomtin); flag=O; }
lc2); }
-
Current-Window();
clrscro;
Clo:
if (flag) { sucpy(nomgrob,temp); ,longitud
num-col=tem-col;
nuq-ren=te
) I* CreaArq */
.
I la
-3ec
IJindow0;
np-bn; lin-mpt=tem-cap;
en;
1
' ,
FUNGI<
Description : Perinite al usupio met
sea en Linea o en Matriz.
,ect-Long_P/ltrO
1 longitud de
los patrones para ser capturados ,sea ya
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' en[3],op
'!
#definen 2
Mefine d3 18
Opcs ArrO={"Captura en Linea"4 '2.
"Captura enMatriz",l2};1,
JF
P
Desp-Opcs-Menu(menu-lonlong,x,Si(ji3,An;"
while (opc)
PAgina 13
i
switch(opc)
{ case 1: Pos-Window(nun~e-lon,x+2,y
",~cmp);
cprintf(" Longitud de los I%~lroncs
do {
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
"
,l. I , 1 ,ty*,~);
setcursor(());
I
dc los Pauones = %d ",MAXLONLIN); ]
:-Widdlow();
Esc=Cancela ","Arquitectura
case 2: Pos~Window(nume~lon,x+2,y
",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,"
",MAXCOL); }
} while ((aux~col[O]==lOII *
if (flag)
I
{ do {
i
setcursor( 1); Lee-Dato(au$
if (*tem-ren>MAMZEN
",MAXREN); 1
~,
una lbpgitud de Columnas en la Matriz = %d
&=o) k&flag);
,2,29,1, , l . 1,'N.O); setcursor(0);
-ren+O)
Current-Windowo;
clrsc1-0;
*tem-cap='"; break;
} if (flag) ope@ else flag=l;
1
~
i
1
Current-Window();
M,1,1:I~,w,o); sctcursor(0);
,"
as)
clrscr0;
close-U
1
Renglones en la Matriz = %d
&& flag);
I Long! de
} while (*tern-lon==O && flag){
1
; au~,?on[O]=aux~col[O]=aux~rcn[O]=lO';
ixima~Longitud
de
if (*tem-lon>MAXLONG
*tem-lon=O; }
~
.S)
{ *ternwren=@
%S
los Patrones = %d ",*tern-lon,MAXLONG);
,e-WibpowO;
I
~
~
OW(); I
I
1
;
I
I
- L o
Pagina 14
Descripcion : Lee del <non
problema.
void Lee-Arq(char nom-arq[])
.[
int c;
char horn[ 131;
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);
strcpy(temp,nom-prob);
Tits-!
wring(
do
{ setcursor(1); Lee-Dato(temp.8,
if (flag)
if ((file2=fopen(arch-arqarsq"f":
{ Error(0," No se puede abri
else
{ exist=O;
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)
.
J
i
{ sprintf(fnombre,"%s~s",~mp,c~
if ((filel=fopcn(fnombrc,"w")) =:
{ EIYM(O,"NO
se p u d e abrir el
else
{ Pos-Window(nwne_~at,x.t13
",longitud);
cpfintf(" N" de Patrones Entrar
do t
sclcursor(1); Lcc-Dato(auxtcmpgat=abs(atoi(aux-pat):
if (kmp-pat > MAXPATRC
{ ternp-pat=O; Error(0," Ni
] while ((auxgat[O]==lO II tc
if (flag)
{
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.
I
'
1
*
fclose(file1);
Current-Windowo;
clrsc
1
1
CurrentWindowO;
chao;
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)
Kecreal.e-Window(ma
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;)
Lce”auiz@atrs[i].pa
{ case -115: if (i > O)
case -111: if (i
<pa
if (!flag) break;
Current-Windowo;
break;
for(j=O; j<num-ren; ++j)
c
b
for(i=@printf(”bb “); icnum-cc
~ntf(”%c”,pauon~num_col*.
) I
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 11: if (func) flag=let; ba
case -115: if (func) flag=let; ba
1
-1
else switch (let)
{ case 13:
band=O;
case 27: flag=& b
a
n
d
*
;
default: if (let=’O II let :
palron[num-col*j+
else if @atron[num-co
let=patron[numelse 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
PAgina18
-._
ISpone 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 : a
t
a funcion st
parte de Memo-PauonO.
La salida es calculada utilizar
ser) los pauoncs que aprendio en I;
Esta funcion tambien puede
(cuando la consulta es intcractiva).
c el usuario IC dc desde el tccladc
nwl) :
void Recupera(char enlradan,char si
{
registerint i j ;
int retorna,numjte=0;
in1 SFIAXLONG];
char nsalida[MAXLONG+l]
sucpy(salida,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;
1while (retorna != FIN);
} /* Recupera */
*ma&)
Wgina 24
I
CIÓN
Pdgina 25
Una simulacidn anima
R
........
......:.:
De'.&m,
......
.....
...
me. m10
0.75
;
1.00
0.25 : 0.50
om
: 0.25
mles de
:tivocibo
actualizacidn. Las 2 rejas re
cuadro determinamos el valor
es y los pesos. Los cuadros de
niento con diferentes valoresde
sos, con el sombreado de cada
erconexi6n. La escala numCrica
Ir de actualizaci6n y sus pesos,
porque cadatipo 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
haciaadelante por medio d
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 redamenudo.
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
cadacapasiguiente,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
dc procesamiento es utilizado
)r grande de 6 indica que una
lcja la dirccci6n en la cual los
l
LANTE
ltando un patron a la red. Cada
'ector. DespuCs de actualizar la
an los pesos de la propagaci6n
S capas.
".ci
......
......
.:...........
....
....
.....:....,...:.:......
KSJ
lacia adelante.
....,:..:.
. ..
......
....
. ....
.
.
:
i
.....
...
I
ropagaci6n hacia adelante. Los
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
3
Pagina 29
lcmcntodeprocesamiento
j,
tda son un caso especial; estos
50s dc entrada,solotoman
el
de procesamiento extra como
muestra lafig 8 y 9). Estos
tctuaci6n de l. Cada elemento
esamiento de la siguiente capa
pagacidn Retro-Error.
I
~
que el resultado se mejore
rcionan un "umbral" eficiente.
e con un termino constante en
:noidal. Esto esequivalentea
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 trasladadala grflka a la
' de la curva senoidal, del valor
;o extra proporciona un umbral
elemento de procesamiento j
PAgina 30
I
La red esta formada por
;nan aleatoriamentc.
;lMis.
C.-Constante d
X.- Posici6n de
'ntal.
V.-Velocidad 1
zrtical.
Fuerza : Fuerzaaplicadapor 1
tratar de mantener e
Grado : Indica el ndmerode
(izquierda 6 derecha), para
palito (con respecto a la
i)N
red aleatoriamen
zando todos las variables de la
ver a presionar "Alto".
ca, permitiendo ver en detalle
)r la foca y los cambiosen las
GUARDAR :
Guarda el estado
CARGAR:
Recupera un esta
SALIR:
Finalizaci6n de 1
# LSTENTOS: Indica el n~mero
TIEMPO:
Indica el tiempo
de los intentos.
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 ADIESlR
' AR A UNA
RDO UN PALITO SOBRE SU
110sde procesamiento (neuronas).
alcs)
:uronas))
i n Roque
86328836.
talez Velez 85327384.
Pagina 34
I
1
para construirla 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
ropagacion bottom-up del patron dc
-
I
,
umbr
I
e salid
unid I
** cac
*'
bral
*/
3 cap
aril*/
k[mlidad I
nplo i
cap3
-
-
ultima capa esc. = sal*/
Mgina 38
i
I
a red y los almacena en variables
a
ra verificar el adiestramiento.
PAgina 40
red de la send de error en cl
146259
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
1
+= err-ejemp[i] * .err-ejemp[
/** 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 salidaco
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 duranteel
@s.da1
.
I
"
i creada durante el aprendizaje.
Phgina 43