Documentos de Académico
Documentos de Profesional
Documentos de Cultura
FACULTAD DE INGENIERA
ESCUELA DE SISTEMAS
QUITO, 2006
AGRADECIMIENTO
DEDICATORIA
La sabidura no se restringe a la
adaptacin y preservacin indefinida del aprendizaje;
su esencia toma forma cuando se propaga el
conocimiento en el momento adecuado.
CONTENIDO
PAGINA
CAPITULO I
INTRODUCCIN ..
CAPITULO II
TEORA DE RESONANCIA ADAPTATIVA (ART)
2.1 Importancia ...
2.2.2.1
Modelo ART1 ..
2.2.2.2
Modelo ART2 ..
10
2.2.2.3
14
17
18
2.3.2
18
26
2.3.4
28
29
2.3.4.2
Procesamiento en F1 .
31
2.3.4.3
Procesamiento en F2 .
39
2.3.4.4
42
44
2.3.4.6
49
53
CAPITULO III
RED ART1 PARA EL RECONOCIMIENTO DE DGITOS
ESCRITURA LIBRE
3.1 Descripcin del Problema .
56
3.2
57
3.3
Casos de Prueba .
59
59
3.5
Resultados .
61
3.5.1
61
3.5.2
67
CAPITULO IV
DESARROLLO DE LA SOLUCIN DE LA RED ART1
4.1
Implementacin en Delphi
4.1.1
72
Diseo de la Red ..
72
72
4.2 Resultados .
76
4.2.1
Caso 1 ...
79
4.2.2
Caso 2 ...
83
4.2.3
Caso 3 ...
92
4.2.4
Caso 4 ...
95
4.2.5
Caso 5 ...
101
CAPITULO V
CONCLUSIONES Y RECOMENDACIONES
5.1
Conclusiones .
120
5.2
Recomendaciones .
121
FUENTES
122
ANEXOS
ANEXO 1 Cdigo Fuente de la Implementacin del Algoritmo
ART1 en C++ .....
126
138
NDICE DE FIGURAS
PAGINA
12
16
19
de
Reconocimiento
del
Patrn
20
Respuesta
Subliminal
22
24
25
29
32
39
51
57
58
58
61
67
73
74
75
77
78
79
81
82
84
90
91
92
94
95
101
102
Caso
Memoria
Llena
Coincidencias
Encontradas
110
111
112
CAPITULO I
INTRODUCCIN
El reconocimiento de imgenes o patrones puede ser definido como el acto de
asimilar datos sin refinamiento y de realizar una accin de clasificacin en base a la
categora del dato. El reconocimiento de imgenes se convirti en materia de estudio
en los aos 60 y actualmente constituye un importante campo de investigacin en
universidades e industrias alrededor del mundo. A lo largo de los aos con la
intervencin de la Inteligencia Artificial se ha utilizado una diversa gama de modelos
para reconocer patrones, como son los algoritmos de redes neuronales y los sistemas
expertos. Nuestro estudio se enfocar en el primer modelo neuronal de la Teora
Resonancia Adaptativa (ART).
Consideramos de gran utilidad investigar acerca de los principios de ART1 dado que
es un algoritmo que no goza de la misma difusin de otros como perceptrn,
perceptrn multicapa o mapas autoorganizativos de Kohonen. Otra razn importante
es el sinnmero de aplicaciones que posee ART1, que incluyen aparte del
reconocimiento de caracteres, el diseo y manufactura de aviones, reconocimiento
automtico de blancos, previsiones financieras, monitoreo de maquinarias, diseo de
circuitos digitales, anlisis qumico y visin de robots.
En este contexto reconocemos que entender el marco terico del algoritmo y crear un
sistema de redes neuronales basadas en este modelo permitirn identificar y difundir
las bondades de ART1, generar posibles soluciones a diversos problemas y
finalmente implementar estas soluciones en la vida prctica.
El presente trabajo de grado tiene como objetivo realizar una descripcin funcional
del algoritmo ART1 y construir una red neuronal para el reconocimiento de dgitos
de escritura libre. Este trabajo contiene adems un software que implementa dicha
red en el lenguaje de programacin Delphi.
CAPITULO II
Proceso en el cual una red neuronal artificial crea su base de conocimientos mediante ejemplos
representativos.
una capa de entrada de la red, que facilita el aprendizaje de informacin nueva sin
destruir la informacin anterior.
El modelo ART cuenta con tres propiedades cruciales:
1. La normalizacin de toda la actividad de la red. Los sistemas biolgicos
generalmente se adaptan muy fcilmente a grandes cambios en su ambiente.
Por ejemplo, el ojo humano puede adaptarse a grandes variaciones en la
intensidad de la luz.
2. Mejoramiento por contraste de los patrones de entrada. Reconocer
diferencias leves en los patrones de entrada puede significar mucho en
trminos de supervivencia. Distinguir una leona escondida de una en
descanso puede constituir una diferencia de vida o muerte para una cebra. El
mecanismo que se utiliza para revelar estas diferencias se conoce como
mejoramiento por contraste.
3. Memoria a corto plazo (STM ) (Short Term Memory) del patrn mejorado
por contraste. Antes de que el patrn de entrada pueda ser decodificado,
debe ser almacenado en una memoria a corto plazo. La memoria a largo
plazo (LTM) (Long Term Memory) implementa un mecanismo de excitacin
(clasificacin), mientras que la STM es usada para causar cambios graduales
en la LTM.
La arquitectura bsica de una red ART se muestra en la Figura 2.1. A continuacin,
se presenta una breve descripcin de los elementos que actan en esta red (su
funcionamiento detallado se presentar a lo largo de este captulo):
Las flechas nos indican las conexiones entre componentes y las seales de
excitacin (+) (azul) y de inhibicin (-) (rojos) que son envidados de, hacia y
a travs de estos.
Grado de respuesta al estmulo generado al aplicar un vector de entrada sobre una neurona.
Arquitectura
10
ART2 debe
11
Adems la figura 2.4 ilustra algunas de las caractersticas de ART2 que no son
compartidas por todos los sistemas ART. Una de las mencionadas caractersticas es
el campo multicapa (tres capas) F1. Tanto F1 como F2 y adems el campo de
prepocesamiento F0 son redes competitivas que realizan mejoramiento por contraste
y normalizacin a sus patrones de activacin.
Ahora describiremos a los componentes de una red ART2 para lo cual nos guiaremos
en la figura anterior.
El Campo de Prepocesamiento F0: Un vector de entrada I es transformado en el
campo F0. Cada capa de este campo de memoria a corto plazo (STM) lleva a cabo
dos clculos:
1. Suma las entradas internas y externas al campo.
2. Normaliza el vector de actividad resultante de la suma.
Estos clculos permiten obtener un vector de salida de F0 al sistema de orientacin y
un vector de entrada al campo F1.
El Campo de Entrada F1: Como en el campo F0, cada capa en F1, suma las
entradas y normaliza el vector resultante. Las operaciones de las dos capas inferiores
(w y u) de F1 son las mismas que las que se llevaron a cabo en las dos capas de F0.
En la capa superior de F1 p , se suma tanto la seal interna u de F1 y todas las
seales filtradas provenientes de F2 a F1.
El Campo de Representacin de Categoras F2: Si F2 se encuentra en estado
inactivo, todas las salidas de F2 a F1 son cero. Un campo competitivo F1 en estado
activo est diseado para realizar una eleccin si solo un nodo de F2 tiene una
memoria STM ha superado el umbral determinado. Este es el nodo que recibe la
mayor entrada total desde F1.
13
La
14
Durante el
15
16
17
Representa el grado de similitud mnimo requerido para que un patrn de entrada sea clasificado
dentro de un patrn ya aprendido.
18
19
G manda una seal excitatoria a todos y cada uno de los nodos de la capa a
F1. Esta seal es conocida como seal no especfica.
20
En la Figura 2.8, se puede ver el proceso que realiza la red en su intento de reconocer
el patrn ingresado:
21
U tambin pasa a ser un segundo patrn de entrada para las unidades F1.
22
Hay tres posibles fuentes de entrada para F1, pero que slo dos de ellas parecen utilizarse en un
instante dado. Las unidades de F1 y F2 estn diseadas de tal forma que permanecen activas
nicamente si dos de las tres posibles fuentes de entrada estn presentes. Esta caracterstica se
denomina Regla 2/3 y su importancia y funcionamiento sern detallados posteriormente.
23
24
En esta vez se puede ver que aparece una nueva actividad Y* en F2, es decir,
aparece un nuevo nodo ganador. Entonces, se reconoce la importancia de que
los nodos participantes en el patrn original Y permanezcan inactivos por los
efectos a largo plazo de la seal de restauracin desde A.
25
26
mucho mayor. La capa F2 podra recibir entradas procedentes de otra capa por
encima de ella, as como de la capa F1 situada ms abajo. Se piensa que esta
estructura jerrquica es frecuente en los sistemas neuronales biolgicos. Si la capa
F2 fuera estimulada por una capa superior, podra producir una salida descendente y
devolver seales a la capa F1. Es posible que esta seal descendente llegase a F1
antes de que llegara a F1 una seal de entrada I procedente de la parte inferior. Una
seal prematura procedente de F2 podra ser el resultado de una anticipacin que
surgiera de un nivel superior de la jerarqua. En otras palabras, F2 est indicando lo
que espera que sea la siguiente seal de entrada, antes que el patrn llegue
realmente a F1.
La aparicin de una seal descendente anticipada procedente de F2 nos plantea un
pequeo dilema. Supongamos que F1 produjese una salida en respuesta a cualquier
vector individual de entrada, independientemente de su origen. Entonces la seal
anticipada procedente de F2 producira una salida de F1, y se producira el ciclo de
bsqueda de coincidencia sin que hubiera llegado a F1 un vector de entrada
procedente de la parte inferior. Vamos a aadir ahora el control de ganancia y la
regla de los 2/3. De acuerdo con lo expuesto en la seccin anterior, si existe G,
entonces cualquier seal procedente de F2
Recordemos que G activa de forma no especfica a todas las unidades de F1. Si est
en vigencia la regla de los 2/3, la inhibicin de G significa que una seal
descendente procedente de F2 no puede, por s misma, desencadenar una salida
procedente de F1. En lugar de esto, las unidades de F1 quedan sensibilizadas, por el
patrn descendente. Si ahora el patrn de entrada esperado se recibe en F1,
procedente de la parte inferior, este condicionamiento previo da lugar a una
27
28
e x k = x k + (1 Ax k )J k (B + Cx k )J k
+
(2.1)
29
xk
Mediante
Jk
Jk
Axk
0 < xk (0) < 1 porque el efecto inhibitorio de una entrada nunca puede exceder a la
entrada excitadora; se sigue que el valor de la excitacin neta sea:
(1 Axk )J k + .
- Cxk representa la inhibicin causada por el resto de neuronas de la capa.
-B
30
cercano a cero, 0 < e << 1 , entonces xk tomar un valor muy grande; es decir,
2.3.4.2 Procesamiento en F1
En la Figura 2.12 se ilustra un elemento de procesamiento de la capa F1, con sus
distintas entradas, salidas y vectores de pesos.
31
32
Vi = u j z ij
(2.2)
j =1
(2.3)
+
K
(2.4)
= I i + D1Vi + B1G
33
(2.5)
(2.6)
En otras palabras, si hay una entrada y F2 no est produciendo una salida, entonces
G=1. Cualquier otra combinacin de actividad de I y de F2 evita prcticamente que
el control de ganancia genere su excitacin en F1.
Vamos a examinar la Ecuacin 2.5 en busca de cuatro posibles combinaciones de
actividad de I y de F2.
Caso 1.- Considrese el caso en que no hay vector de entrada y F2 est inactiva.
Dicha ecuacin se reduce a:
(2.7)
ya que I i , Vi , G = 0.
x1i =
B1
1 + C1
(2.8)
34
(2.9)
ya que Vi = 0.
Cuando las unidades alcanzan sus actividades de equilibrio, es decir cuando
x1i =
Ii
1 + A1 (I i + B1 ) + C1
(2.10)
35
(2.11)
ya que G = 0.
As, en el estado de equilibrio el valor para x1i se obtiene de:
x1i =
I i + D1VI B1
1 + A1 (I i + D1VI ) + C1
(2.12)
36
1 + D1 B1 > 0
B1 < D1 + 1
(2.13)
Toda unidad que no reciba una seal descendente de F2 debe tener una actividad
negativa, incluso aunque reciba una entrada procedente de la parte inferior. En este
caso, debemos tener que I i B1 < 0 , o bien B1 > 1
Caso 4.- Supongamos que F2, est produciendo una salida descendente (quiz como
(2.14)
ya que I i , G = 0.
El estado de equilibrio es:
x1i =
D1VI B1
1 + A1 (I i + D1VI ) + C1
(2.15)
Si una unidad no recibe una entrada neta procedente de F2 (si V I =0) entonces
permanece en su nivel ms negativo de actividad, como en las ecuacin 2.8. Si
V I >0, entonces la actividad de la unidad asciende hasta algn valor superior al de la
ecuacin 2.8, pero debe seguir siendo negativa porque no se desea que la unidad
tenga una salida no nula basada nicamente en entradas descendentes. Entonces, a
partir del numerador de la ecuacin 2.15, se debe tener que:
37
B1 > D1
(2.16)
(2.17)
lugar a que V I <1). En tal caso, la condicin para que la ecuacin 2.12 produzca un
valor positivo es: I i + D1Vi B1 > 0
Dado que I i =1, esta relacin define la siguiente condicin sobre V I :
VI >
B1 1
D1
(2.18)
La ecuacin 2.18 nos dice que la entrada de la unidad vi debida a una seal
descendente que procede de F2 debe satisfacer una cierta condicin umbral para
asegurar una activacin positiva de vi , incluso en el caso de que vi reciba una
fuerte entrada Ii procedente de la parte inferior. Volveremos a este resultado cuando
hablemos de los pesos, o rastros de LTM, que van de F2 a F1.
38
2.3.4.3 Procesamiento en F2
u j de la unidad se vuelven a enviar hacia abajo a F1 (figura 2.13 flecha roja). Este
elemento de procesamiento, recibe entradas procedentes de la capa F1 ( T j ) y un
39
excitadora total J + (figura 2.11) a la neurona v j . Adems esta unidad enva una
seal idntica a g ( x2 j ) a travs de una conexin inhibitoria a todas las neuronas de
la capa F2, excepto a s misma. Por ende, v j recibir estmulos negativos
provenientes de los dems elementos en F2 (figura 2.13 flechas verdes). Estas
entradas forman la entrada inhibidora total J (figura 2.11) a esta neurona.
Las actividades de las unidades estn descritas mediante la ecuacin 2.1. La
entrada neta recibida procedente de la capa F1 se calcula como de costumbre:
M
T j = si z ji
i =1
(2.19)
J j = D2T j + g ( x2 j )
(2.20)
J j = g ( x2 k )
k j
(2.21)
40
x2 j = x2 j + (1 A2 x2 j )( D1T j + g ( x2 j )) ( B2 + C2 x2 j ) g ( x2 k )
(2.22)
k j
1 si T j max{Tk } k
k
u j = f ( x2 j ) =
0 caso contrario
(2.23)
41
salida de
intermedios.
Las ecuaciones que describen los rastros descendentes de LTM (los pesos de las
conexiones de unidades de F2 hasta las unidades de F1) son del tipo de una red
competitiva.
z ij = (-z ij + h(x1i )) f (x 2 j )
(2.24)
Ya que f ( x2 j ) slo es no nula para un nico valor de j (para un nodo de F2, vj), la
ecuacin anterior es no nula slo para conexiones que descienden desde esa unidad
ganadora. Entonces:
42
- z ij + 1 vj y vi estn activados
vj activado, vi inactivo
z ij = - z ij
vj y vi estn inactivos
0
(2.25)
>
B1 1
D1
(2.26)
A no ser que z ij tenga un valor mnimo dado por la ecuacin anterior, ste ir
decreciendo hasta cero an en el caso de que vj est activada y vi est recibiendo una
entrada Ii procedente de la parte inferior.
Desde un punto de vista prctico, todos los pesos de conexin descendentes deben
recibir un valor inicial mayor que le mnimo dado por la ecuacin 2.26, para que as
pueda tener lugar el aprendizaje de la red. En caso contrario, cada vez que un vj est
activado en F2, todas las conexiones que vayan desde l hasta cualquier unidad de
F1 tendern a cero; de tal forma que todos los pesos de la conexin sern nulos, y el
43
un tiempo suficiente para que se equilibren los pesos descendentes, se les puede dar a
los pesos descendentes sus asintticos. Si vj es el nodo ganador de F2, entonces:
1 si vi est activada
z ij =
0 caso contrario
(2.27)
Las ecuaciones que describen los pesos ascendentes de LTM son algo ms
complicadas que las utilizadas para los pesos descendentes de LTM. As, el peso de
la conexin que va desde vi en F1 hasta vj en F2 est dado por:
(2.28)
(2.29)
44
Los pesos de la conexin con otras unidades F2 no van a cambiar puesto que, para
ellas:
f(x2 k ) = 0 , si k j
(2.30)
(2.31)
(2.32)
si F2 est activada
si F2 est desactivada
(2.33)
45
| S | = h(x1i ) ,
i
(2.34)
se tiene que
h(x
k 1
1k
) = h(x1k ) h(x1i ) ,
(2.35)
(2.36)
z ji = K [z ji | S |]
si vi est desactivada y vj activa
si vj est desactivada
0
(2.37)
Debemos recordar que vi puede seguir activada nicamente si recibe una seal de Ii
procedente de la parte inferior, junto con una entrada Vi suficientemente grande
procedente de la parte superior. En el caso del aprendizaje rpido, los pesos del nodo
F2, vJ, toman los valores asintticos dados por:
zJi
= L 1 + | S |
si vi est activada
(2.38)
si vi est desactivada
46
Supongamos que un nodo de F2, vJ1, gana, y que aprende durante la presentacin de
un patrn de entrada, I1, y que otro nodo vJ2 gana y aprende el patrn de entrada I2.
Adems, se tiene que el patrn de entrada I1 un subconjunto del patrn de entrada I2;
esto es, I1 I2 . La prxima vez que se presente I1 o I2, desearamos que ganase el
nodo apropiado de F2. La ecuacin 2.38 nos asegurar que el nodo adecuado gane,
manteniendo a los pesos del nodo que ha aprendido el patrn del subconjunto
suficientemente ms elevados que los del nodo que ha aprendido el patrn del
conjunto ms extenso.
Para el patrn del subconjunto I1, los pesos que vienen de los nodos activos de F1
toman el valor
z J 1,i =
L
L 1+ | I1 |
(2.39)
| S | = | I1 V J | = | I1 | .
(2.40)
z J 2 ,i =
L
L 1+ | I 2 |
(2.42)
47
L | I1 |
L 1+ | I1 |
y
TJ 2 ,1 = z J 2 ,i h( x1i )1
i
L | I1 |
L 1+ | I 2 |
(2.33)
L | I1 |
L 1+ | I1 |
y
TJ 2 ,2 = z J 2 ,i h( x1i ) 2
i
L | I2 |
L 1+ | I 2 |
(2.43)
48
L
L 1+ M
(2.44)
49
(2.45)
o bien
P | I| >Q |S|
P |S|
>
Q |I|
(2.46)
|I|
(2.47)
50
1 , P Q
(2.48)
51
1. Definicin de parmetros:
M: unidades en F1.
N: unidades en F2.
A1 ^ C1 > 0
z ij (0 ) >
B1 1
D1
53
pesos ascendentes: vi vj
L
L 1+ M
B1
1 + C1
en F2: x2 j (0) = 0
Ii
1 + A1 (I i + B1 ) + C1
5. Calcular la salida ( si ) de F1
1 si x1i > 0
s i = h( x1i ) =
0 si x1i 0
T j = si z ji
i =1
1 si T j max{Tk } k
k
u j = f ( x2 j ) =
0 caso contrario
8. Propagar la salida de F2 a F1 y calcular la entrada neta Vi
N
Vi = u j z ij
j =1
54
I i + D1VI B1
1 + A1 (I i + D1V I ) + C1
12. Si
S
I
S
I
De lo contrario, si
S
I
> continuar.
zJi
= L 1 + | S |
si vi est activada
si vi est desactivada
55
CAPITULO III
Buscamos construir una red neuronal ART1 con el fin de utilizarla para resolver el
problema del reconocimiento de dgitos de libre escritura. Este problema radica en
intentar agrupar dentro de una misma clase a dgitos con mnimas variaciones en
forma, pero que representen un mismo valor numrico. En la siguiente figura se
ilustra con un ejemplo el problema a resolver: Los tres patrones, a pesar de la ligera
variacin en su escritura, representan a un mismo valor, el nmero 1.
56
57
58
Se han definido dos casos de prueba para determinar las bondades del algoritmo. El
primer caso de prueba ser el glyph correspondiente al nmero uno (1), mientras que
en el segundo caso se probar el glyph del nmero seis (6).
El prximo paso para probar la red es definir los parmetros que determinan las
caractersticas de la misma. Estos parmetros son los siguientes:
M, nmero de neuronas en la capa de entrada F1.
N, nmero de neuronas en la capa competitiva F2.
A, respuesta inhibitoria debido a la normalizacin.
B, parmetro de inhibicin que se utiliza para realizar el mejoramiento por
contraste.
C, inhibicin causada por el resto de neuronas de la capa.
D, multiplicador del efecto de la seal de entrada neta procedente de F2 hacia cada
neurona en F1.
L, constante para el ajuste de pesos ascendentes.
, parmetro de vigilancia que determina la similitud entre el vector de entrada y el
patrn almacenado en memoria LTM.
Estos parmetros debern ser seleccionados bajo las condiciones establecidas por el
algoritmo:
59
1. A1 ^ C1 > 0,
2. mx{ D1 ,1} < B1 < D1 +1,
3. L > 1,
4. 0 < <1
En virtud de estas condiciones, los valores de los parmetros que hemos escogido
son los siguientes:
M = 15
N = 15
A1 = 1
B1 = 1.5
C1 = 5
D1 = 0.9
L=3
= 0.9
60
3.5 Resultados
3.5.1 Glyph correspondiente al nmero 1. 5
1. Definicin de Parmetros.
M = 15
N = 15
A1 = 1
B1 = 1.5
C1 = 5
61
D1 = 0.9
L=3
= 0.9
2. Inicializar Pesos.
Pesos Descendentes:
Las condiciones del algoritmo imponen que z ij (0) >
z ij (0) >
B1 1
, de donde:
D1
1.5 1
= 0.556
0.9
Para cumplir con esta condicin se aadi un pequeo valor positivo (0.3) a
B1 1
, porque representa una adicin significativa de alrededor del 50% de 0.556.
D1
Por ende:
z ij (0 ) =
1.5 1
+ 0.3 = 0.856 , entonces:
0.9
z ij = (0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856,
0.856, 0.856, 0.856, 0.856)T
Pesos Ascendentes:
Las condiciones del algoritmo indican que z ji (0 ) <
z ji (0 ) <
L
, de donde:
L 1+ M
3
= 0.176
3 1 + 15
62
L
por
L 1+ M
3
0.076 = 0.1 , entonces:
3 1 + 15
z ji = (0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1)
3. Inicializar Actividades.
B1
, as:
1 + C1
x1i (0 ) =
1.5
= 0.25
1+ 5
X 0 = (-0.25, -0.25, -0.25, -0.25, -0.25, -0.25, -0.25, -0.25, -0.25, -0.25, -0.25, -0.25,
-0.25, -0.25, -0.25)
En F2: x2 j (0) = 0
si I i = 0
x11 = 0
si I i = 1
x12 =
1
= 0.118
1 + 1(1 + 1.5) + 5
63
S = (0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1)
6. Propagar s a F2 y calcular la entrada neta: T j
T j = z ji S = 0.1 8 = 0.8
T = (0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8)
7. Calcular la salida de F2 (neurona ganadora vJ)
Dado que todas las neuronas tienen el mismo valor de entrada neta, se escoger a la
primera como ganadora, ya que es fcil hacer un seguimiento de las neuronas
ganadoras en un orden secuencial.
U = (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
8. Propagar la salida de F2 a F1 y calcular la entrada neta Vi
Vi = z ij U = 0.856
V = (0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856,
Si I i = 0
x11 =
Si I i = 1
64
x11 =
X 2 = (-0.108, 0.035, -0.108, 0.035, 0.035, -0.108, -0.108, 0.035, -0.108, -0.108,
S = (0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1)
S
I
S
I
8
8
S
I
=1
si vi est activa:
z Ji =
3
3 1+ 8
= 0.621
z iJ = (0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1) T
65
66
si I i = 0
x15 = 0
si I i = 1
x11 =
1
= 0.118
1 + 1(1 + 1.5) + 5
X 3 = (0.118, 0.118, 0.118, 0.118, 0, 0, 0.118, 0.118, 0.118, 0.118, 0, 0.118, 0.118,
0.118, 0.118)
67
5. S = (1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1)
6. T j = z ji S = 0.1 12 = 1.2
T = (3.726, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2)
7. U = (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
8. Vi = z ij U
V = (0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1)
9. Las nuevas actividades
ij
en F1:
si I i = 1 y Vi = 0
x11 =
1 + 0 .9 * 0 1 .5
= 7.14 10 2
1 + 1 * (1 + 0 ) + 5
si I i = 1 y Vi = 1
x12 =
1 + 0 .9 * 1 1 .5
= 5.063 10 2
1 + 1 * (1 + 0.9 * 1) + 5
si I i = 0 y Vi = 1
x15 =
0 + 0 .9 * 1 1 .5
= 8.695 10 2
1 + 1 * (0 + 0.9 * 1) + 5
si I i = 0 y Vi = 0
x16 =
0 + 0 .9 * 0 1 .5
= 0.25
1 + 1 * (0 + 0.9 * 0 ) + 5
10. S = (0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1)
11.
S
I
6
12
= 0.707
68
S
I
Se debe enviar una seal de restauracin para la neurona 1 de la capa F2, para evitar
que vuelva a ganar en la competencia, as T1 = 0, de donde:
T = (0, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2)
7. Tomando como ganadora esta vez a la segunda neurona de F2, se tiene:
U = (0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
8. Vi = z ij U
V = (0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856, 0.856,
x1i = -0.108
si I i =1
x1i = 0.035
10. S = (1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1)
11.
S
I
12
12
=1
69
S
I
3
3 1 + 12
= 0.549
70
71
CAPITULO IV
En la Figura 4.1 se aprecia que el ART1 Simulator posee una zona de mens que
contiene las opciones Archivo y Ayuda. La opcin Archivo permite realizar
funciones de crear (Nuevo), Abrir, Guardar como y Salir.
72
73
La interfase del Simulador contiene cuatro botones: Parmetros, Crear Red, Ejecutar
y Limpiar Glyph. El evento clic del botn Parmetros despliega una pantalla que
solicita el ingreso de los parmetros necesarios para construir la red (Figura 4.3). El
botn Crear Red permite inicializar los valores de los pesos de las capas F1 y F2,
despus de haber dibujado un glyph (patrn) de entrada con el puntero en la Grilla de
Ingreso de Glyph (Figura 4.1).
74
75
4.2 Resultados
76
ii). Determinaremos la dependencia entre el tamao del glyph de entrada, el valor del
aprendido.
v). Averiguaremos lo que sucede en el proceso de reconocimiento cuando se da el
78
4.2.1 Caso 1
1. Para este caso definiremos un rho = 0.8 con el fin de demostrar que la red
79
Vector de Entrada:
000100000110000001000000100000010000001000000100000010000001000
Salida F1:
000100000110000001000000100000010000001000000100000010000001000
2. A continuacin haremos que la red clasifique a un patrn del nmero uno (1) con
una barra inclinada izquierda mucho ms corta. Este patrn es clasificado como
miembro de la clase del primer patrn aprendido (patrn a de la Figura 4.4). Esto
se puede apreciar en la Zona de Procesamiento donde se ve que la neurona
ganadora en F2 es la misma que cuando se ingres el primer patrn. Sin embargo
la red almacena en su memoria LTM el segundo patrn ingresado (patrn b
Figura 4.4) ya que ste es subconjunto del primero.
80
Vector de Entrada:
000100000110000101000100100000010000001000000100000010000001000
Salida F1:
000100000110000101000100100000010000001000000100000010000001000
Neurona Ganadora F2: 1
Salida F2: 010000000000000
Nueva Salida F1:
000100000110000001000000100000010000001000000100000010000001000
81
3. Como tercer paso se vuelve a ingresar el nmero uno (1) con la barra ms larga.
En este punto la red lo clasificar como su subconjunto (el nmero uno con la
barra corta), dado que este subconjunto representa hasta este instante el patrn
ms simple (el de menor nmero de neuronas activas) del nmero uno.
Figura 4.8 Primer Caso Nueva Clasificacin del Patrn Aprendido Inicialmente.
82
Vector de Entrada:
000100000110000101000100100000010000001000000100000010000001000
Salida F1:
000100000110000101000100100000010000001000000100000010000001000
Neurona Ganadora F2: 1
Salida F2: 010000000000000
Nueva Salida F1:
000100000110000001000000100000010000001000000100000010000001000
Coincidencia entre trama de salida y trama de entrada: 0,833333333333333
4.2.2 Caso 2
1. Inicialmente ingresaremos un patrn correspondiente al nmero seis (6) de la
83
Rho = 0.95.
(Flix N. Diego, Ziga C. Wladimir)}
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 6
Salida F2: 000000100000000
Nueva Salida F1:
000111000000000000000100000011111101000001100000110000010111110
84
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 5
Salida F2: 000001000000000
Nueva Salida F1:
000111000000000000000100000011111100000001000000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,826086956521739
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 3
Salida F2: 000100000000000
Nueva Salida F1:
000111000000000000000000000000011100000001000000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,652173913043478
85
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 2
Salida F2: 001000000000000
Nueva Salida F1:
000111000000000000000000000001111101000000100000010000010111110
Coincidencia entre trama de salida y trama de entrada: 0,739130434782609
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 8
Salida F2: 000000001000000
Nueva Salida F1:
000111000000000000000100000001111101000001100000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,869565217391304
86
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 0
Salida F2: 100000000000000
Nueva Salida F1:
000111000000000000000100000010000001000001100000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,695652173913043
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 9
Salida F2: 000000000100000
Nueva Salida F1:
000111000000000000000100000001111100000001000000000000000111000
Coincidencia entre trama de salida y trama de entrada: 0,565217391304348
87
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 1
Salida F2: 010000000000000
Nueva Salida F1:
000100000100000100000100000000010000000000000000000000000001000
Coincidencia entre trama de salida y trama de entrada: 0,260869565217391
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 4
Salida F2: 000010000000000
Nueva Salida F1:
000000000000000000000100000011111100000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,347826086956522
88
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 7
Salida F2: 000000010000000
Nueva Salida F1:
000111000000000000000000000000010000000000000000000000000010000
Coincidencia entre trama de salida y trama de entrada: 0,217391304347826
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Neurona Ganadora F2: 10
Salida F2: 000000000010000
Nueva Salida F1:
000111000100000100000100000011111101000001100000110000010111110
Coincidencia entre trama de salida y trama de entrada: 1
89
2. En este punto se reingresar el patrn del paso 1, pero se cambiar el valor de rho
a 0.8 para verificar que la red clasifica al patrn de entrada como uno de los
patrones en memoria LTM.
Rho = 0.80.
(Flix N. Diego, Ziga C. Wladimir)
Vector de Entrada:
000111000100000100000100000011111101000001100000110000010111110
Salida F1:
000111000100000100000100000011111101000001100000110000010111110
90
4.2.3 Caso 3
1. Ingresaremos el patrn del nmero uno (1) con la barra de la izquierda corta
como en la Figura 4.4 b, pero desplazado dos pxeles hacia la derecha en la Grilla
de Glyph de Entrada (Figura 4.12).
hacia la Derecha.
(Flix N. Diego, Ziga C. Wladimir)
Vector de Entrada:
000001000001100000010000001000000100000010000001000000100000010
92
Salida F1:
000001000001100000010000001000000100000010000001000000100000010
Neurona Ganadora F2: 4
Salida F2: 000010000000000
Nueva Salida F1:
000000000000100000010000001000000100000010000001000000100000010
Coincidencia entre trama de salida y trama de entrada: 0,8
Vector de Entrada:
000001000001100000010000001000000100000010000001000000100000010
Salida F1:
000001000001100000010000001000000100000010000001000000100000010
Neurona Ganadora F2: 3
Salida F2: 000100000000000
Nueva Salida F1:
000001000000000000000000000000000100000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,3
Vector de Entrada:
000001000001100000010000001000000100000010000001000000100000010
93
Salida F1:
000001000001100000010000001000000100000010000001000000100000010
Neurona Ganadora F2: 11
Salida F2: 000000000001000
Nueva Salida F1:
000001000001100000010000001000000100000010000001000000100000010
Coincidencia entre trama de salida y trama de entrada: 1
Como se puede comprobar en estos resultados, el patrn desplazado no es
reconocido como el patrn ya existente en memoria LTM y es aprendido como
un patrn diferente, a pesar de son exactamente iguales en forma y tamao.,
como se muestra en la Figura 4.13.
4.2.4 Caso 4
1. Ingresamos un patrn que representa al nmero cuatro (4), pero de un tamao
ms pequeo que los patrones hasta ahora aprendidos por la red., como aparece
en la grilla de ingreso de Glyph de la Figura 4.14.
Tamao.
(Flix N. Diego, Ziga C. Wladimir)
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
95
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 4
Salida F2: 000010000000000
Nueva Salida F1:
000000000000000000000000000000111100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,444444444444444
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 9
Salida F2: 000000000100000
Nueva Salida F1:
000000000000000000000000000000111100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,444444444444444
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
96
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 10
Salida F2: 000000000010000
Nueva Salida F1:
000000000000000000000000000000111100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,444444444444444
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 2
Salida F2: 001000000000000
Nueva Salida F1:
000000000000000000000000000000111100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,444444444444444
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
97
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 5
Salida F2: 000001000000000
Nueva Salida F1:
000000000000000000000000000000111100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,444444444444444
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 6
Salida F2: 000000100000000
Nueva Salida F1:
000000000000000000000000000000111100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,444444444444444
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
98
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 3
Salida F2: 000100000000000
Nueva Salida F1:
000000000000000000000000000000011100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,333333333333333
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 8
Salida F2: 000000001000000
Nueva Salida F1:
000000000000000000000000000000111100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,444444444444444
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
99
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 7
Salida F2: 000000010000000
Nueva Salida F1:
000000000000000000000000010000010000000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,222222222222222
Vector de Entrada:
000000000000000010000001010000111100000100000010000000000000000
Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Neurona Ganadora F2: 12
Salida F2: 000000000000100
Nueva Salida F1:
000000000000000010000001010000111100000100000010000000000000000
Coincidencia entre trama de salida y trama de entrada: 1
Se puede observar con claridad que el patrn del nmero cuatro de menor tamao
no es clasificado como le cuatro aprendido en le entrenamiento, sino ms bien es
aprendido por la red, a pesar de que en forma estos dos patrones son similares y
ambos representan al nmero cuatro (Figura 4.15)
100
4.2.5 Caso 5
1. Alimentamos la red con un patrn que representa al nmero dos (2), dibujado de
la forma como aparece en la Figura 4.16. Como el valor de rho es alto (0.95) la
red intentar aprender el patrn; sin embargo, como la memoria LTM est llena
(15 neuronas en la capa F2 almacenan 15 patrones) el patrn no ser aprendido.
Como resultado se despliegan el o los patrones que arrojan un valor de rho ms
cercano al valor de rho establecido (0.95).
101
Figura 4.16 Quinto Caso Memoria Llena Coincidencia con el Patrn ms Parecido
(Nmero 2)
(Flix N. Diego, Ziga C. Wladimir)
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 2
Salida F2: 001000000000000
Nueva Salida F1:
011111010000010000001000000000111000000000100000010000001111111
102
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 3
Salida F2: 000100000000000
Nueva Salida F1:
011111010000010000001000000000011000000000000000010000000111110
Coincidencia entre trama de salida y trama de entrada: 0,695652173913043
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 6
Salida F2: 000000100000000
Nueva Salida F1:
011111010000011000000000000000111000000000100000010000000111110
Coincidencia entre trama de salida y trama de entrada: 0,782608695652174
103
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 8
Salida F2: 000000001000000
Nueva Salida F1:
011111010000011000001000000000111000000000100000010000001111111
Coincidencia entre trama de salida y trama de entrada: 0,91304347826087
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 5
Salida F2: 000001000000000
Nueva Salida F1:
011111010000001000000000000000111000000000000000010000001111110
Coincidencia entre trama de salida y trama de entrada: 0,739130434782609
104
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 9
Salida F2: 000000000100000
Nueva Salida F1:
011111010000011000001000000000111000000000000000000000000111000
Coincidencia entre trama de salida y trama de entrada: 0,652173913043478
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 0
Salida F2: 100000000000000
Nueva Salida F1:
011111010000011000001000000000000000000000100000010000001111111
Coincidencia entre trama de salida y trama de entrada: 0,782608695652174
105
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 10
Salida F2: 000000000010000
Nueva Salida F1:
000111000000000000000000000000111000000000100000010000000111110
Coincidencia entre trama de salida y trama de entrada: 0,565217391304348
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 14
Salida F2: 000000000000001
Nueva Salida F1:
011111000000000000000000001000011000000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,391304347826087
106
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 7
Salida F2: 000000010000000
Nueva Salida F1:
011111000000010000000000000000010000000000000000000000000010000
Coincidencia entre trama de salida y trama de entrada: 0,347826086956522
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 4
Salida F2: 000010000000000
Nueva Salida F1:
000000010000001000000000001000111000000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,304347826086957
107
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 13
Salida F2: 000000000000010
Nueva Salida F1:
000011000000000000000000001000111000000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,304347826086957
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 12
Salida F2: 000000000000100
Nueva Salida F1:
000000000000000000000000000000111000000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,130434782608696
108
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 11
Salida F2: 000000000001000
Nueva Salida F1:
000001000000000000000000001000000000000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,130434782608696
Vector de Entrada:
011111010000011000001000001000111000100000100000010000001111111
Salida F1:
011111010000011000001000001000111000100000100000010000001111111
Neurona Ganadora F2: 1
Salida F2: 010000000000000
Nueva Salida F1:
000100000000000000000000000000010000000000000000000000000001000
Coincidencia entre trama de salida y trama de entrada: 0,130434782608696
109
110
111
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 5
Salida F2: 000001000000000
Nueva Salida F1:
011111110000001000000100000001111100000001000000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,958333333333333
112
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 6
Salida F2: 000000100000000
Nueva Salida F1:
011111010000001000000100000001111100000001100000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,958333333333333
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 3
Salida F2: 000100000000000
Nueva Salida F1:
011111010000000000000000000000011100000001000000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,75
113
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 10
Salida F2: 000000000010000
Nueva Salida F1:
000111000000000000000100000001111100000001100000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,791666666666667
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 8
Salida F2: 000000001000000
Nueva Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Coincidencia entre trama de salida y trama de entrada: 1
114
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 9
Salida F2: 000000000100000
Nueva Salida F1:
011111010000001000000100000001111100000001000000000000000111000
Coincidencia entre trama de salida y trama de entrada: 0,708333333333333
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 2
Salida F2: 001000000000000
Nueva Salida F1:
011111010000000000000000000001111100000000100000010000010111110
Coincidencia entre trama de salida y trama de entrada: 0,791666666666667
115
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 0
Salida F2: 100000000000000
Nueva Salida F1:
011111110000001000000100000000000000000001100000110000010111110
Coincidencia entre trama de salida y trama de entrada: 0,791666666666667
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 14
Salida F2: 000000000000001
Nueva Salida F1:
011111000000000000000000000000011100000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,375
116
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 7
Salida F2: 000000010000000
Nueva Salida F1:
011111100000000000000000000000010000000000000000000000000010000
Coincidencia entre trama de salida y trama de entrada: 0,333333333333333
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 4
Salida F2: 000010000000000
Nueva Salida F1:
000000010000001000000100000001111100000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,375
117
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 13
Salida F2: 000000000000010
Nueva Salida F1:
000011000000000000000000000001111100000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,333333333333333
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 12
Salida F2: 000000000000100
Nueva Salida F1:
000000000000000000000000000000111100000000000000000000000000000
Coincidencia entre trama de salida y trama de entrada: 0,166666666666667
118
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 1
Salida F2: 010000000000000
Nueva Salida F1:
000100000000000000000100000000010000000000000000000000000001000
Coincidencia entre trama de salida y trama de entrada: 0,166666666666667
Vector de Entrada:
011111110000001000000100000001111100000001100000110000010111110
Salida F1:
011111110000001000000100000001111100000001100000110000010111110
Neurona Ganadora F2: 11
Salida F2: 000000000001000
Nueva Salida F1:
000001000000000000000000000000000100000000000000000000000000010
Coincidencia entre trama de salida y trama de entrada: 0,125
119
CAPITULO V
CONCLUSIONES Y RECOMENDACIONES
5.1 Conclusiones
120
5.2 Recomendaciones
reconocimiento, tal que, permita una clasificacin correcta de todos los patrones
a reconocer con su correspondiente asociado en forma y valor.
121
FUENTES
LIBROS
122
PAPERS
CARPENTER G.A., GROSSBERG S., A Massively Parallel Architecture for a SelfOrganizing Neural Pattern Recognition Machine, Computer Vision, Graphics,
and Image Processing, 1987.
CARPENTER G.A., GROSSBERG S., ART2: Stable Self-Organization of Pattern
Recognition Codes for Analog Input Patterns, Applied Optics, 1987.
CARPENTER G.A., Distributed Learning, Recognition, and Prediction by ART and
ARTMAP Neural Networks, Neural Networks, 1997.
LIPPMANN r.p., An Introduction to Computing with Neural Nets, IEEE
Transactions on Acoustics, Speech, and Signal Processing, 1987.
INTERNET
http://ailab.ch/teaching/classes/2004ss/nn/Lecture_on_ART.pdf
http://www.cs.brandeis.edu/~cs113/docs/other/heins_tauritz.pdf
http://profusion.bu.edu/techlab/modules/xoopsfaq/index.php?cat_id=1
http://www.gui.uva.es/login/13/redesn.html
http://www.gui.uva.es/login/13/redesn.html
http://www.sav.us.es/formaciononline/asignaturas/asigpid/apartados/textos/recursos/r
edesneuronales/PIRN.htm
http://www.uta.edu/psychology/faculty/levine/EBOOK/ART_networks.pdf
http://cns.bu.edu/Profiles/Grossberg/CarGro2003HBTNN2.pdf
123
http://www.cs.brandeis.edu/~cs113/docs/other/heins_tauritz.pdf
http://ailab.ch/teaching/classes/2004ss/nn/Lecture_on_ART.pdf
http://www.it.uom.gr/pdp/DigitalLib/Neural/Neu_soft.htm
http://www-ra.informatik.uni-tuebingen.de/SNNS/
124
ANEXOS
125
ANEXO 1
Cdigo Fuente de la Implementacin del Algoritmo ART1 en C++.
# include <conio.h>
# include <iostream.h>
# include <math.h>
struct capaF1{
float *salida;
float *peso;
};
struct capaF2{
float *salida;
float *peso;
};
struct ART1{
capaF1 *F1;
capaF2 *F2;
float A1;
float B1;
float C1;
float D1;
float L;
float ro;
int GF2;
float INH[];
float modX;
};
//-------------------------FUNCIONES--------------capaF1* crearF1 ( int cM, int cN){
capaF1 *crea;
crea = new capaF1;
crea->salida=new float[cM];
crea->peso=new float[cM*cN];
MxN
return(crea);
}
//matriz
126
NxM
}
crea->salida=new float[cN];
crea->peso=new float[cN*cM];
//matriz
return(crea);
127
}
while (nodoF1<iM);
//----Inicializar pesos F2
do{
for (int j=0; j<iM; j++){
iART1->F2->peso[indiceF2]=(iL/(iL1+iM))-0.1;
indiceF2++;
}
nodoF2++;
}
while (nodoF2<iN);
}
void propagarF1 (ART1 *pART1, float *pvectorEntrada, int
iM){
float *unidadSalida;
unidadSalida=pART1->F1->salida;
for (int i =0; i<iM; i++){
unidadSalida[i]=pvectorEntrada[i]/(1 +
pART1->A1 * (pvectorEntrada[i] + pART1->B1) + pART1->C1);
if (unidadSalida[i] > 0)
unidadSalida[i]=1;
else
unidadSalida[i]=0;
}
}
void propagarF2 (ART1 *pART1, int pN, int pM){
float *unidadSalida;
//salida F2
float *unidadEntrada;
//salida F1
float conexionesaF2;
float mayor;
int ganadora;
float suma;
int indiceF2;
int nodoF2;
unidadSalida=pART1->F2->salida;
unidadEntrada=pART1->F1->salida;
mayor=-100;
indiceF2=0;
nodoF2=0;
for (int i=0; i<pN; i++)
unidadSalida[i]=0;
cout<<"\nEntradas netas a unidades F2\n";
do{
128
suma=0;
for (int j=0; j<pM; j++){
conexionesaF2=pART1->F2->peso[indiceF2];
suma= suma + (unidadEntrada[j] *
conexionesaF2);
indiceF2++;
}
suma=suma*pART1->INH[nodoF2];
if(suma > mayor && pART1->INH[nodoF2]==1){
ganadora=nodoF2;
mayor=suma;
};
cout<<" "<<suma;
nodoF2++;
}
while (nodoF2<pN);
cout<<"\nGANADORA F2:"<<ganadora<<"\n";
unidadSalida[ganadora]=1;
pART1->GF2 = ganadora;
getch();
129
indiceGanadora=indiceGanadora+pN;
}
cART1->modX=modPlantilla;
return(modPlantilla/modEntrada);
130
131
}
vectorF2[nodoF2]=suma;
cout<<" "<<suma;
nodoF2++;
}while (nodoF2<pN);
return(vectorF2);
132
indiceF1++;
}
cout<<"\n";
nodoF1++;
}
while (nodoF1<M);
//------- PESOS F2------int indiceF2=0;
int nodoF2=0;
cout<<"\nPESOS F2";
cout<<"\n---------\n";
do{
for (int K=0; K<M; K++){
cout<<rART1->F2->peso[indiceF2]<<"
";
indiceF2++;
}
cout<<"\n";
nodoF2++;
}
while (nodoF2<N);
}
void informacion (ART1 *rART1, int M, int N, int
coincide){
cout<<"\n";
cout<<"\nPropaga F1: salida= ";
for (int k=0; k<M; k++)
cout<<rART1->F1->salida[k]<<"
";
cout<<"\nPropaga F2: salida= ";
for (k=0; k<N; k++)
cout<<rART1->F2->salida[k]<<"
";
F2
int M;
int N;
// #neuronas F1
// # neuronas
133
float A1;
float B1;
float C1;
float D1;
float L;
float ro;
float
*INH;
float *vectorEntrada;
// definir vector de entrada solo para admitir M
float coincide;
int opcion;
capaF1 *F1;
capaF2 *F2;
ART1 *rART1;
do{
clrscr();
cout<<"\n
---MENU---";
cout<<"\n\n 1.Ingreso Par metros";
cout<<"\n 2.Inicializar";
cout<<"\n 3.Ingresar Entrada";
cout<<"\n 4.Procesar";
cout<<"\n 5.Salir";
cout<<"\n\n
Opcin:";
cin>>opcion;
switch (opcion) {
case 1:
clrscr();
cout<<"M="; cin>>M;
// #
neuronas F1
cout<<"N="; cin>>N;
// #
neuronas F2
cout<<"A1="; cin>>A1;
cout<<"B1="; cin>>B1;
cout<<"C1="; cin>>C1;
cout<<"D1="; cin>>D1;
cout<<"L="; cin>>L;
cout<<"ro="; cin>>ro;
INH=new float [N];
eliminarInhibicion(rART1, N);
break;
case 2:
clrscr();
F1= crearF1 (M, N);
F2= crearF2 (N, M);
134
C1, D1,
L, ro, INH);
inicPesos(rART1, N, M, B1, D1, L);
cout<<"PESOS INICIALES:\n";
verPesos(rART1, M, N);
getch();
break;
case 3:
clrscr();
vectorEntrada=new float[M];
for (int i=0; i<M; i++){
cout<<"\nElemento ["<<i<<"]:";
cin>>vectorEntrada[i];
}
break;
case 4:
clrscr();
cout<<"\n PESOS INICIALES:\n";
verPesos(rART1, M, N);
getch();
int finalizado;
int intentos;
finalizado=0;
intentos=0;
//-- utilizo el auxVectorEntrada porque da problemas con
memoria
//-- si no se usa este vector, el vectorEntrada original
sale alterado
//-- slo para la 1era iteracin
float *auxVectorEntrada;
auxVectorEntrada=new float[N];
for (i=0; i<M; i++)
auxVectorEntrada[i]=vectorEntrada[i];
eliminarInhibicion(rART1, N);
for (i=0; i<M; i++)
vectorEntrada[i]=auxVectorEntrada[i];
135
coincide=procesar(rART1,vectorEntrada,M,N)
136
break;
case 5:
clrscr();
break;
default:
clrscr();
cout<<"\n No Valido!\n";
}
}while (opcion != 5);
}
137
ANEXO 2
Cdigo Fuente de la Implementacin del Algoritmo ART1 en Delphi.
Unidad Principal
unit undPrincipal;
interface
uses
Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms,
Dialogs, Menus, CustomizeDlg, StdCtrls, ToolWin,
ActnMan, ActnCtrls,
Buttons, ComCtrls, ExtCtrls, ActnList, StdActns,
ActnColorMaps, jpeg;
type capaF1 = record
salida: array of Real;
peso: array of array of Real;
end;
type capaF2 = record
salida: array of Real;
peso: array of array of Real;
end;
type ART1 = record
F1 :capaF1;
F2 :capaF2;
A1 :Real;
B1 :Real;
C1 :Real;
D1 :Real;
L :Real;
rho :Real;
GF2: Integer;
INH :array of Real;
modX :Real;
end;
type entrada = record
neurona: array of Real;
end;
type
138
TART1Lab = class(TForm)
MainMenu1: TMainMenu;
MAyuda: TMenuItem;
MArchivo: TMenuItem;
MASalir: TMenuItem;
N2: TMenuItem;
MAGuardar: TMenuItem;
MAAbrir: TMenuItem;
MANuevo: TMenuItem;
PCInterfaz: TPageControl;
TabSimulador: TTabSheet;
LGlyphCodificado: TLabel;
LProcesamiento: TLabel;
PnGlyph: TPanel;
LbM: TLabel;
LbA1: TLabel;
LbB1: TLabel;
LbC1: TLabel;
LbD1: TLabel;
LbL: TLabel;
Lbrho: TLabel;
LbN: TLabel;
LTextA1: TLabel;
LTextB1: TLabel;
LTextC1: TLabel;
LTextD1: TLabel;
LTextL: TLabel;
LTextrho: TLabel;
LTextN: TLabel;
LTextM: TLabel;
PBGlyph: TPaintBox;
TBSimulador: TToolBar;
BtnParametros: TBitBtn;
BtnCrearRed: TBitBtn;
BtnEjecutar: TBitBtn;
MGlyphCodificado: TMemo;
MProcesamiento: TMemo;
LResultados: TLabel;
CuadroSaveDialog: TSaveDialog;
CuadroOpenDialog: TOpenDialog;
ActionList1: TActionList;
FileExit1: TFileExit;
IGlyph: TImage;
TabArquitectura: TTabSheet;
IArquitectura: TImage;
CBResultados: TComboBox;
PMostrarGlyph: TPanel;
PBResultado: TPaintBox;
139
BMostrarResulado: TButton;
LInfResultado: TLabel;
BLimpiarGlyph: TButton;
procedure ActionToolBar1Click(Sender: TObject);
procedure BtnParametrosClick(Sender: TObject);
procedure BtnCrearRedClick(Sender: TObject);
procedure BtnEjecutarClick(Sender: TObject);
procedure PBGlyphMouseDown(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure MAGuardarClick(Sender: TObject);
procedure MAAbrirClick(Sender: TObject);
procedure MANuevoClick(Sender: TObject);
procedure BMostrarResuladoClick(Sender: TObject);
procedure BLimpiarGlyphClick(Sender: TObject);
procedure FormPaint(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
M:Integer;
N:Integer;
A1:Real;
B1:Real;
C1:Real;
D1:Real;
L:Real;
rho:Real;
INH: array of Real;
coincide: Real;
F1: capaF1;
F2: capaF2;
rART1: ART1;
vectorEntrada : entrada;
glyphCodificado:String;
end;
var
ART1Lab: TART1Lab;
implementation
uses undParametros;
{$R *.dfm}
procedure TART1Lab.ActionToolBar1Click(Sender: TObject);
type
140
Button1= TButton;
begin
Button1.Create(Application);
end;
//------------------------------------------------------------------------------// Funcin para el glyph
function pintarglyph35(PBGlyph: TPaintBox; PX,PY:
Integer; Inicial: Boolean):TPaintBox;
begin
if (PBGlyph.Canvas.Pixels[PX,PY] = clWhite)then
PBGlyph.Canvas.Brush.Color := clFuchsia
else
PBGlyph.Canvas.Brush.Color := clWhite;
if (Inicial = true) then
PBGlyph.Canvas.Brush.Color := clWhite;
//primera fila
if((PX>0) and (PX<32) and (PY>0) and (PY<34))then
PBGlyph.Canvas.Rectangle(0,0,33,35);
if((PX>32) and (PX<64) and (PY>0) and (PY<34))then
PBGlyph.Canvas.Rectangle(32,0,65,35);
if((PX>64) and (PX<96) and (PY>0) and (PY<34))then
PBGlyph.Canvas.Rectangle(64,0,97,35);
if((PX>96) and (PX<128) and (PY>0) and (PY<34))then
PBGlyph.Canvas.Rectangle(96,0,129,35);
if((PX>128) and (PX<159) and (PY>0) and (PY<34))then
PBGlyph.Canvas.Rectangle(128,0,160,35);
//segunda fila
if((PX>0) and (PX<32) and (PY>34) and (PY<68))then
PBGlyph.Canvas.Rectangle(0,34,33,69);
if((PX>32) and (PX<64) and (PY>34) and (PY<68))then
PBGlyph.Canvas.Rectangle(32,34,65,69);
if((PX>64) and (PX<96) and (PY>34) and (PY<68))then
PBGlyph.Canvas.Rectangle(64,34,97,69);
if((PX>96) and (PX<128) and (PY>34) and (PY<68))then
PBGlyph.Canvas.Rectangle(96,34,129,69);
if((PX>128) and (PX<159) and (PY>34) and (PY<68))then
PBGlyph.Canvas.Rectangle(128,34,160,69);
//tercera fila
if((PX>0) and (PX<32) and (PY>68) and (PY<102))then
PBGlyph.Canvas.Rectangle(0,68,33,103);
if((PX>32) and (PX<64) and (PY>68) and (PY<102))then
PBGlyph.Canvas.Rectangle(32,68,65,103);
141
142
143
PBGlyph.Canvas.Rectangle(0,54,24,82);
if((PX>23) and (PX<46) and (PY>55) and (PY<82))then
PBGlyph.Canvas.Rectangle(23,54,47,82);
if((PX>46) and (PX<69) and (PY>55) and (PY<82))then
PBGlyph.Canvas.Rectangle(46,54,70,82);
if((PX>69) and (PX<92) and (PY>55) and (PY<82))then
PBGlyph.Canvas.Rectangle(69,54,93,82);
if((PX>92) and (PX<115) and (PY>55) and (PY<82))then
PBGlyph.Canvas.Rectangle(92,54,116,82);
if((PX>115) and (PX<138) and (PY>55) and (PY<82))then
PBGlyph.Canvas.Rectangle(115,54,139,82);
if((PX>138) and (PX<159) and (PY>55) and (PY<82))then
PBGlyph.Canvas.Rectangle(138,54,160,82);
//cuarta fila
if((PX>0) and (PX<23) and (PY>81) and (PY<109))then
PBGlyph.Canvas.Rectangle(0,81,24,109);
if((PX>23) and (PX<46) and (PY>81) and (PY<109))then
PBGlyph.Canvas.Rectangle(23,81,47,109);
if((PX>46) and (PX<69) and (PY>81) and (PY<109))then
PBGlyph.Canvas.Rectangle(46,81,70,109);
if((PX>69) and (PX<92) and (PY>81) and (PY<109))then
PBGlyph.Canvas.Rectangle(69,81,93,109);
if((PX>92) and (PX<115) and (PY>81) and (PY<109))then
PBGlyph.Canvas.Rectangle(92,81,116,109);
if((PX>115) and (PX<138) and (PY>81) and (PY<109))then
PBGlyph.Canvas.Rectangle(115,81,139,109);
if((PX>138) and (PX<159) and (PY>81) and (PY<109))then
PBGlyph.Canvas.Rectangle(138,81,160,109);
//quinta fila
if((PX>0) and (PX<23) and (PY>108) and (PY<135))then
PBGlyph.Canvas.Rectangle(0,108,24,136);
if((PX>23) and (PX<46) and (PY>108) and (PY<135))then
PBGlyph.Canvas.Rectangle(23,108,47,136);
if((PX>46) and (PX<69) and (PY>108) and (PY<135))then
PBGlyph.Canvas.Rectangle(46,108,70,136);
if((PX>69) and (PX<92) and (PY>108) and (PY<135))then
PBGlyph.Canvas.Rectangle(69,108,93,136);
if((PX>92) and (PX<115) and (PY>108) and (PY<135))then
PBGlyph.Canvas.Rectangle(92,108,116,136);
if((PX>115) and (PX<138) and (PY>108) and (PY<135))then
PBGlyph.Canvas.Rectangle(115,108,139,136);
if((PX>138) and (PX<159) and (PY>108) and (PY<135))then
PBGlyph.Canvas.Rectangle(138,108,160,136);
//sexta fila
if((PX>0) and (PX<23) and (PY>135) and (PY<162))then
PBGlyph.Canvas.Rectangle(0,135,24,163);
if((PX>23) and (PX<46) and (PY>135) and (PY<162))then
PBGlyph.Canvas.Rectangle(23,135,47,163);
144
145
PBGlyph.Canvas.Rectangle(69,216,93,238);
if((PX>92) and (PX<115) and (PY>216) and (PY<238))then
PBGlyph.Canvas.Rectangle(92,216,116,238);
if((PX>115) and (PX<138) and (PY>216) and (PY<238))then
PBGlyph.Canvas.Rectangle(115,216,139,238);
if((PX>138) and (PX<159) and (PY>216) and (PY<238))then
PBGlyph.Canvas.Rectangle(138,216,160,238);
Result:=PBGlyph;
end;
function codificarGlyph35(PBGlyph: TPaintBox):String;
var codificacion:String;
PX:Integer;
PY:Integer;
begin
codificacion:='';
PY:=20;
repeat
PX:=20;
repeat
if (PBGlyph.Canvas.Pixels[PX,PY] = clWhite)then
codificacion:=codificacion+'0'
else
codificacion:=codificacion+'1';
PX:=PX+30;
until PX>140;
PY:=PY+35;
until PY>230;
Result:=codificacion;
end;
function codificarGlyph63(PBGlyph: TPaintBox):String;
var codificacion:String;
PX:Integer;
PY:Integer;
begin
codificacion:='';
PY:=20;
repeat
PX:=20;
repeat
if (PBGlyph.Canvas.Pixels[PX,PY] = clWhite)then
codificacion:=codificacion+'0'
else
codificacion:=codificacion+'1';
PX:=PX+20;
until PX>140;
PY:=PY+25;
146
until PY>220;
Result:=codificacion;
end;
function construirGlyph35(PBGlyph: TPaintBox): TPaintBox;
var PX:Integer;
PY:Integer;
begin
PY:=20;
repeat
PX:=20;
repeat
pintarglyph35(PBGlyph, PX, PY, true);
PX:=PX+30;
until PX>140;
PY:=PY+35;
until PY>230;
Result:=PBGlyph;
end;
function construirGlyph63(PBGlyph: TPaintBox): TPaintBox;
var PX:Integer;
PY:Integer;
begin
PY:=20;
repeat
PX:=20;
repeat
pintarglyph63(PBGlyph, PX, PY, true);
PX:=PX+20;
until PX>140;
PY:=PY+25;
until PY>236;
Result:=PBGlyph;
end;
function decodificarGlyph (PBGlyph: TPaintBox; m:
Integer; textoCodificado:String) :TPaintBox;
var x:Integer;
y:Integer;
sumax:Integer;
sumay:Integer;
cuadro:Integer;
filas:Integer;
i:Integer;
caracter:String[63];
147
begin
caracter:=textoCodificado;
if m=35 then
begin
sumax:=32;
sumay:=34;
filas:=7;
end
else
begin
sumax:=23;
sumay:=27;
filas:=9;
end;
cuadro:=2;
y:=0;
i:=1;
repeat
begin
x:=0;
cuadro:=cuadro-1;
repeat
begin
if caracter[cuadro]= '1' then
PBGlyph.Canvas.Brush.Color := clFuchsia
else
PBGlyph.Canvas.Brush.Color := clWhite;
PBGlyph.Canvas.Rectangle(x,y,x+sumax+1,y+sumay+1);
x:=x+sumax;
cuadro:=cuadro+1;
end
until x>162;
y:=y+sumay;
i:=i+1
end
until i>filas;
PBGlyph.Canvas.Pen.Color:= clBlack;
PBGlyph.Canvas.Rectangle(159,0,165,238);
PBGlyph.Canvas.Rectangle(0,237,165,240);
Result:= PBGlyph;
end;
function decodificarResultado (PBResultado: TPaintBox; m:
Integer; textoCBResultados:String) :TPaintBox;
var x:Integer;
148
y:Integer;
sumax:Integer;
sumay:Integer;
cuadro:Integer;
filas:Integer;
i:Integer;
caracter:String[63];
begin
caracter:=textoCBResultados;
if m=35 then
begin
sumax:=14;
sumay:=13;
filas:=7;
end
else
begin
sumax:=10;
sumay:=10;
filas:=9;
end;
cuadro:=2;
y:=0;
i:=1;
repeat
begin
x:=0;
cuadro:=cuadro-1;
repeat
begin
if caracter[cuadro]= '1' then
PBResultado.Canvas.Brush.Color := clFuchsia
else
PBResultado.Canvas.Brush.Color := clWhite;
PBResultado.Canvas.Rectangle(x,y,x+sumax+1,y+sumay+1);
x:=x+sumax;
cuadro:=cuadro+1;
end
until x>71;
y:=y+sumay;
i:=i+1
end
until i>filas;
149
Result:=PBResultado;
end;
//Fin de Funcin de Glyph
//------------------------------------------------------------------------------procedure TART1Lab.BtnParametrosClick(Sender: TObject);
var frmp: TFrmParametros;
begin
frmp := TFrmParametros.Create(Application);
if((self.LTextM.Caption='') or
(self.LTextM.Caption='35'))then
frmp.CBM.ItemIndex:=0
else
frmp.CBM.ItemIndex:=1;
frmp.EN.Text:=self.LTextN.Caption;
frmp.EA1.Text:=self.LTextA1.Caption;
frmp.EB1.Text:=self.LTextB1.Caption;
frmp.EC1.Text:=self.LTextC1.Caption;
frmp.ED1.Text:=self.LTextD1.Caption;
frmp.EL.Text:=self.LTextL.Caption;
frmp.Erho.Text:=self.LTextrho.Caption;
if (frmp.ShowModal=mrOK) and(frmp.correcto = 1) then
begin
ShowMessage('Los parmetros han sido ingresados
de forma satisfactoria');
if(frmp.CBM.ItemIndex=0)then
self.LTextM.Caption:='35'
else
self.LTextM.Caption:='63';
self.LTextN.Caption:=frmp.EN.Text;
self.LTextA1.Caption:=frmp.EA1.Text;
self.LTextB1.Caption:=frmp.EB1.Text;
self.LTextC1.Caption:=frmp.EC1.Text;
self.LTextD1.Caption:=frmp.ED1.Text;
self.LTextL.Caption:=frmp.EL.Text;
self.LTextrho.Caption:=frmp.Erho.Text;
self.M :=StrToInt(self.LTextM.Caption);
self.N :=StrToInt(self.LTextN.Caption);
self.A1 :=StrToFloat(self.LTextA1.Caption);
self.B1 :=StrToFloat(self.LTextB1.Caption);
self.C1 :=StrToFloat(self.LTextC1.Caption);
self.D1 :=StrToFloat(self.LTextD1.Caption);
150
self.L :=StrToFloat(self.LTextL.Caption);
self.rho :=StrToFloat(self.LTextrho.Caption);
if self.M=35 then
self.PBGlyph:=construirGlyph35(PBGlyph)
else
self.PBGlyph:=construirGlyph63(PBGlyph);
self.BtnCrearRed.Enabled:=true;
self.BtnParametros.Enabled:=false;
end;
frmp.free;
end;
function crearF1(M,N : Integer): capaF1;
var crea : capaF1;
i,j : Integer;
begin
SetLength(crea.salida, M);
SetLength(crea.peso, M);
for i:= Low(crea.peso) to High(crea.peso) do
begin
SetLength(crea.peso[i],N);
for j:= Low(crea.peso[i])to High(crea.peso[i])do
crea.peso[i,j]:=0;
end;
Result:=crea;
end;
function crearF2(N,M : Integer): capaF2;
var crea : capaF2;
i,j : Integer;
begin
SetLength(crea.salida, N);
SetLength(crea.peso, N);
for i:= Low(crea.peso) to High(crea.peso) do
begin
SetLength(crea.peso[i],M);
for j:= Low(crea.peso[i])to High(crea.peso[i])do
crea.peso[i,j]:=0;
end;
Result:=crea;
end;
function crearRed(F1: capaF1; F2: capaF2;
A1,B1,C1,D1,L,rho: Real; N: Integer): ART1;
var crea : ART1;
i:Integer;
begin
crea.F1:=F1;
151
crea.F2:=F2;
crea.A1:=A1;
crea.B1:=B1;
crea.C1:=C1;
crea.D1:=D1;
crea.L:=L;
crea.rho:=rho;
crea.GF2:=-100;
SetLength(crea.INH, N);
for i:= Low(crea.INH)to High(crea.INH)do
crea.INH[i]:=1;
crea.modX:=-100;
Result:=crea;
end;
function inicializarPesos(rART1: ART1; B1,D1,L: Real;
M:Integer):ART1;
var i,j:Integer;
lalto,lbajo:Real;
begin
repeat
lalto:=Random ;
until (lalto<((B1-1)/D1)*0.6) AND (lalto>((B11)/D1)*0.1);
repeat
lbajo:=Random;
until (lbajo<(L/(L-1+M))*0.3) AND (lbajo>(L/(L1+M))*0.1);
for i:= Low(rART1.F1.peso)to High(rART1.F1.peso)do
for j:= Low(rART1.F2.peso)to High(rART1.F2.peso) do
rART1.F1.peso[i,j]:=((B1-1)/D1)+lalto;
for i:= Low(rART1.F2.peso)to High(rART1.F2.peso) do
for j:= Low(rART1.F1.peso)to High(rART1.F1.peso)do
rART1.F2.peso[i,j]:=(L/(L-1+M))-lbajo;
Result:=rART1;
end;
{imprimir pesos}
function mostrarPesos(rART1: ART1; MProcesamiento :
TMemo):TMemo;
var i,j:Integer;
begin
MProcesamiento.Lines.Add('');
MProcesamiento.Lines.Add('Pesos F1:');
MProcesamiento.Lines.Add('-----------------');
152
153
rART1.F1.salida[i]:=0;
end;
Result:=rART1;
end;
function propagarF2 (rART1:ART1; M:Integer) :ART1;
var i,j: Integer;
ganadora: Integer;
mayor: Real;
suma:Real;
begin
ganadora:=0;
mayor:=-100;
for i:= Low(rART1.F2.salida)to High(rART1.F2.salida) do
rART1.F2.salida[i]:=0;
for i:= Low(rART1.F2.salida)to High(rART1.F2.salida) do
begin
suma:=0;
for j:=0 to M-1 do
suma:=suma+(rART1.F1.salida[j]*rART1.F2.peso[i,j]);
suma:=suma*rART1.INH[i];
if(suma>mayor) and (rART1.INH[i]=1) then
begin
ganadora:=i;
mayor:=suma;
end;
end;
rART1.F2.salida[ganadora]:=1;
rART1.GF2:=ganadora;
result:=rART1;
end;
function propagacionVuelta (rART1:ART1; vectorEntrada:
Entrada) :ART1;
var i:Integer;
nuevaEntrada: Real; //X
begin
for i:=Low(rART1.F1.salida)to High(rART1.F1.salida)do
begin
nuevaEntrada:=(vectorEntrada.neurona[i]+(rART1.D1*rART1.F
1.peso[i,rART1.GF2])rART1.B1)/(1+(rART1.A1*(vectorEntrada.neurona[i]+(rART1.D
1*rART1.F1.peso[i,rART1.GF2])))+rART1.C1);
if (nuevaEntrada >0) then
rART1.F1.salida[i]:=1
else
154
rART1.F1.salida[i]:=0;
end;
Result:=rART1;
end;
function moduloDeX (rART1:ART1; vectorEntrada:Entrada)
:ART1;
var i: Integer;
moduloX: Real;
begin
moduloX:=0;
for i:= Low(rART1.F1.salida)to High(rART1.F1.salida)do
begin
moduloX:=moduloX+rART1.F1.salida[i];
end;
rART1.modX:=moduloX;
Result:=rART1;
end;
function coincidencia (rART1: ART1; moduloX:Real;
vectorEntrada:Entrada) :Real;
var i: Integer;
moduloEntrada: Real;
begin
moduloEntrada:=0;
for i:= Low(rART1.F1.salida)to High(rART1.F1.salida)do
begin
moduloEntrada:=moduloEntrada+vectorEntrada.neurona[i];
end;
Result:=(moduloX/moduloEntrada);
end;
function actualizarPesos (rART1:ART1) :ART1;
var i: Integer;
begin
for i:= Low(rART1.F1.salida)to High(rART1.F1.salida)do
rART1.F2.peso[rART1.GF2,i]:=(rART1.L/(rART1.L1+rART1.modX))*rART1.F1.salida[i];
for i:= Low(rART1.F1.salida)to High(rART1.F1.salida)do
rART1.F1.peso[i,rART1.GF2]:=rART1.F1.salida[i];
Result:=rART1;
end;
function eliminarInhibicion (rART1:ART1) :ART1;
var i: Integer;
begin
155
156
begin
F1:=crearF1(M,N);
F2:=crearF2(N,M);
rART1:=crearRed(F1,F2,A1,B1,C1,D1,L,rho,N);
inicializarPesos(rART1, B1,D1,L,M);
MProcesamiento.Lines.Add('PESOS INICIALES:');
self.MProcesamiento:=mostrarPesos(rART1,self.MProcesamien
to);
self.BtnCrearRed.Enabled:=false;
self.BtnEjecutar.Enabled:=true;
self.BLimpiarGlyph.Enabled:=true;
end;
procedure TART1Lab.BtnEjecutarClick(Sender: TObject);
var i:Integer;
textoVectorEntrada: String;
textoSalidaF1: String;
textoSalidaF2: String;
textoNuevaSalidaF1:String;
textoTramaResultante:String;
resultadoCoincidencia:Real;
procesado: Integer;
intentos: Integer;
errorCodificacion: Boolean;
begin
if(self.M=35)then
glyphCodificado:=codificarGlyph35(self.PBGlyph);
if(self.M=63)then
glyphCodificado:=codificarGlyph63(self.PBGlyph);
errorCodificacion:= false;
if(self.M=35)then
if(glyphCodificado='00000000000000000000000000000000000')
then
begin
ShowMessage ('El glyph no puede estar vaco');
errorCodificacion:= true;
end;
if(self.M=63)then
if(glyphCodificado='0000000000000000000000000000000000000
00000000000000000000000000')then
begin
ShowMessage ('El glyph no puede estar vaco');
errorCodificacion:= true;
157
end;
if errorCodificacion= false then
begin
self.LInfResultado.Caption:=' ';
self.CBResultados.Clear;
self.CBResultados.Items.Clear;
if(self.M=35)then
self.MGlyphCodificado.Lines.Add(glyphCodificado)
else
self.MGlyphCodificado.Lines.Add(glyphCodificado);
SetLength(vectorEntrada.neurona,M);
self.MProcesamiento.Lines.Add('');
rART1:=eliminarInhibicion(rART1);
procesado:=0;
intentos:=0;
{El procesamiento inicia desde aqui}
while (procesado=0) and (intentos<N) do
begin
textoVectorEntrada:='';
textoSalidaF1:='';
textoSalidaF2:='';
textoNuevaSalidaF1:='';
self.MProcesamiento.Lines.Add('');
vectorEntrada:=cargarVectorEntrada
(self.MGlyphCodificado , vectorEntrada, M);
for i:= 0 to M-1 do
textoVectorEntrada:=textoVectorEntrada+FloatToStr(vectorE
ntrada.neurona[i]);
self.MProcesamiento.Lines.Add('Vector de Entrada:
'+ textoVectorEntrada);
rART1:=propagarF1 (rART1, vectorEntrada);
for i:= 0 to M-1 do
textoSalidaF1:=textoSalidaF1+FloatToStr(rART1.F1.salida[i
]);
self.MProcesamiento.Lines.Add('Salida F1: '+
textoSalidaF1);
rART1:=propagarF2 (rART1, M);
158
159
begin
rART1.INH[rART1.GF2]:=0;
intentos:=intentos+1;
end;
{Fin de actualizacin de pesos}
end;
//('ha salido del proceso');
{proceso que inicia la trama con la que ha encontrado la
coincidencia}
if intentos>=N then
begin
self.LInfResultado.Font.Color:= ClRed;
self.LInfResultado.Caption:='Memoria Llena. No se
ha podido crear una nueva clasificacin los patrones ms
parecidos son: ';
self.CBResultados:=coincidenciasMasCercanas(rART1,vectorE
ntrada,self.CBResultados);
end
else
begin
self.LInfResultado.Font.Color:= ClGreen;
self.LInfResultado.Caption:='El patrn se encuentra
dentro de la siguiente clasificacin:';
end;
if(self.M=35)then
self.PBGlyph:=decodificarGlyph(self.PBGlyph,self.M,glyphC
odificado);
if(self.M=63)then
self.PBGlyph:=decodificarGlyph(self.PBGlyph,self.M,glyphC
odificado);
end;
end;
procedure TART1Lab.PBGlyphMouseDown(Sender: TObject;
Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
var PX: Integer;
PY: Integer;
begin
PX:=X;
160
PY:=Y;
if(self.M=35)then
PBGlyph:=pintarglyph35(PBGlyph,PX,PY,false);
if(self.M=63)then
PBGlyph:=pintarglyph63(PBGlyph,PX,PY,false);
end;
procedure TART1Lab.MAGuardarClick(Sender: TObject);
var
F: TextFile;
i,j: Integer;
begin
if cuadroSaveDialog.Execute then
begin
cuadroSaveDialog.Options :=
[ofAllowMultiSelect, ofFileMustExist];
cuadroSaveDialog.Filter := 'ART files
(*.art)|*.art'; {Delphi}
cuadroSaveDialog.FilterIndex := 2; { start the
dialog showing all files }
AssignFile(F, cuadroSaveDialog.Filename);
Rewrite(F);
Writeln(F,floatToStr(M));
Writeln(F,floatToStr(N));
Writeln(F,floatToStr(rART1.A1));
Writeln(F,floatToStr(rART1.B1));
Writeln(F,floatToStr(rART1.C1));
Writeln(F,floatToStr(rART1.D1));
Writeln(F,floatToStr(rART1.L));
Writeln(F,floatToStr(rART1.rho));
Writeln(F,floatToStr(rART1.GF2));
Writeln(F,floatToStr(rART1.modX));
for i:= Low(rART1.INH)to High(rART1.INH)do
Writeln(F,floatToStr(rART1.INH[i]));
for i:= Low(rART1.F1.salida)to
High(rART1.F1.salida)do
for j:= Low(rART1.F2.salida)to
High(rART1.F2.salida)do
Writeln(F,floatToStr(rART1.F1.peso[i,j]));
for i:= Low(rART1.F2.salida)to
High(rART1.F2.salida)do
for j:= Low(rART1.F1.salida)to
High(rART1.F1.salida)do
Writeln(F,floatToStr(rART1.F2.peso[i,j]));
CloseFile(F);
end;
end;
161
162
if self.M=35 then
begin
self.PBGlyph:=construirGlyph35(PBGlyph);
PBResultado:=decodificarResultado(PBResult
ado,self.M,'');
end;
if self.M=63 then
begin
self.PBGlyph:=construirGlyph63(PBGlyph);
PBResultado:=decodificarResultado(PBResult
ado,self.M,'');
end;
F1:=crearF1(M,N);
F2:=crearF2(N,M);
rART1:=crearRed(F1,F2,A1,B1,C1,D1,L,rho,N);
LTextrho.Caption:= line;
Readln(F, line);
rART1.GF2:=StrToInt(line);
Readln(F, line);
rART1.modX:=StrTofloat(line);
for j:= Low(rART1.INH)to High(rART1.INH)do
begin
Readln(F,line);
rART1.INH[i]:=StrTofloat(line)
end;
for j:= Low(rART1.F1.salida)to
High(rART1.F1.salida)do
for k:= Low(rART1.F2.salida)to
High(rART1.F2.salida)do
begin
Readln(F,line);
rART1.F1.peso[j,k]:=StrTofloat(line);
end;
for j:= Low(rART1.F2.salida)to
High(rART1.F2.salida)do
for k:= Low(rART1.F1.salida)to
High(rART1.F1.salida)do
begin
Readln(F,line);
rART1.F2.peso[j,k]:=StrTofloat(line);
end;
CloseFile(F);
163
if self.M=35 then
glyphCodificado:=
'00000000000000000000000000000000000';
if self.M=63then
glyphCodificado:=
'0000000000000000000000000000000000000000000000
00000000000000000';
self.MProcesamiento:=mostrarPesos(rART1,self.MP
rocesamiento);
self.BtnParametros.Enabled:=false;
self.BtnCrearRed.Enabled:=false;
self.BtnEjecutar.Enabled:=true;
self.BLimpiarGlyph.Enabled:=true;
end;
end;
procedure TART1Lab.MANuevoClick(Sender: TObject);
begin
if self.M=35 then
glyphCodificado:=
'00000000000000000000000000000000000';
if self.M=63then
glyphCodificado:=
'000000000000000000000000000000000000000000000000000
000000000000';
self.PBGlyph.Canvas.Pen.Color:= clBtnFace;
self.PBGlyph.Canvas.Brush.Color:= clBtnFace;
self.PBGlyph.Canvas.Rectangle(0,0,160,238);
self.PBResultado.Canvas.Pen.Color:= clBtnFace;
self.PBResultado.Canvas.Brush.Color:= clBtnFace;
self.PBResultado.Canvas.Rectangle(0,0,160,238);
self.PBGlyph.Canvas.Pen.Color:= clBlack;
self.PBResultado.Canvas.Pen.Color:= clBlack;
self.MGlyphCodificado.Clear;
self.MProcesamiento.Clear;
self.CBResultados.Clear;
self.CBResultados.Items.Clear;
self.M:=0;
self.BtnEjecutar.Enabled:=false;
self.BLimpiarGlyph.Enabled:=false;
self.BtnParametros.Enabled:=true;
self.LTextM.Caption:='';
self.LTextN.Caption:='';
self.LTextA1.Caption:='';
self.LTextB1.Caption:='';
self.LTextC1.Caption:='';
164
self.LTextD1.Caption:='';
self.LTextL.Caption:='';
self.LTextrho.Caption:='';
self.LInfResultado.Caption:='';
end;
procedure TART1Lab.BMostrarResuladoClick(Sender:
TObject);
var textoCBResultados:String;
begin
if self.LTextM.Caption <> '' then
begin
textoCBResultados:=CBResultados.Text;
PBResultado:=decodificarResultado(PBResultado,self.M,text
oCBResultados);
end;
end;
procedure TART1Lab.BLimpiarGlyphClick(Sender: TObject);
begin
self.LInfResultado.Caption:='';
PBResultado:=decodificarResultado(PBResultado,self.M,'');
self.CBResultados.Clear;
if self.M=35 then
begin
self.PBGlyph:=construirGlyph35(PBGlyph);
glyphCodificado:='00000000000000000000000000000000000';
end;
if self.M=63then
begin
self.PBGlyph:=construirGlyph63(PBGlyph);
glyphCodificado:=
'000000000000000000000000000000000000000000000000000
000000000000';
end;
end;
165
begin
self.PBGlyph:=construirGlyph35(PBGlyph);
PBResultado:=decodificarResultado(PBResultado,self.M,'');
self.PBGlyph:=decodificarGlyph(self.PBGlyph,self.M,glyphC
odificado);
end;
if self.M=63 then
begin
self.PBGlyph:=construirGlyph63(PBGlyph);
PBResultado:=decodificarResultado(PBResultado,self.M,'');
self.PBGlyph:=decodificarGlyph(self.PBGlyph,self.M,glyphC
odificado);
self.PBGlyph.Canvas.Pen.Color:= clBlack;
self.PBGlyph.Canvas.Rectangle(159,0,165,238);
self.PBGlyph.Canvas.Rectangle(0,237,165,240);
end;
end;
end.
Unidad de parmetros
unit undParametros;
interface
uses
Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms,
Dialogs, StdCtrls, Buttons, ExtCtrls;
type
TFrmParametros = class(TForm)
LbD1: TLabel;
LbB1: TLabel;
LbC1: TLabel;
LbA1: TLabel;
LbM: TLabel;
LbN: TLabel;
LbL: TLabel;
Lbrho: TLabel;
BtnOkParametros: TBitBtn;
166
BtnCancelParametros: TBitBtn;
EA1: TEdit;
EB1: TEdit;
EC1: TEdit;
ED1: TEdit;
EL: TEdit;
Erho: TEdit;
EN: TEdit;
PnParametros: TPanel;
BtnReset: TBitBtn;
CBM: TComboBox;
procedure BtnResetClick(Sender: TObject);
procedure BtnOkParametrosClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
correcto: Integer;
end;
var
FrmParametros: TFrmParametros;
implementation
{$R *.dfm}
procedure TFrmParametros.BtnResetClick(Sender: TObject);
begin
self.CBM.ItemIndex:=0;
self.EN.Text:='';
self.EA1.Text:='';
self.EB1.Text:='';
self.EC1.Text:='';
self.ED1.Text:='';
self.EL.Text:='';
self.Erho.Text:='';
self.CBM.SetFocus;
end;
procedure TFrmParametros.BtnOkParametrosClick(Sender:
TObject);
var mayor:Real;
begin
correcto:=0;
167
168