UNIVERSIDAD AUTóNOMA METROPOLITANA UNIDAD IZTAPALAPA

REPORTE DEL PROYECTO TERMINAL I Y II

asesora : M en C. Mariko Nakano M.

FEB 1995

REDES NEURONALES

IMPLEMENTACION Y DISEA0 DE ADALINE

(ADAPTATIVE LINEAR ELEMENTS)

POR : JESúS NARO CRUZ UNIVERSIDAD AUT6NOMA METROPOLITANA

UAMUtAPAIAPA MeXICO , D.F

2

A MIS PADRES, HERMANOS Y MONICA JUDITH LAS PERSONAS QUE MAS AMO EN ESTE MUNDO.

A MIS PADRES QUE SE HAN SACRIFICADO TANTO POR DARME LOS MEJORES ESTUDIOS

A MIS HERMANOS QUE HAN SIDO PACIENTES CONMIGO

Y A M6NICA JUDITH A QUIEN AMO CON TODO EL CORAZ6N.

3

INDICE GENERAL

PREFACIO

CAPITULO 1

CAPITULO 2

CAPITULO 3

CAPITULO 4

CAPITULO 5

Pag 5

LA RED NEURONAL BIOL6GICA .............................................. 6 INTRODUCCI~N ................................................................ 6 LA NEURONA .................................................................... 7 EL CUERPO DE LA NEURONA ......................................... 7 DENDRITAS ....................................................................... 8 EL AXON ............................................................................ 8 ANALOGíAS ....................................................................... 9 LA NEURONA COMO UNA UNIDAD ACTIVA .................... 10

FUNDAMENTOS ......................................................................... 12 LA NEURONA ARTIFICIAL ................................................ 13 FUNCIONES DE ACTIVAC16N .......................................... 14 MODELO ABSTRACTO ..................................................... 16

ENTRENAMIENTO DE REDES NEURONALES ARTIFICIALES ..... 17 OBJETIVO DEL ENTRENAMIENTO ................................... 17 ENTRENAMIENTO SUPERVISADO ................................... 17 ENTRENAMIENTO NO SUPERVISADO ............................. 18 ALGORITMOS DE ENTRENAMIENTO ................................ 18

RECONOCIMIENTO DE PATRONES ............................................. 20 ADALINE ............................................................................. 20 ALGORITMO ....................................................................... 20 ALGORITMO ADAPTATIVO ............................................... 21

HERRAMIENTA GENERADORA DE IMÁGENES .............. 22

RED NEURONAL DE KOHONEN ................................................... 26 CARACTERíSTICAS DEL MAPA CLASIFICADOR ............. 26 SIMULAC16N DEL SOM ..................................................... 27 ESTRUCTURA DE DATOS DEL SOM ............................... 28 ALGORITMOS DEL SOM ................................................... 28 PROPAGACION DE LA SEÑAL EN EL SOM ..................... 29 ALGORITMOS DE APRENDIZAJE PARA SOM ................. 31 ENTRENAMIENTO DEL SOM ............................................ 32

SIMULACI~N ................................................................... 21

C6DIGO FUENTE .................................................................................................. 34

CONCLUSIONES ................................................................................................... 53

BIBLIOGRAFíA ....................................................................................................... 54

4

PREFACIO

Este reporte, como parte de mi proyecto terminal, tiene como objetivo examinar las estructuras de datos y los algoritmos que fundamentan gran parte de las Redes Neuronales en la programacidn actual de computadoras. La base de esta obra es el contenido de sus primeros 5 capítulos, que mediante una previa investigacidn en artículos y libros sobre el tema, obtuve en el transcurso de los 6 meses de investigacidn y desarrollo. El Único requisito para entender sobre el tema de Redes Neuronales es conocer el lenguaje programacidn C; aunque el generador de imdgenes que desarrolle requiere que se conozca Windows y C para Windows (programacidn por Eventos) , en donde se explica detalladamente y se ofrece el listado completo del cddigo fuente para su estudio. Esta disposicidn permitir6 a cualquier lector no sdlo aprender los principios, sino tambibn observar cdmo se aplican en las Redes Neuronales (particularmente en ADALINE).

representaciones Abstractas con el fin de Modelar las actividades del Cerebro Humano en coordinacidn con el Ojo en el amplio contexto de la solucidn de los problemas por computadora.

proceso de la solucidn de los problemas.

Aquí, se intenta cubrir el estudio de las estructuras de Datos, Algoritmos y

Tambibn se introducen los conceptos de Redes Neuronales como parte integrante del

La estructura de este reporte

El capitulo 1 contiene observaciones sobre las aspectos bioldgicos de las Neuronas,así como una descripcidn breve de cada uno de los componentes de la Celula.

a conocer a la persona interesada acerca de los modelos de Redes Neuronales y las Tbcnicas estadísticas tradicionales empleadas.

el objetivo de cada tknica dando sus ventajas y desventajas. Tambibn se muestra una notacidn matemdtica estandar que se usa en las tbcnica de entrenamiento de Redes.

Los capítulos 4 y 5 son los importantes ya que muestran 2 Casos de Estudio de las Redes Neuronales : Adaline y la Red de Kohonen. Así tambihn se da el cddigo fuente del generador de imagenes desarrollado en Windows y se explica su funcionamiento. El entrenamiento de ADALINE se hizo en una de Tarjeta TRANSPUTER , la cual me

proporciono mi asesora; para poder entrenar la RED NEURONAL rdpidamente.

El capitulo 2 presenta los conceptos matemdticos en funci6n a la Red Neuronal, dando

E l capitulo 3 se analizan las tbcnicas de entrenamiento de Redes Neuronales así como

Agradecimientos Deseo expresar mi reconocimiento y agradecimiento, a mi asesora de Proyecto Terminal Mariko Nakano, por permitirme participar en uno de sus proyectos y por permitirme usar su computadora y cubículo, hecho que facilitd de manera significativa en la preparacidn, desarrollo y entrenamiento de la Red Neuronal de mi proyecto Terminal I y II. Así tambien quiero agradecer al CINVESTAV (Centro de Investigaciones y Estudios Avanzados del IPN) por facilitarme artículos y libros sobre el tema de Redes Neuronales para poder mejorar este reporte en cuanto a informacidn basica y fundamental del tema.

Jesús Naro Cruz.

5

CAPITULO 1 LA RED NEURONAL BIOLóGICA

No se trata de Saber más que los demás sino de saberlo mejor.

Seneca

INTRODUCCION :

El cerebro humano contiene más de 100 millones de neuronas. Excediendo el número de estrellas de la vía Láctea, éstas neuronas se comunican a través del cuerpo por medio de fibras nerviosas que son tal vez 100 mil billones de conexiones llamadas sindpsis. Esta red de neuronas es la responsable de aquellos fenómenos que llamamos pensamiento, emociones y cognición, así como el desempeño de miles de funciones de autónomas y sensomotoras. La manera exacta en que se lleva a cabo esta está función, es muy poco conocida, pero sin embargo las estructuras biológicas han sido mapeadas, y ciertas áreas están gradualmente siendo comprendidas.

El cerebro humano contiene una densa red vasos de sangre que proveen de oxígeno y nutrientes a las neuronas y otras entidades del cerebro. Estos vasos están conectados al sistema circulatorio principal por un sistema de filtración altamente efectivo llamado la barrera de Sangre del cerebro, un mecanismo de protección que aisla al cerebro de sustancias potencialmente tóxicas encontradas en el torrente sanguíneo.

La barrera de sangre del cerebro es esencial para la seguridad del cerebro, pero complica la administración de drogas terapéuticas. También frustra a los investigadores quiénes quisieran observar los efectos de una amplia variedad de químicos en el funcionamiento del cerebro.

El cerebro es el que consume más energía del cuerpo. Conteniendo sólo el 2% de la masa corporal, utiliza el 20% del oxígeno del Cuerpo. Aún cuando dormimos, el consumo de energía se mantiene estable. De hecho, existe evidencia de que puede incrementarse durante los periodos de Sueño REM (Rapid eyes Movement). Consumiendo sólo 20 wats, el cerebro es increíblemente eficiente en su consumo de energía.

La computadora con sólo una pequeda fracción de la habilidad computacional del cerebro, consume muchos miles de wats y requiere de elevadas provisiones de enfriamiento para prevenir su autodestrucción térmica.

6

D E N D R I T ! Muchas de las señales de entrada de otras neuronas entran a la célula por medio de las dendritas, una estructura arborescente que emana del cuerpo de la célula. En las dendritas éstan las conexiones sinápticas donde las señales son recibidas, usualmente desde otros axones.

Además, existen un número significante de conexiones sinápticas de axón a axón, de axón a cuerpo celular y de dendritas a dendrita, la función de éstas conexiones es poco entendida, pero es demasiado notable para ser significantes.

A diferencia de l o s circuitos eléctricos, normalmente no existen conexiones físicas o eléctricas en la sinápsis. En vez de ello, una pequeña separación llamada fisura sináptica separa la dendrita del axón transmisor. Sustancias químicas especializadas liberadas por el axón dentro de la fisura sináptica separa la dendrita del axón transmisor. Sustancias químicas especializadas liberadas por el axón dentro de la fisura sináptica se difunden en las dendritas. Estas sustancias llamadas neurotransmisores, llegan a receptores específicos que existen en las dendritas y entran en el cuerpo celular.

Más de 30 neurotransmisores han sido identificados. Algunos son excitatorios y hacen que la célula "dispare" y produzca un pulso de salida. Otros son inhibitorios y tienden a suprimir tales pulsos. El cuerpo de celular combina las señales recibidas en sus dendritas y, si su señal resultante se encuentra arriba de cierto umbral, un pulso es producido y se propaga del axón hacia otras neuronas.

EL =ÓN Un axón puede ser tan corto como 0.1 milímetro, o puede exceder 1 metro de longitud, extendiéndose hacia una parte enteramente diferente del cuerpo. Cerca de su final, el axón tiene múltiples ramificaciones, cada una terminando en una en una sinapsis, donde la señal es transmitida a la otra neurona a través de una dendrita, o en algunos casos, directamente al cuerpo celular.

Está forma, una sola neurona puede generar un pulso que activará o inhibirá cientos de miles de otras neuronas, cada una de las cuales puede a su vez (a través de las dendritaslser activadas por cientos de miles de neuronas. Así, es éste alto grado de conectividad más que la complejidad funcional de la neurona en si misma lo que la dé a la neurona su poder computacional.

La conexión sináptica que termina una rama del axón es una expansión pequeña y bulbosa conteniendo estructuras esféricas llamadas vesículas sinápticas,cada una de las cuales contiene un gran número de moléculas transmisoras. Cuando un impulso nervioso llega al axón, algunas de ésas vesículas liberan sus contenidos dentro de la fisura sináptica, iniciándo así el proceso de comunicación interneuronal.

8

La actividad de cada celda neuronal en el sistema nervioso central depende de las señales recibidas de muchas otras celdas. Por ejemplo, la celda piramidal, el cual es la neuronal principal de la neocorteza mammalian, tiene alrededor de 2000 a 10,000 terminales de entrada (sinápsis) en el hombre. Las conexiones de entrada podrían llegar de la celda mas cercana , y estudios anatómicos indican que cada neurona, dentro de una fracción de un milímetro esta conectada firmemente a 1000 neuronas que están cercas. Por otro lado, también existe interconexión mutua entre grupos de celdas localizados remotamente haciendo largas Prolongaciones (long Axons). Las conexiones hechas por el cuerpo calloso (Corpus callosum) entre l o s hemisferios del cerebro y las 2 formas de proyecciones entre partes seguras ,e.g., áreas cortical y nuclei thalamic,son de este tipo. Hay así plenamente un subconjunto cooperativo de celdas en el cerebro, consistiendo de un número considerable de neuronas (104)esparcidas a lo largo del área. Por lo tanto, la Red Cerebral es un sistema de retroalimentación muy complicado, teniendo interacciones químicas y de retroalimentación tanto global como local. Es evidente que los fenómenos colectivos juegan un papel muy importante en el procesamiento de señales, reflejado en varias características del grupo de actividades y ondas cerebrales observadas.

Por otra parte, el registro de las actividades de las celdas sencillas en el cerebro revelan plenamente las operaciones especificas de estas. Otro punto de vista, respaldado por numerosas investigaciones en electrofisiología, es que muchas neuronas son procesadores individuales, de algún modo capaces de responder a específicas experiencias sensoriales u otras ocurrencias. Muy pocas neuronas, sin embargo, reciben directamente señales desde l o s órganos sensoriales o de la Ganglia Preporcesadora; las respuestas específicas deberán entonces resultar de alguna clase de procesamiento multifacético de información por la red donde las neuronas están involucradas. Entonces las conexiones sinápticas son los principales enlaces de comunicación de una neurona a otra, esto será tomando que aquellos resultados de respuesta especifico son la habilidad de la celda para decoficar y/o codificar patrones específicos de actividades en aquellas terminales de entrada, de una manera similar los circuitos lógicos de las computadoras están posibilitados para decodificar combinaciones de la entrada de valores de señales lógicos. Sin embargo, uno deberá evitar las comparaciones de la red neuronal a los circuitos logicos o digitales; ya que los fenómenos colectivos no pueden ser explicados por operaciones lógicas. La intensidad de las señales neuronales parecerán estar definidas en términos de variables de impulsos de frecuencia, y los trenes de impulsos de un numero grande de neuronas son integrados por otras neuronas. La red neuronal es más parecida a una computadora analógica.

9

LA NEURONA COMO UNA UNIDAD A C T m Existe una gran variedad de celdas neuronales y redes neuronales posiblemente relacionando diferentes técnicas de solución en la biología. Si estamos restringiéndonos al sistema nervioso central de l o s animales, la celda neuronal puede ser considera como una unidad activa operante como una compuerta oscilatoria de impulso capaz de producir trenes de impulso neuronal en respuesta a una suave entrada de excitación. Las propiedades de la neurona resultan de fenómenos biológicos de la membrana de la celda las cuales suministran la enérgica señal. Esto será manteniendo frecuentemente que el análisis de la dinámica neuronal deberá estar basado en la teoría de membranas activas, i.e., fenómenos disparados, y sus controles bioquímicos. El ciclo disparador obedece una gran variedad de ecuaciones de Hodgkin-Huxley. Operaciones correctas solo pueden garantizar Si la neurona es una parte activa del organismo viviente, con todos los efectos de control estabilizantes químicos y fisiológicos incluidos.

Por otra parte, esto podría que ciertas propiedades generales de estás leyes funcionales pueden deducirse de restricciones físicas. Primero, cada neurona puede solamente oscilar (en)/a un impulso de frecuencia, el cual por razones físicas, químicas y energéticas, esta limitado por 2 límites de saturación, es decir, cero y unos pocos cientos de Hertz; hay el llamado periodo refractario después de cada impulso durante el cual nuevos impulsos no pueden ser disparados. Entre estos límites el porcentaje de frecuencia oscilatoria es una función monotonica de la activación total de la neurona (despolarización de la membrana) por la señal presinaptica. Los efectos combinados de entrada, sin embargo, necesita especial consideración. Si cada sinapsis tiene un efecto de control el cual sería independiente de aquella u otras sinapsis y de la actividad de la neurona, uno podría aplicar los principios de Spatial Summation de estos efectos. Entonces, como es muchas veces pensado, la neurona tuvo características de una integración por partes de la señal presinaptica, uno podría escribir el siguiente tipo de ecuación diferencial para la actividad eléctrica yi de la neurona en un sentido promedio estadístico

dyi/dt = S fi j (xi j) - gi (yi) y por que la actividad es una entidad no negativa, impondremos una condición adicional

Aquí yi representa la frecuencia suavizada disparada temporalmente de la iesima neurona, y xij es el impulso de frecuencia en la j-esima entrada (conexión sinaptica) desprendida por otras neuronas, respectivamente. La f(*) son las formas funcionales,las cuales describen el control sinaptico de la membrana disparada de la neurona. En una descripción más exacta fij debe depender de la historia de l o s términos cortos de la entrada de la señal(correspondiente, e.g., a el termino corto de Fatiga o facilitación de la conexión). Por otra parte, l o s cambios en el termino largo en fijo son usualmente identificados con los efectos de memoria. El termino de perdida gi(yi) deberá ser no lineal en yi tomando l o s efectos de saturación dentro del conteo en una forma simple.

yi>= O

10

Grossberg remarca que durante el tiempo cuando la neurona es disparada, esta bloquea la eficiencia de las entradas donde para las señales de entrada efectiva uno deberá tomar expresiones de la forma (1-Byi)xij, donde B es una constante suave. Por otra parte, durante el numero de impulsos de salida en un estallido liberado por la neurona es una complicada y sensible función de la membrana potencial,^ hay otras restricciones, esto fue filtrado en el presente trabajo que todos los factores responsables de la saturación podrían simplemente ser puestos dentro de un separado termino de perdida. Las leyes del modelo deberán ser simplificado de una u otra manera. Hay casos en l o s cuales el comportamiento rápido trascendente de yi será importante,e.g.,en las funciones de control optimizado. Mas comúnmente, sin embargo, uno esta interesado en fenómenos que persisten por un tiempo apreciable,por decir, 10-50 ms, el cual es un tiempo trascendente en la ecuación 1. Para la expresión de arriba esto es entonces posible resolverla directamente la relación estacionaria entrada-salida entre las señales,poniendo dyi/dt=O. Entonces nosotros tenemos otras relación funcional, asumiendo que la inversa de la función gi-1 existe:

yi=d [S fij (xij)- q] =d (Ii-qi)

donde si(*) es una función Sigmoide; esta tiene un alto y un bajo limite de saturación y una proporcionalidad entre rango. Esta en una versión suave de la familia de Heaviside o función de paso. El valor de desplazamiento qi es una constante positiva , una entrada hipotética. (La verdadera entrada disparada depende de la interacciones co1ectivas)Los efectos de control de entrada de la red son simplificados por el escalar Ii. Existen dos tipos de conexiones sinapticas, excitatoria e inhibidora, correspodientemente. La eficiencia de muchas conexiones inhibidoras son de un orden de magnitud mas fuerte que el de una excitatoria. El numero de entradas inhibidoras es correspondientemente el mas pequeño. El efecto de una entrada inhibidora puede ser muy no lineal y no siempre puede ser descrita como una suma como se mostró en la Ecuación 1 o 2.A veces esto bloquea la actividad de la neurona totalmente y hay casos en los cuales la sinapsis inhibidora puede dejar inactiva una gran parte de la celda neuronal. Un tipo común de control es la inhibición presinaptica de donde la sinapsis excitatoria es provista con una directa conexión inhibidora, físicamente localizada sobre esta. La otra sinapsis inhibidora conecta en la membrana de la celda del cuerpo. Por otra parte, existen casos, de efectos especialmente integrados, donde la débil inhibición pueden tomarse dentro del conteo de la suma lineal, como en las interacciones laterales discutidas mas adelante.

11

CAPITULO 2 FUNDAMENTOS

Tan al to como p u e d e s v o l a r , t a n lejos como puedas llegar en tu búsqueda por el Saber D i s f r u t a de ello con toda t u p a s i ó n .

Jesús Naro Cruz.

Las redes neuronales artificiales han sido desarrolladas en una amplia variedad de configuraciones. A pesar de éSta diversidad, los paradigmas de las redes tienen mucho en común. Las redes neuronales artificiales están biológicamente inspiradas; esto es, los investigadores están usualmente pensando acerca de la organización del cerebro cuando están considerando configuraciones y algoritmos de redes. El conocimiento acerca de la operación general del cerebro está tan limitada que existe poca guía para aquellos que quisieran emularlo. De aquí, los diseñadores de redes neuronales deben ir más allá del conocimiento biológico actual. En muchos casos, es necesario descartar posibilidades biológicas; el cerebro se convierte en una metáfora; las redes neuronales son producidas de tal forma que son orgánicamente imposibles o requiere un conjunto de hechos asumidos muy improbable acerca de la anatomía del cerebro y su funcionamiento. Los modelos de redes neuronales están especificados por la topología de l a red, características del nodo, y las reglas del aprendizaje o entrenamiento. Estas reglas especifican un conjunto inicial de pesos e indican e indican cómo éstos deben ser adaptados para mejorar el desempeño. Tanto los procedimientos de diseño como las reglas de entrenamiento son el tópico de muchas investigaciones actuales.

Las redes neuronales típicamente proveen un más alto grado de tolerancia a las fallas que las computadoras secuenciales de Von Neumann porque hay muchos nodos de procesamiento, cada uno con conexiones primarias locales. El daño a unos pocos nodos o ligas en una u otra manera no necesariamente disminuye el desempeño general significativamente.

Muchos de los algoritmos de redes neuronales también adaptan pesos de conexión para mejorar el desempeño basados en resultados actuales. La adaptación o aprendizaje es uno de los puntos focales de la investigación de redes neuronales actuales. La habilidad de adaptarse y continuar aprendiendo es esencial en áreas como reconocimiento del habla donde los datos de entrenamiento son limitados y nuevas palabras, nuevos dialectos, nuevas frases, y nuevos ambientes son continuamente encontrados. La adaptación también provee un grado de robustez para compensar variaciones pequeñas en características de los elementos procesados.

12

Las técnicas de estadistica tradicionales no son adaptivas, pero típicamente procesan todos los datos de entrenamiento simultáneamente antes de ser usados con nuevos datos. Los clasificadores de redes neuronales también son no parametricos y hacen mas fragiles suposiciones concernientes a la forma de apoyar distribuciones que los clasificadores estadísticos tradicionales. Estos pueden probar ser más robustos cuando las distribuciones son generadas por procesos no Lineales y son fuertemente No Gaussianos.

LA NEURONA ARTIFICIAL La neurona artificial fue diseñada para imitar las características de Primer Orden de la Neurona biológica. En esencia, un conjunto de entradas son aplicadas, cada una representando la salida de otra neurona. Cada entrada es multiplicada por un Correspondiente peso, análogo a una fuerza sináptica, y todas las entradas pesadas son entonces sumadas para determinar el nivel de activación de la neurona. La figura de abajo, muestra un modelo que implementa ésa idea. A pesar de la diversidad de los paradigmas sobre redes, casi todas están basadas en éSta consideración. Aquí, un conjunto de entradas llamadas xl,x2, ..., xn es aplicada a la neurona artificial. Estas entradas, colectivamente referidas como el vector X, corresponden a las señales dentro de las sinápsis de una neurona biológica.

Xi * . NET = XW

NET = XlWl+ ..... + XnWn

f i g u r a 2 . 1

Cada peso corresponde a la fuerza de una sola conexión sináptica biológica. (El conjunto de pesos es llamada colectivamente como el vector W) . El bloque sumatorio, correspondiente al cuerpo biológico celular, suma todas las entradas pesadas algebraicamente, produciéndose una salida que llamamos NET. Esta puede ser escrita compactamente en notación vectorial como sigue:

NET = x w

13

FUNCIONES DE ACTIVACI~N La señal NET es usualmente procesada más por una función de activación F para producir la señal de salida de las neurona, OUT. Esto puede ser una simple función lineal,

OUT = K (NET) Donde K es una constante, una f u n c i ó n de umbral,

OUT=l si NET T OUT=O de otra forma

donde T es una constante de valor de Umbral, o una función que simula más exactamente la característica y transferencia de la neurona biológica y permite funciones de red más generales.

En la figura 2-2,el bloque etiquetado como F acepta la salida RED y produce la salida la señal de salida SALIDA. Si el bloque de procesamiento F comprende el rango de NET, de tal modo que OUT nunca excede los límites inferiores sin importar el valor de NET, F es la llamada función compresora. La función comprensora es comúnmente escogida para ser la función Logística del Sigmoide (S-sombreada mediana) como se muestra en la figura 2.2. Esta función se expresa matemáticamente como :

-NET F(x) = 1 / (lte 1

Entonces

-NET OUT = 1 / (l+e )

Por similitud a los sistemas análogos, podemos pensar en la función de activación como definir la ganancia no lineal de la neurona artificial. Esta ganancia se obtiene encontrando el cociente del cambio de OUT a un pequeño cambio en NET. Entonces, la ganancia es la inclinación de la curva a un nivel de excitación específico. Varia de un valor bajo a grandes excitaciones negativas (la curva es casi horizontal), a un gran valor de excitación cero, y decae como la excitación se va haciendo más grande y positiva.

x1

x2

XN

OUT=F

FIG 2.2 NEURONA ARTIFICIAL

Grossberg (1973) encontró que ésta característica no lineal de ganancia resuelve el dilema de saturación de ruido que él propuso; esto es, ¿Cómo puede la misma Red manejar tanto señales grandes como pequeñas? Las señales de entrada pequeñas requieren alta ganancia a través de la red si van a ser capaces de producir una salida utilizable; sin embargo, un gran número de estados en cascada de gran ganancia saturan la salida con el ruido

14

amplificado (variaciones aleatorias), esto está presente en cualquier red realizable. También, grandes señales de entrada saturan estados de gran ganancia, eliminando otra vez cualquier salida utilizable. La región central de alta ganancia de la función logística resuelve el problema de procesar señales pequeñas, mientras que sus regiones de ganancia decreciente en los extremos positivos y negativos son apropiadas para grandes excitaciones. De éSta manera, una neurona se desempeña con ganancia apropiada para una gran amplitud de niveles de entrada.

Otra función comúnmente usada es la función Tangente Hiperbólica. Véase la figura 2.3.Es similar en forma a la función sigmoidal y es comúnmente usada por biólogos como un modelo matemático de activación de nervios celulares. Usada como una función de activación de una red neuronal es expresada como sigue:

OUT = TANH( x )

Como la función logística, la tangente hiperbólica tiene la forma de S simétrica al origen, resultando que OUT tiene el valor de Cero cuando NET es Cero. A diferencia de la función logística, la función tangente hiperbólica tiene un valor Bipolar para OUT, una característica que ha sido vista es benéfica para ciertas redes.

OUT A

'NET

L

-1

FIGURA 2.3

Este modelo simple de la neurona artificial ignora muchas de las características de su contraparte biológica. Por ejemplo, no toma en cuenta los retardos de tiempo que afecta la dinámica del sistema; las entradas producen salida inmediata. Más importante, no incluye los efectos de la sincronía o modulación de frecuencia de la neurona biológica, característica que para algunos investigadores es crucial. Sin tomar en cuenta éstas limitaciones, las redes formadas de éstas neuronas exhiben atributos que son fuertemente reminiscentes de los sistemas biológicos. Tal vez lo suficiente de la naturaleza esencial de la neurona biológica ha sido capturado para producir respuestas como el sistema biológico, o tal vez la similaridad es coincidencia; sólo el tiempo y la investigación lo dirá.

15

MODELO ABSTRACTO Las redes neuronales así como el cerebro operan en 2 modos o estados: El modo de APRENDIZAJE o carga de los datos y el modo de RECONOCIMIENTO o recuperación; y ambos PROCESOS utilizan una "memoria" base. Esta memoria en las redes neuronales no llega a convertirse en una Base de Datos como ocurre en la inteligencia artificial sino simplemente es un conjunto de valores que marcan de manera Discriminatoria a los diferentes patrones. Así tenemos que en las redes neuronales estos procesos son Pasivos; es decir, primero se realiza el proceso de Aprendizaje y después el de reconocimiento, implicando asi, que no pueda llevarse a cabo los 2 procesos simultáneamente y por ende la actualizarse automáticamente los valores de la "memoria" cuando exista un nuevo patrón (ya que se tendría que entrenar toda la red desde el inicio para poder reconocer.

MODELO DE APRENDIZAJE

PREGUNTA RECOLECTAR RESPUESTA

fR€COffOC/Ml€ffTO

FIGURA 1

16

CAPITULO 3 ENTRENAMIENTO DE LAS REDES NEURONALES

ARTIFICIALES

La iteración es humana; sin embargo la recursión es Divina.

L Peter Deutsch.

De todas las características interesantes de las redes neuronales artificiales, ninguna captura la imaginación como su habilidad para aprender. Su entrenamiento muestra tantos paralelos al desarrollo intelectual de los seres humanos que puede parecer que hemos logrado un entrenamiento fundamental de este proceso. La euforia debe ser temprana con precaución, el aprendizaje en las redes neuronales artificiales es limitado, y muchos diferentes problemas quedan por resolver antes de poder determinar si es que vamos en la pista correcta. Aún así, se han hecho demostraciones impresionantes, tales como la de Sejnowski con su NetTalk, y muchas otras aplicaciones prácticas.

EL OBJETIVO DEL EN!CREB"IENTO Una red es entrenada de tal forma que la aplicación de un conjunto de entradas produce la salida deseada (o al menos consistente). Cada una de tales conjuntos de entrada (o de salida) es referido como un vector. El entrenamiento es llevado a cabo por medio de aplicar secuencialmente vectores de entrada, mientras que se ajustan los pesos de la red de acuerdo a un procesamiento predeterminado. Durante el entrenamiento, los pesos de la red convergen gradualmente hacia valores de tal forma que cada vector de entrada produce el vector de salida deseado.

ENTRENAMIENTO SUPERVISADO Los algoritmos de entrenamiento están categorizados en supervisado y no supervisado. El entrenamiento supervisado requiere de aparear cada vector de entrada con un vector objetivo representando la salida deseada; juntos se denominan par de entrenamiento. Comúnmente una red es entrenada sobre un número de tales pares de entrenamiento. Un vector de entrada es aplicado, la salida de la red es calculada y comparada con ei vector objetivo correspondiente, y la diferencia (error) es realimentada a través de la red y los pesos son cambiados de acuerdo a un algoritmo que tiende a minimizar el error. Los vectores del conjunto de entrenamiento son aplicados secuencialmente, y los errores son calculados y los pesos ajustados para cada vector, hasta que el error para el conjunto entero de entrenamiento sea puesto a un aceptable nivel bajo.

17

ENTREPJAMIENTO NO SUPERVISADO Aún con muchos éxitos en aplicaciones, el entrenamiento supervisado ha sido criticado por ser biológicamente impausible; es difícil de concebir un mecanismo de entrenamiento en el cerebro que compare las salidas actuales y las deseadas, alimentando las correcciones procesadas hacia la red. ¿Si éste fuera el mecanismo del cerebro, de dónde vendrían los patrones de salida deseados? ¿Cómo podría el cerebro de un infante llevar a cabo la autoorganización que se ha demostrado ocurre en el desarrollo temprano?.

El desarrollo no supervisado es un modelo mucho más pausible de aprendizaje en un sistema biológico. Desarrollado por Kohonen (1984) y muchos otros, no requieren de un vector objetivo para las salidas, y de aquí, no hay comparaciones predeterminadas para respuestas ideales. El conjunto de entrenamiento consiste solamente de vectores de entrada. El algoritmo de entrenamiento modifica los pesos de la red para producir vectores de salida que sean consistentes; esto es tanto la aplicación de un vector de entrenamiento o un vector que es suficientemente similar a él producirá el mismo patrón de salidas.

El proceso de entrenamiento, así , extrae las propiedades estadísticas del conjunto de entrenamiento y agrupa vectores similares en clases. Aplicando un vector de una clase dada a la entrada producirá un especifico vector de salida, pero no hay manera de determinar antes del entrenamiento cuál especifico patrón de salida será producido por una clase dada de vector de entrada. De aquí, las salidas de tal red deben generalmente ser transformadas a una forma comprensiva subsecuente al proceso de entrenamiento. Esto no representa un problema serio. Es comúnmente un simple asunto de identificar las relaciones de entrada - salida establecidas por la red.

ALGORI!IMOS DE EN!IXENAMIEN!TO Muchos de los algoritmos de entrenamiento de hoy día han evolucionado de l o s conceptos de D.O. Hebb (1961). El propuso un modelo para aprendizaje no supervisado en el cual la fuerza sináptica (Peso) es amplificado si tanto la fuente como el destino (neuronas) son activadas.En ésta forma, los caminos más usados en la red eran reforzados, y el fenómeno del hábito y aprendizaje a través de la representación era explicado.

Una red neuronal artificial utilizando aprendizaje Hebbiano incrementará sus pesos de Red de acuerdo al producto de los niveles de excitación de las neuronas fuentes y destino. En símbolos:

donde Wij(n) = El valor de un peso de una neurona i, hacia una neurona j antes del ajuste. Wij(n+l)= El valor del Peso desde la neurona i, a la neurona j después del ajuste. b = coeficiente de aprendizaje.

18

OUT i = La salida de la neurona i. OUT j = La salida de la neurona j.

Se han construido redes que utilizan el aprendizaje Hebbiano, sin embargo, se han desarrollado algoritmos más efectivos en los últimos 20 años. En particular el trabajo de Rosenblatt (1962). Widrow (1959), Widrow y Hoff (1960), y muchos otros desarrollaron algoritmos de entrenamiento supervisado, produciendo redes que aprendieron un amplio rango de patrones de entrada, y más altos niveles de aprendizaje, que lo que podrían haber hecho con un simple algoritmo Hebbiano. Existen una tremenda variedad de algoritmos de entrenamiento en uso hoy día; sería necesario más espacio que éste para darnos un tratamiento completo de éste tópico.

19

CAPITULO 4 RECONOCIMIENTO DE PATRONES

(ADALINE )

Que sea s e n c i l l o ; l o más s e n c i l l o p o s i b l e , pero no más.

Albert E i n s t e i n .

ADALINE En este capitulo, nos centraremos en el estudio del algoritmo utilizado en Adaline (Adaptive Linear Elements) desarrollado por Bernand Widrow de la Universidad de Stanford. Adaline e s una estructura propuesta y modificada por Mariko Nakano para el reconocimiento de Caracteres. Está estructura propuesta consiste de N Elementos Adaptativos lineales (ADALINE) operando en paralelo, y una SubRed la cual determina el máximo de todas las salidas de ADALINE.

ALGORI- El algoritmo de Entrenamiento consiste en lo siguiente: Primero un Patrón (en este caso un dígito cualquiera entre 0-9) que consiste de M pixeles es presentado a la entrada de ADALINE, como se muestra en la figura 4.1. Esta RED produce entonces N salidas, Y k , dado por:

T Y k = H k (n) A(n) ; (k= o , . . .N-I) . . . . . . . . . . (1)

T Donde H . k (n) = Es el K-esimo coeficiente del vector de ADALINE

A (n) = Es el vector de Entrada y N es el posible numero de entradas del Patrón .

I I

a0

al

ak

aM- 1 I 1

ADALINE

fig 4.1

Subsecuentemente las Salidas N de ADALINE son procesadas por una subred la cual selecciona la entrada más grande y entonces determina el elemento o patrón original (reconocimiento). Esto es, si la red ha sido entrenada para detectar caracteres numéricos tales como 0,1,2,3,4,5,6,7,8, y 9; y la salida ADALINE

20

del 6to elemento es el elemento más grande de la Subred, entonces el carácter seleccionado será el carácter 5 como el carácter de Reconocimiento. Esta red tiene un alto grado de paralelismo el cual te permite relativamente una fácil implementación en un array procesado por la Transputer.

ALGORITMO W T A T I V O El algoritmo adaptativo será seleccionado tal que el valor del error cuadratico medio de la salida K-esima de ADALINE , ek (n) (k=O, ..... N-1) es el mínimo, donde :

donde dk(n) = es el K-esima señal de referencia en un instante n y además yk(n) = es dado por la ecuación (1) y es la K-esima salida lineal de ADALINE.

ek (n)= dk(n)- yk(n)

La versión de normalización del algoritmo LMS (Least Mean Square) para adaptar l o s coeficientes del vector Hk es dado por

Hk(ni-1) = Hk(n) + P ek (n) &(n) ...... (3) T

donde Hk (n) = [hk,o ; hk,l ; ......... ; hk,m-1] T

A b ) = [a0 I al , ............ ., am-I] 2

Donde a es el factor de convergencia que controla la estabilidad y la convergencia de la Red. Si el factor es más grande o igual a uno entonces el reconocimiento de los patrones de la Red será muy bajo, en cambio si el valor es pequeño el reconocimiento será más acertado pero convergerá muy lentamente.

SIMULACI~N Para la simulación de esta Red Artificial tenemos las siguientes fases : ENTRENAMIENTO : Esta fase se realizó utilizando una Tarjeta ( TRANSPUTER ) para el entrenamiento en paralelo de la Red, tomando un archivo donde había 500 imagenes (generados con la herramienta que Desarrolle para generar imagenes). Las 500 imagenes tienen 50 ceros, 50 unos ,....,y 50 nueves, cada uno escritos en diferente forma y posición. El algoritmo de entrenamiento se escribió de manera que Primero hace un preprocesamiento del patrón tomando la Transformada de Fourier en Magnitud y en Fase; y con estos coeficientes se van adaptando los pesos o valores de Reconocimiento de la Red Artificial.

RECONOCIMIENTO: Esta fase se realizó en DOS, simplemente dando como entrada un archivo binario (cualquier archivo .DAT), el cual contiene el patrón que se desea reconocer. Mostrando a l a salida el patrón que esta reconociendo la Red Artificial. Aqui use 3 tipos de archivos imagen. Uno es con los numeros normales, otro con los numeros con "ruido" (con Basura en la imagen) y finalmente un archivo con un cero asi a-

21

I . AEWENDO IMA -AMA NUEVA PARA DIBUJAR u14 P A ~ N Esta es l a primera pantalla que aparecer& para poder empezar a dibujar las patrones. Para lograr esto Primero en el menú de archivo se seleccionó la opción Generar.

2. DXBUJAMtXl WN P&H

el botón izquierdo sobre alguna celda. Tambib puede borrar cualquier punto ya dibujado volviendo a presionar con el b o t h izquierdo el punto que desea borrar.

Para poder dibujar una imagen con el ratón, presione

22

3. c.zm#mmw~~moNARcHIvo dialogo Salvar Coano.

Seleccionar el bot6n NUEVO, donde saldr6 la ca ja de

I Df51TO DE

23

Archiva en:

PRESIONE Fast: ACTUALIW ARcBm "lTPST.'"

I

24

25

CAPITULO 5 RED NEURONAL DE KOHONEN

Todos los hombres corren el riesgo de cometer Errores, y la mayoría, por Pasión, se sienten con l a tentación de hacerlo.

John Locke Ensayo sobre el entendimiento humano.

INZUODWCCI~N El motivo por el cual incluyo este caso de estudio es porque originalmente no se tenía planteado desarrollar esta red neuronal, sin embargo, debido a que la mayoría de las redes neuronales siguen las mismas fases ( véase el capitulo 2 en la sección MODELO ABSTRACTO ) y solo cambia el algoritmo de entrenamiento, solo incluyo el algoritmo de entrenamiento así como las Estructuras de Datos. Esta red Neuronal es una de las difíciles de desarrollar, sin embargo, es una de las más interesantes ya que sigue el modelo de operación de la forma de trabajar del Cerebro.

PROCESAMIENTO DE DATOS EN SOM ( S e l f -Organizing mps) Kohonen desarrollo una manera fácil para ilustrar la dinámica de los procesos de aprendizaje. En lugar de trazar la posición de los elementos de procesamiento de acuerdo a su posición física , podremos trazarlos de acuerdo a su locación del espacio de pesos. Nosotros entonces dibujaremos líneas conectadas entre unidades que están cercas físicamente; la figura 5.1 ilustrar esta idea.

wv Cada unidad es Identificada por 2 conjuntos

fisicas en el espacio [u,v]p y (modHimble) coordenadas espaciales de Peso sobre el el espacio w u , w p . Un trazo es hecho de puntos de acuerdo a su posicidn sobre el el espacio de Peso. Las unidades se juntan por líneas de acuerdo a su poslcion en el

(O.l]p y (l.O]p serán conectadas como se muestran con la linea aruesa.

(0.11 P de coordenadas : [Ordenas] coordenadas

L&? IO.0lP espacio fisico. Las unidades vecinas [O,O]p

> w u

Estamos asumiendo en toda esta discusión que los puntos de entrada son seleccionados aleatoriamente desde un conjunto distribuido uniformemente dentro de un área rectangular ocupada por elementos de procesamiento. Suponemos que los puntos de entrada fueron seleccionados desde una distribución diferente, En este ejemplo, los puntos de entrada son seleccionados desde una uniforme distribución triangular. Los mismos elementos de procesamiento están estáticamente en un arreglo bidimensional, pero los pesos forman un mapa de la región triangular. Recordando que las unidades no cambian sus posiciones físicas durante el entrenamiento.

En la introducción dada anteriormente se hablo del uso del SOM para trabajar una reducción dimensional en los datos de entrada

26

para mapear vectores de entrada de gran dimensión dentro de mapas bimensionales. Nosotros podemos ilustrar esta idea gráficamente mapeando una región bidimensional de puntos dentro de un arreglo unidimensional de elementos de procesamiento. El caso para dos diferentes distribuciones de puntos de entrada. Recuerde que l o s vectores de entrada y de peso son bidimensionales, donde la posición física de cada elemento de procesamiento esta en un arreglo unidimensional. Todos nuestros ejemplos para este punto han usado puntos de entrada que están uniformemente distribuidos dentro de alguna región. Los puntos de entrada pueden estar distribuidos de acuerdo alguna función de distribución. Una vez que SOM ha sido entrenado los vectores de peso serán organizados dentro de una aproximación de la función de distribución de vectores de entrada. Esto en términos formales es:

La función de densidad puntual de los vectores de Peso tiende a aproximarse a la función de densidad probabilistica p(x)de l o s vectores de entrada, x, y l o s vectores de peso tienden a ordenarse de acuerdo a similitudes mutuas de ellos."

CARACTERÍSTICAS DEL MAPA CLASIFICADOR Una ventaja del SOM es que aquellos numeros largos de datos sin etiqueta pueden ser organizados rápidamente dentro una configuración que aquel podría llenar la estructura fundamental con los datos. Siguiendo el proceso de auto-organización este puede estar deseablemente asociar ciertas entradas con ciertos valores de salida, tal como lo son dados en Backpropagation y counterpropagation. La arquitectura del SOM puede ser entendida por adición de una capa asociativa. Nosotros nos referimos a esta estructura como un Mapa clasificador de características(FMC). Las unidades sobre la capa de salida pueden ser entrenadas por diversos métodos incluyendo la Regla de Delta o por el procedimiento de OUTSTAR . Un método alternativo es el llamado MAXIMUM LIKELIHOOD TRAINING.

I' capa de Salida

El SOM adua CDIIIO una red competitiva que clasifica IDS vectctres de entrada

27

SIMUUCIÓN DEL SOM Tal como vimos, el SOM es relativamente una red sin complicaciones en el que esta s o l o puede tener 2 capas de unidades. Por lo tanto, la simulación de esta red puede no imponer la capacidad de las estructuras de datos de la red general con los cuales estamos familiarizados. El SOM, sin embargo, adiciona al menos una curva interesante de la noción de las estructuras de las capas usadas por mas de otras redes; esta es la primera vez que nosotros tenemos un trato con una capa de unidades que se organizan como una matriz bidimensional, que más bien como un vector unidimensional. Acomodando esta nueva dimensión, nosotros podemos descomponer la matriz conceptualmente dentro de un simple vector conteniendo todos l o s renglones de vectores de la matriz original. Como podemos ver en la sig discusión, esta descomposición de la matriz nos permite la simulación del SOM implementarla con el mínimo de modificaciones para estructuras de datos generales.

LA ESTRUCTURA DE DATOS DEL SOM Desde nuestra discusión teórica, nosotros conocemos que el SOM es una estructura de 2 capas de red, con un simple vector de unidades de entrada proveyendo estimulación a un arreglo rectangular de unidades de salida. Además, unidades en la capa de salida están interconectadas para permitir inhibición y excitación lateral. Esta estructura de la red podría complicar la simulación si nosotros ensayamos la red precisamente como la ilustramos, porque tendríamos que iterar con el desplazamiento de columnas y renglones de las unidades de salida. Desde que nosotros seleccionamos nuestra estructura de conexiones de red como discreta, arreglos de dimensiones sencillas accediendo através de un arreglo intermedio, sin líneas hacia adelante de l o s recursos definiendo una matriz de arreglos de conexiones sin modificar la estructura más general de la red. Podemos, sin embargo, reducir la complejidad de la tarea de simulación por el desempacamiento conceptualmente de la matriz de las unidades sobre la capa de salida, reordenandolas como una simple capa de unidades organizadas como un largo vector compuesto de la concatenación de los vectores de renglón original. Así teniendo esto, Tendremos reestructurado la red tal que esto se asemeja más a la estructura de 2 capas. Tal como vimos los beneficios de la reestructuración de la red de esta manera nos permitirá la localización, actualización, de l o s alrededores vecinos de la unidad Ganadora en competición. Si observamos también que las conexiones entre las unidades sobre la capa de salida pueden ser simuladas en un sistema de computadora con una determinación algoritmica de la unidad ganadora (y de la vecindad asociada), podemos reducir el modelo de procesamiento del SOM a una simple de dos capas , retroalimentación hacia adelante. Así tenemos el siguiente registro:

RECORD Layer= Salida: "float[] ; / / Apuntador a las unidades de salida. Peso: ""float[] ; / / Apuntador a los pesos de la capa. END ;

28

RECORD SOM= ROWS: inteqer / / Numero de renglones en la Capa de Salida. COL: integer / / 10 mismo para las columnas. INPUTS:^Layer //Apuntador a la estructura de Capa de Entrada 0UTPUTS:"Layer //pointer to outputlayer structure WINNER: integer //indice de la unidad ganadora. DeltaR: integer //Desplazamiento del renglón vecino DeltaC: integer //Desplazamiento de la columna vecina Time: Integer //Tiempo de paso Discreto. END ;

ALGORI!IMOS DEL SOM Pondremos nuestra atención al proceso de implementación del simulador del SOM.Comenzaremos con los algoritmos necesarios para propagar la información através de la red y concluiremos esta sección describiendo los algoritmos de entrenamiento.

PROPAGACI~N DE LA SE- EN EL SOM Veremos un recurso viable de la competición implementada,igual que este es el método básico de las unidades de salida estimuladas en el SOM. En el SOM, la capa de entrada es provista solo para guardar el vector de entrada. Por esta razón, podemos considerar el proceso de propagación de la señal hacia adelante una manera de permitir a la computadora visitar todas las unidades de la capa de salida secuencialmente. Desde cada unidad de la capa de salida la computadora calcula la magnitud del vector de diferencia entre la capa de salida de la capa de entrada y el vector de peso formado por la conexión entre la capa de entrada y la unidad concurrente. Después de terminar los cálculos, la magnitud será guardada, y la computadora podrá moverse a la siguiente unidad de la capa. Una vez que todas las capas han sido procesadas la propagación de la señal hacia adelante termina, y la salida de la red será la matriz conteniendo la magnitud del vector de diferencia para cada unidad en la capa de salida. Si también consideramos el proceso de entrenamiento,podremos permitir a la computadora guardar localmente un índice(apuntador) a la localización de la unidad de salida que tiene una pequeña magnitud del vector de diferencia durante el paso inicial. Aquel índice puede ser usado para identificar la unidad ganadora de la competición. Adoptando esta aproximación podremos usar la rutina usada para la señal de propagación hacia adelante en el SOM durante el entrenamiento (paralelamente! !)sin modificaciones. Basada en esta estrategia, definiremos el algoritmo de la señal de propagación delantera como una combinación de dos rutinas: 1 Una computa la diferencia del vector de magnitud para una unidad especifica de la capa de salida, 2 y una llamada a la primera para cada unidad de la capa de salida. Llamando a estas rutinas como PROP y PROPAGATE respectivamente Comenzaremos la codificación.

29

//Calcula la magnitud del vector de diferencia para UNIT.

FUNCI~N PROP(NET:SOM ; UNIT :integer) : regresa Float var invec,connect:"float[]; //Arrrglo local

sum,mag:float; / / Var temporal i:integer; / / Contador

BEGIN invec = NET."INPUT."Salida; //Vector de entrada LOCAL connect = NET.AOUTPUTS."Peso[UNIT]; //CONCESI6N sum=o ;

for i=l to lengt(invec) //Para todas las entradas

return (mag=sqrt(sum)); //calcula magnitud end;

sum+=sqr (invec [i] -connect [ i] ) ; //diferencia sqr

Ahora que podemos calcular el valor de salida para una unidad sobre la capa de salida, ahora consideraremos la rutina que genera la salida para la RED Entera. Así tenemos el pseudocodigo para nuestra RED SOM definida de 2 capas.

/ / Propagación hacia adelante atraves del SOM,regresa el fNDICE del ganador Función Propagate (Net: SOM) return integer var Outvec : float [ I ; //Arreglo local de salida

winner : integer ; //Unidad ganadora. smal1,mag : float ; //Variables Temporales i : integer //Contador

BEGIN Outvec=Net.Ouputs".Salida"; //Arreglo local winner=O; / / Inicializamos al ganador small = 10000 //Arbitrariamente Grandisirno for (i=l;i<=length(Outvec) ;i++)//Para todas las salidas

comienza mag=PROP(Net, i); //Unidad Activa Outvec [i] =mag; //Salvar salida Si(Mag < Small ) //Si(un nuevo ganador es encontrado) com winner=i; //Marcar al nuevo ganador small=mag / / Salvar el valor ganador

fin fin For

Net.Wi&er= winner; regresa(winner);

END Función;

30

ALWRIZMOS DE APRENDIZAJE PARA SOM

de la señal en el SOM, implementaremos el problema del entrenamiento de la RED. Teniendo la formula ya estudiada : Wi(t+l)= { wi(t)+ Alfa(t) (x-wi(t)) i E Nc

que actualiza las conexiones del conjunto de salida que Caen dentro de la vecindad de la unidad ganadora,tenemos que esta es la ecuación de Aprendizaje. Nosotros tenemos que implementar l o s recursos para determinar el Ganador como parte de la propagación de la señal hacia adelante.Desafortunadamente, el proceso para determinar los limites vecinales de la unidad ganadora es probablemente dependiente de la aplicación, ya que habrá problemas que requieran determinar el mas adecuado de los tamaños de la vecindad para cada aplicación. Sin embargo, desarrollaremos el código necesario para describir una función de Selección Vecinal. Por simplicidad, diseñaremos el proceso en 2 funciones :La primera regresará verdadero o falso que indicara si una cierta unidad esta dentro de la vecindad de la unidad ganadora en el tiempo actual y el segundo actualizara loa valores de conexión de la unidad de salida, si la unidad caen dentro de la región de la unidad ganadora. La primera rutina, la cual llamaremos NEIGHBOR, regresara una bandera si las coordenadas de la columna y renglón de la unidad dada como entrada caen dentro del rango de unidades para ser actualizadas.Este proceso trabaja siguiendo 2 pruebas de chequeo que son

Ahora que ya se ha desarrollado el trabajo de la propagación

O Otro caso

(Rw-OffsetR) <= R <= (Rw+OffsetR) (Cw-OffsetR) <= C <= (Cw+OffsetC)

donde (Rw,Cw) son el Renglón y columna de la unidad Ganadora y (OffsetR,OffsetC) son el desplazamiento que define la unidad ganadora ha sus vecinas.

Para poder implantar este mecanismo de determinación de Región Circundante a una unidad ganadora, nosotros implementamos 2 variables llamadas DeltaR y DeltaC, los cuales nos permiten guardar los valores de los términos OffsetR y OffsetC. Teniendo esta observación tenemos la Función NEIGHBOR (Vecindad)

/ / Regresa Verdad si (R,C) esta cercas de W (unidad ganadora)

Función NEIGHBOR (Net :SOM ; R,C,W: integer) regresa Boolean var row, col, //Coordenadas para la ganadora

Off setRl, Off setCl, / / Coordenadas del limite inferior OffsetR2,OffsetCZ: integer//Coordenadas del limite superior

Comienza row=(W-l)/Net.Cols;//Convierte índice de unidad ganadora a Renglón col=(W-1) % Net.Cols; / / Encontrar columna ganadora OffsetRl=MAX(l, (row-Net.DeltaR) ) ; OffsetR2=MIN(Net,Rows, (row+Net.DeltaR)); OffsetCl=MAX(l, (col-Net.DeltaC) ) ; OffsetCZ=MIN(Net.COLS, (col+Net.DeltaC)); regresa ( ((OffsetRl<= R )&&(R<=OffsetRZ)) & &

Fin Función ((OffsetCl<= C )&&(C<=OffsetCZ)) )

31

Ahora que hemos determinado si la unidad esta o no en una región cercana a la unidad ganadora, tenemos que implementar el algoritmo para actualizar los pesos de todas aquellas unidades que se requieran actualizar. Diseñaremos este algoritmo regresando el numero de la unidad actualiza en el SOM. También para simplificar las cosas el Termino Alfa(t) que participa en la ecuación de Aprendizaje es considerada una pequeña constante, que una función del tiempo.

En el pseudocodigo esta constante aparece como Alfa. / / Actualiza todos los pesos de las unidades ganadoras, / / regresando el numero de la unidades actualizadas

Función Update(Net :SOM ) regresa Integer const Alfa :float = 0.3 //Constante de Activación var winner,unidad,updated:integer;//fndices a unidades de salida

invec : "float [ I //Arreglo de Unidad de salida Local conexión: "float[] //Arreglo de conexión Local i, j, k : integer //Contadores

comienza winner=Propagate(NET); //Propagar y encontrar Ganador Unidad=l; //iniciar en la primera unidad de Salida Updated=O; / / Aun no Actualizar nada for (i=l;i<=Net.Rows; i++) / / Para todas los renglones for (j=l; j<=Net.Cols; j++) / / Para todas las columnas Comienza

if (NEIGHBORN (Net, i, j ,winner) ) Comienza

//Primero coloca el apropiado arreglo de conexión

/entonces coloca el arreglo de salida de la capa de entrada conexion=Net.OutputsA.Peso"[unidad] ;

invec=Net.INPUTS".Salida; updated++; / / Cuenta otra actualización for (K=l;K<=length(conexión);K++)

/ / para todas las conexiones conexión [ k] += (Alfa* (invec [K] -conexión [K] ) ) ;

fin If

fin for0 unTdad++; //acceso a la siguiente unidad

regresa(updated); //regresa numero de actualizaciones Fin Función

ENlTRENAMIENTO DEL SOM En el proceso de entrenamiento se necesita saber Como y cuando decidir colapsar la región ganadora.Asi como esté es un aspecto de diseño, probablemente influenciado por la aplicación, resolvimos esto para la simulación del SOM que la cada una de las unidades de la capa de salida sería asociado a un especifico vector de entrada. Para el algoritmo SOM,existen 2 fases.En primera,el entrenamiento de la red se detiene hasta encontrar una unidad Ganadora.Para la segunda fase ,ocurre después de que todos los los patrones de entrenamiento han sido alojados a una unidad ganadora,se continua el entrenamiento ( un numero arbitrario de

32

ciclos ) para garantizar la estabilidad de la red. Así Tenemos el Algoritmo Principal.

//Entrenamiento de la Red Para NP Patrones

Proc Train(Net:SOM; NP :integer) comienza inicializa (NET) ; for (i=l ;i<=NP; i++)//Para todos los patrones de entrenamiento comienza Net.deltaR=Net.Rows/Z ; //Inicializar el renglón offset Net.deltaC=Net.Cols/2 ;//Inicializar la columna offset Net.Time=O ; / / Resetear tiempo set entrada (NET, i) I //Obtener patrón de entrenamiento while (UPDATE (NET) >1 ) //Repite hasta que haya un ganador

comienza Net.Time++; //Avanza Entrenamiento

//si se acorta el tiempo entonces acorta la región con referencia a (O, O)

If (Net.Time % NumPatron? = O) comienza

Net.deltaR=MAX(O,Net.deltaR-1) ; Net.deltaC=MAX(O,Net.deltaC-1) ;

fin If fin while

fin for -

//moraque todos tiene un ganador el entrenamiento sigue

for(j=l;j<=NP;j++)//Para todos los patrones de entrenamiento for(i=l; i<=aleatorio; i++)

set entradas(Net,j) ; //conjunto de patrones de entrenamiento d"y=update (NET) ; //Entrena red

end for end-for End-Proc.

33

CODIGO FUENTE DEL GENERADOR DE IMÁGENES (GENERATE.C)

#include "general.h" #include "globales. h" #include "GENERATJ2.h" #include "fR.h" //ARCHIVO QUE CALCULA LA TRANSFORMADA DE FOURIER (MAGNITUD Y FASE)

Struct Stat Filestatus; //ESTRUCTURA PARA ABRIR Y RETENER EL DESCRIPTOR DE ARCHIVOS Char FileName[ 1281; //NOMBRE DEL ARCHIVO DONDE SE GUARDARÁ LAS IMAGENES char PathName[ 1281; //DIRECTORIO DONDE SE GUARDARA char Numero[ 1281; char Formato[l28]; char OpenName[l28]; char DefPath[ 1281; char DefSpec[l3] = I**.*";

char DefExt[] = ".dat"; //EXTENSION POR DEFAULT PARA LA IMAGEN BINARIA

typedef struct MDI_FPl{ BOOL fStatewl][N2]; int numwindow; char *arch; char * formato; BOOL bsave; 1 MDI-FP;

typedef MDI-FP NEAR * MDI-Private;

ff .............................

char str[255];

long FAR PASCAL MainWndProc (HWND, WORD, WORD, LONG) ; BOOL FAR PASCAL -export AboutDlgProc (HWND, WORD, WORD, LONG) ; BOOL FAR PASCAL -export UPDATEMsgProc (HWND, WORD, WORD, LONG) ; void SeparateFile(HWND, LPSTR, LPSTR, LPSTR); void UpdateListBox(HWND); void SetNewBufTer(HWND, HANDLE, PSTR); void AddExt(PSTR, PSTR); void ChangeDefExt(PSTR, PSTR); BOOL CheckFileName(HWND hWnd,PSTR pDest, PSTR pSrc); long FAR PASCAL, -export RectWndProc (HWND hwnd, WORD message, WORD wParam,LONG Param) ; BOOL FAR PASCAL -export CloseEnumProc (HWND hwnd, LONG Param); int FAR PASCAL SaveAsDlg(HWND hDlg,unsigned message,WORD wParam,LONG Param); BOOL SaveFile(HWND hWnd,BOOL fState[Nl][N2],char *Formato-FP,char *FileName-FP ,int SalvaTipo); int FAR PASCAL FastDlg(HWND hDlg,unsigned message,WORD wParam,LONG lParam); PSTR ExtFFT(PSTR Name,char ext[3]) 9

void Tipo(F1LE *fpl,char *Formato,char *Numero);

// GLOBAL VARIABLES

static char szAppName [I = "GENERATEITOOL" ; static HWND hDlgModeless ; HANDLE hnet; int Ven= 1;

34

char szRectClass [I = "MdiRectChild" ; HMENU hMenuInit, hMenuRect ; HMENU hMenuInitWindow, hMenüRectWindow ; HANDLE Nnst ;

int PASCAL WinMain (HANDLE hInstance, HANDLE Wrevhstauce,

LPSTR IpszCmdLine, int nCmdShow) { MSG msg; HWND hwnd,hwndClient ; HANDLE hAccel ; WNDCLASS wndclass ; FARPROC 1pProcAbout ; int i j ;

Nnst = hlnstance ; if ( ! hPrevInstance)

{ wndclass.style = CS-HREDRAW I CS-VREDRAW ; wndclass.1pfnWndProc =MainWndProc ; wndclass.cbC1sExtra = O ; wndclasscbWndExtra = O ; wndclass.hInstance = Nnstance ; wndclass.Ncon = LoadIcon (Nnstance, szAppName) ; wndclass.hCursor = Loadcursor (NULL, IDC-ARROW) ; wndc1ass.hbrBackground = Getstockobject (WHITE-BRUSH) ; wndclass.lpszMenuName = NULL ; wndclass.lpszC1assName = szAppName ; Registerclass (&wndclass) ;

/I REGISTAR LA CLASE PRINCIPAL DE LA VENTANA HIJA

wndclass.sty1e = CS-WDRAW 1 CS-VREDRAW ; wndclass.1pfnWndProc = RectWndProc ; wndclass.cbC1sExtra = O ; wndc1ass.cbWndExtra = sizeof(L0CALHANDLE) ; // APUNTADOR AL HEAP

wndc1ass.hInstance = Nnstance ; wndclass.hIcon = LoadIcon (Nnstance, szRectClass) ; ; wndclass.hCursor = Loadcursor (NULL, IDC-ARROW) ; wndc1ass.hbrBackground = Getstockobject (WHITE-BRUSH) ; wndclass.1pszMenuName = NULL ; wndclass.lpszClassName = szRectClass ;

//PRIVADO DE LA VENTANA

Registerclass (&wndclass) ; >

/I CARGAR MENUS hMenuInit = LoadMenu (Nnstance, "PopPad") ; hMenuRect = LoadMenu (Nnstance, "MdiMenuRect") ; hMenuInitWindow = GetSubMenu (hMenuInit, INIT-MENu_POS) ; hMenuRectWindow = GetSubMenu (hMenuRect, RECT"ENU_POS) ; hwnd = Createwindow (szAppName, "ADALINE - GENERADOR DE IMAGENES",

WS-OVERLAPPEDWINDOW I WS-CLIPCHILDREN, CW-USEDEFAULT, CW-USEDEFAULT, CW-USEDEFAULT, CW-USEDEFAULT, NULL, hMenuInit, Mnstance, NULL) ;

35

hwndclient = Getwindow (hwnd, GW-CHILD) ;

//CARGAR CURSOR DE ARENA PARA USARSE DURANTE LA TRANSFERENCIA DE // ARCHIVOS O DE ESPERA DE INFORMACION hHourGlass = LoadCursor(NULL, IDC-WAIT); ShowWindow(hwnd,nCmdShow); Updatewindow (hwnd); hAccel = LoadAccelerators (Nnstance, szAppName) ; while (GetMessage (Lmsg, NULL, O, O))

{ if(hDlgMode1ess == NULL 11 !IsDialogMessage (hDlgModeless, &msg))

{ if (!TranslateAccelerator (hwnd, hAccel, &m@)

{ TranslateMessage (&msg) ; DispatchMessage (&m@ ; 1

1 1

DestroyMenu (hMenuRect) ; return msg.wParam ;

1 I* *I

long FAR PASCAL MainWndProc (HWND hwnd, WORD message, WORD wParam,LONG Waram)(

static FARPROC 1pfnAboutDlgProc ; FARPROC IpOpenDlg; F M R O C lpfnEnum ; int i,k& static HWND hwndclient ; CLIENTCREATESTRUCT clientcreate ; HWND hwndChild ; MDICREATESTRUCT mdicreate ;

switch (message) { case WM-CREATE: // MENSAJE QUE SE PROCESA DURANTE LA CREACION DE LA VENTANA

clientcreate.hWindowMenu = hMenuInitWindow ; clientcreate.idFirstChi1d = IDM-FIRSTCHILD ; hwndclient = Createwindow ("MDICLIENT", NULL,

WS-CHILD I WS-CLIPCHILDREN I WS-VISIBLE, O, O, O, O, hwnd, 1, hInst, (LPSTR) &clientcreate) ;

return O ;

case WM-COMMAND : switch (wparam)

{ case IDM-NEWGENERATE: case IDM-GEN: // CREAR UNA VENTANA HIJA

mdicreate.szClass = szRectClass ; mdicreate.szTitle = "GENERATE" ; mdicreate.hOwner = hInst ; mdicreate.x = CW-USEDEFAULT ; mdicreate.y = CW-USEDEFAULT ; mdicreatexx = CW-USEDEFAULT ;

36

mdicreateq = CW-USEDEFAULT ; mdicreatestyle = O ; mdicreate.Param = NULL ;

hwndChild = (HWND) SendMessage (hwndclient, WM-MDICREATE, O, (long) (LPMDICREATESTRUCT) &mdicreate) ;

return O ;

case DM-HELP: sprintf(str,”No esta implementada la ayuda”);

MessageBox(hwnd, str, NULL,MB-OK I MB-ICONHAND); return O;

case DM-ABOUT: 1pfnAboutDlgProc = MakeProcInstance ((FARPROC) AboutDlgProc, hInst) ;

DialogBox (hInst, “AboutBox”, hwnd, IpfnAboutDlgProc); return O ;

hwndChild = LOWORD (SendMessage (hwndclient, WM-MDIGETACTIVE, O, OL)) ;

if (SendMessage (hwndchild, WM_QUERYENDSESSION, O, OL))

case DM-CLOSE:

SendMessage (hwndclient, WM-MDDESTROY,

Ven-- ; hwndchild, OL) ;

return O ;

case DM-EXIT: //SALIR DEL PROGRAMA

SendMessage (hwnd, WM-CLOSE, O, OL) ; return O ;

I / MENSAJE PARA ARREGLAR LAS VENTANAS case DM-TILE:

SendMessage (hwndclient, WM-MDITILE, O, OL) ; return O ;

case DM-CASCADE: SendMessage (hwndclient, WM-MDICASCADE, O, OL) ; return O ;

case DM-ARRANGE: SendMessage (hwndclient, WM-MDIICONARRANGE, O, OL) ; return O ;

Case DM-CLOSEA.LL: //CERRAR TODAS LAS VENTANAS Ven= 1 ;

lpfnEnum = MakeProcInstance ((FARPROC) CloseEnumProc ,hInst) ; EnumChildWindows (hwndclient, IpfnEnum, OL) ; FreeProcInstance (IpfnEnum) ; return O ;

default: // PASAR EL FOCO A LA VENTANA HIJA

hwndChild = LOWORD (SendMessage (hwndclient, WM-MDIGETACTIVE, O, OL)) ;

if (Iswindow (hwndchild))

37

SendMessage (hwndchild, WM-COMMAND, wParam, Param) ;

break ; //AND THEN TO DEFFRAMEPROC

I break ;

case W-QUERYFNDSESSION: case WM-CLOSE: // CERRAR TODAS LAS VENTANAS

SendMessage (hwnd, WM-COMMAND, DM-CLOSEALL, OL) ;

if (NUL,L != Getwindow (hwndclient, GW-CHILD)) return O ;

break ; N IE, LLAMAR DEFFRAMEPROC

case WM-DESTROY : PostQuitMessage (O) ; return O ;

I // PASAR EL MENSAJE NO PROCESADO A DEFFRAMEPROC (NO ES DEFWINDOWROC)

return DefFrameProc (hwnd, hwndclient, message, wParam, lParam) ; I

void Docaption (HWND hwnd,char * Title) { char szCaption [64 ] ;

wsprintf (szcaption, "%S - Yd", (LPSTR) Title,Ven++) ;

SetWindowText (hwnd, szcaption) ; 1

long FAR PASCAL -export RectWodProc (EIWND hwnd, WORD message, WORD wParam,

LONG Waram) { static HWND hwndclient, hwndFrame,hwndList[4] ; LOCALHANDLE Wrivate; MDIPrivate IWprivate ; HDC hdc; WEN Brush; RECT rect,rectOld ; PAINTSTRUCT ps ; register int ij,y,x; TEXTMETRIC t m ;

switch (message) { case WM-CREATE:

hwndclient = GetParent (hwnd) ; hwndFrame = GetParent (hwndclient) ;

38

hdc = GetDC (hwnd) ; Selectobject (hdc, Getstockobject (SYSTEM-FONT)) ; GetTextMetrics (hdc, &tm) ; ReleaseDC (hwnd, hdc) ;

rect.left = 5 * tm.tmAveCharWidth ; rect.top = 2 * tm.tmHeight ;

hwndList[O] = Createwindow ("Button", "&Nuevo", WS-CHILDWINDOW I WS-VISIBLE I BS-PUSHBUTTON, 200,2, 2*rect.left, 3 * rect.top 14, hwnd, O, Nnst, NULL) ;

WS-CHILDWINDOW I WS-VISIBLE I BS-PUSHBUTTON, 200, (3 * rect.top 1 4 )+2,

2*rect.left, 3 * rect.top 14, hwnd, 1, Nnst, NULL) ;

WS-CHILDWINDOW I WS-VISIBLE I BSPUSHBU'ITON, 200, 2*(3 * rect.top 14 )+4, 2*rect.lefV2,3 * rect.top 14, hwnd, 2, Nnst, NULL) ;

WS-CHILDWINDOW I WS-VISIBLE I BS-PUSHBUTTON, 200+ rect.left, 2*(3 * rect.top 1 4 )+4, 2*rect.left/2, 3 * rect.top 14, hwnd, 3 , hInst, NULL) ;

hwn&ist[ 11 = Createwindow ("Button", "&Actualiza",

hwndlist[2] = Createwindow ("Button'*, "F&ast",

hwndList[3] = Createwindow ("Button", "C&lear",

DoCaption (hwnd,"GENEF¿ATE"); hPrivate =LocalAlloc(LMEM-MOVEABLE I LMEM-ZERONT,sizeof(MDI-FP)) ;

NPprivate->arch=NULL; NPprivate->bsave=FALSE; NPprivate->formato=""; NPprivate->numwindow=Ven- 1; LocalUnlock(hPrivate);

NPpriVate=(MDI-PriVatte) LocalLock(hPrivate) ; //NEAR POINTER PRIVATE

SetWindowWord(hwnd,O,hPrivate) ;//APUNTAR AL ARBOL DEL HEAP

return O ; case WM-COMMAND:

hPrivate=GetWindowWord(hwnd,O); NPprivate=(MDI-Private) LocalLock(hPrivate) ; / / N E A R POINTER PRIVATE switch(wParam) {

{ Case 1 : //UPDATE

FARPROC IpfnUPDATEMsgProc;

1pfnUPDATEMsgProc = MakeProcInstance((FAROC)UPDATEMsgPrw, Nnst); i=DialogBox(hInst,"UPDATE", hwnd, IpfnWDATEMsgProc); FreeProcInstance(1pfnUPDATEMsgProc); if

NPprivate->arch=strdup((char * )FileName); NPprivate->formato=Formato;

sprintf(str, < Y' > Archivo - Y'",NPprivate->numwindow, NPprivate->arch); 39

SetWindowText(hwnd, str); SaveFile(hwnd,NPprivate->fState,NPprivate->formato, NPprivate->arch,Update);

1 1

break; case O: { //New File

FARPROC IpSaveAsDlg;

1pSaveAsDlg = MakeProcInstance(SaveAsDlg, hInst); i = DiaIogBox(hInst, "Saveas", hwnd, IpSaveAsDlg); FreeProcInstance(lpSaveAsD1g); if (i == IDOK) {

NPprivate->arch=strdup((char * )FileName); NPprivate->formato=Formato; sprintf(str, ' Y %d > Archivo - %S'', Npprivate->numwindow,

SetWindowText(hwnd, str); SaveFile(hwnd,NPprivate->fitate, NPprivate->formato, NPprivate->arch,New);

NPprivate->arch);

1 1 break; WSe 2: { //FAST

FARPROC 1pFastDlg; if(NPprivate->bsave==TRUE ){ MessageBox(hwnd, "La imagen ya fue salvada",NULL, MB-OK I

break; 1

if(NPprivate->arch==NULL){ NPprivate->arch=strdup((char * )FileName) ;

SetWindowText(hwnd, str); NPprivate->formato=Formato;

m-ICONHAND);

printf(str, %d > Archivo - %S@', NPprivate->numwindow,NPprivate->arch);

1 1pFastDlg = MakeProcInstance(FastDlg, hInst); DialogBox(hInst, Past", hwnd, IpFastDlg); FreeProcInstance(lpFastD1g);

NPprivate->bsave=TRUE; SaveFile(hwnd,NPprivate->State, NPprivate->formato, NPprivate->arch,Update);

1 break;

Case 3: //CLEAR IMAGEN NPprivate->bsave=FALSE ; for (i=O;i<Nl;i++) for(j=Od<N2j++)

NPprivate->fState[i]u]=O; GetClientRect (hwnd, &rect) ;

InvalidateRect (hwnd, &rect, FALSE) ; break; } I/ switch

LocalUnlock(hprivate); return O ;

case b%í-bfDIACTIVATE: // PONER EL MENU ADECUADO if (WParam = TRUE)

SendMessage (hwndclient, W"I)ISETMENU, O, MAKELONG (hMenuRect, hMenuRectWindow)) ;

40

else SendMessage (hwndclient, WM-MDISETMENU, O,

MAKELONG (Mendnit, MenuInitWindow)) ;

DrawMenuBar (hwndFrame) ; return O ;

case WM-LBUTTONDOWN: bChanges=TRUE; x = LOWORD (Param) ;

y = HIWORD (Param) ;

GetClientRect (hwnd, &re@ ; rectOld.lefi = 20 + rect.lefi ; rectOld.right = 160 + rectOld.lefi ; rectOld.top = 20 + rect.left ; rectOld.bottom = 160+ rectOld.lefi ; hPrivate=GetWindowWord(hwnd,O);

if (x < rectOld.right && y < rectOld.bottom ) NPprivate=(MDI-Private) LucalLock(hPrivate) ; //NEAR POINTER PRIVATE

{ x= (1<<4)-( (rectOld.right -x)/lO)-1; y= (1<<4)-((rectOld.right -y)/lO)-1; NPprivate->fState W[x] A= 1 ; InvalidateRect (hwnd, &rect, FALSE) ;

1 else

MessageBeep (O) ; LocalUnlock(hPrivate);

return O ; case WM-PAINT:

// REPINTAR LA VENTANA hdc = BeginPaint (hwnd, &ps) ; GetClientRect (hwnd, &rea) ; hPrivate=GetWindowWord(hwnd,O); NPprivate=(MDI-Private) LocalLock(hPrivate) ; / M E A R POINTER PRIVATE for (j=O,y=rect.left+20 ; j<(1<<4) ;j++,y+=lO)

for ( i 4 ,x=rect.left+20 ; i<(1<<4) ;i++,x+=lO) {

Rectangle (hdc, x, y ,x+10, y+10) ; if (NPprivate->fState[i] [i])

hdc = GetDC (hwnd) ; Brush = CreateSolidBrush (RGB (128, 128, 128)) ; Selectobject (hdc, Brush) ; Rectangle (hdc, x, y ,x+lO, y+10) ; ReleaseDC (hwnd, hdc) ; Deleteobject (Brush) ;

{

1 1

LocalUnlock(hPrivate); DrawText (hdc, "PATRON", -1, &rect,DT-SINGLELINE I DT-TOP) ; EndPaint (hwnd, &ps) ; return O ;

case WM-DESTROY: LocalFree(hPrivate); return O ;

1

41

// PASAR EL MENSAJE NO PROCESADO A DEFMDICHILDPROC

return DefMDIChildProc (hwnd, message, wParam, lParam) ; 1

int FAR PASCAL SaveAsDlg(hDlg, message, wParam, Param) HWND hDlg; unsigned message; WORD wParam; LONG lParam; {

char TempName[ 1281;

switch (message) { case WM-INITDIALOG:

if (!FileName[O])

else { bSaveEnabled = FALSE;

bSaveEnabled = TRUE; DlgDirList(hDlg, DefPath, NULL, IDC-PATH, 0x4010); SetDlgItemText(hDlg, IDC-EDIT, FileName); SendDlgItemMessage(hDlg, IDC-EDIT, EM-SETSEL, O,

SetDlgItemText(hDlg, IDC-Numero, Numero); SendDlgItemMessage(hDlg, IDC-Numero, EM-SETSEL, O,

SetDlgItemText(hDlg, IDC-Formato, Formato); SendDlgItemMessage(hDlg, IDC-Formato, EM-SETSEL, O,

MAKELONG(O,Ox7fff));

MAKELONG(OYOx7fff));

h4AKELONG(O,Ox7fff)); 1 EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled); SetFocus(GetDlgItem(hDlg, IDC-Numero)); return (FALSE); /" FALSE CUANDO EL FOCO FUE MODIFICADO */

case w"coMh4AND: switch (wParam) {

case IDC-EDIT: if (HIWORD(lParam) == EN-CHANGE && !bSaveEnabled) EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled=TRUE); return (TRUE);

case IDOK: GetDlgItemText(hDlg, IDC-EDIT, TempName, 128); GetDlgItemText(hDlg, IDC-Numero, Numero, 128); GetDlgItemText(hDlg, IDC-Formato, Formato, 128); if(!Numero[O] 11 !Formato[O]){

MessageBox(hDlg, "Falta Informacion para Procesar",NULL, MB-OK I MB-ICONHAND); return (TRUE);

1 if (CheckFileName(hDlg, FileName, TempName)) {

SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec, (LPSTR) FileName);

strcpy@efPath, str); if (Str[Ol)

EndDialog(hDlg, IDOK);

42

1 return (TRUE);

case IDCANCEL: EndDialog(hDlg, IDCANCEL); return (TRUE);

1 break;

1 return (FALSE);

1

int FAR PASCAL FastDlg(HWND hDlg,unsigned message,WORD wParam,LONG Waram)(

switch (message) ( case WM-INITDIALOG:

SetDlgItemText(hDlg, IDC-Numero, Numero); SendDlgItemMessage(hDlg, IDC-Numero, EM-SETSEL, O,

MAKELONG(O,Ox7f€l)); EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled); SetFwus(GetDlgItem(hDlg, IDC-Numero)); return (FALSE); I* FALSE CUANDO EL FOCO FUE MODIFICADO *I

case WM-COMMAND: switch (wparam) {

case IDC-Numero: if (HIWORD(lParam) == EN-CHANGE && !bSaveEnabled)

return (TRUE); EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled = TRUE);

case IDOK: GetDlgItemText(hDlg, IDC-Numero, Numero, 128); if (!Numero[O])(

MessageBox(hDlg, "Falta Infonnacion para Procesar",NULL,

return (TRUE); MB-OK 1 MB-ICONHAND);

1 EndDialog(hDlg, IDOK); 1 return (TRUE);

f return (FALSE);

1

BOOL FAR PASCAL -export CloseEnumProc (HWND hwnd, LONG IParam) {

if (Getwindow (hwnd, GW-OWNER)) // CHECAR PARA ICON TITLE

SendMessage (GetParent (hwnd), WM-MDIRESTORE, hwnd, OL) ; if (!SendMessage (hwnd, WM-QUERYENDSESSION, O, OL))

SendMessage (GetParent (hwnd), WM-MDIDESTROY, hwnd, OL) ;

1

return 1 ;

return 1 ;

return 1 ;

43

switch(Message) { case WM-INITDIALOG:

UpdateListBox(hD1g); SetDlgItemText(hDlg, IDC-EDIT, DefSpec); SendDlgItemMessage(hDlg,IDC~EDIT,EM~SETSEL,NLJLL,MAKELONG~O,

SetFocus(GetDlgItem(hDlg, IDC-Numero)); return (FALSE); /* Indicates the focus is set to a control */

o x 7 m ;

break; case WM-CLOSE:

PostMessage(hDlg, W-COMMAND, IDCANCEL, OL); break;

switch(wParam) {

switch (I-IIWORD(lParam)) {

case WM-COMMAND:

case IDc-LIsTBox: 1" LIST BOX *I

case LBN-SELCHANGE: if @lgDirSelect(hDlg, str, IDC-LISTBOX))

strcat(str, DefSpec); SetDlgItemText(hDlg, IDC-EDIT, str); SendDlgItemMessage(hDlg, IDC-EDIT, EM-SETSEL, NULL, MAKELONG(0, Ox7fEQ);

break; case LBN-DBLCLK:

goto openfile; 1

return (TRUE); break;

case IDOK: openfile: GetDlgItemText(hDlg, IDC-EDIT, OpenName, 128);

if (strchr(OpenName, '*I) 11 strchr(OpenName, '7')) { SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,

if (Str[Ol)

ChangeDefExt@efExt, DefSpec); UpdateListBox(hD1g); return (TRUE); }

MessageBox(hDlg, "no hay Archivo Especificado",

return (TRUE); }

(LPSTR) Opedame);

strcpy@efPath, str);

if(!OpenName[O]) {

NULL, MB-OK I MB-ICONHAND);

GetDlgItemText(hDlg, IDC-Numero, Numero, 128); GetDlgItemText(hDlg, IDC-Formato, Formato, 128); if( (!Formato[O]) 11 (!Numero[O]) ) {

MessageBox(hDlg, "Falta Informacion para Procesar", NULL, MB-OK I MB-ICONHAND);

44

return (TRUE); 1

AddExt(OpenName, DefExt);

if ((Wile = OpenFile(OpenName, (LPOFSTRUCT) &zofstruct, I* OPEN THE FILE *I

OF-READ)) - 1) { sprintf(str, "Error %d opening ?.".",OfStruct.nErrCode,

OpenName); MessageBox(hDlg, str, NULL,

MB-OK I MB-ICONHAND); 1

- lclose(hFi1e) ; else {

strcpy(FileName, OpenName); EndDialog(hDlg, 1); return (TRUE); 1

return (TRUE);

EndDialog(hDlg, O); return (TRUE);

case IDCANCEL:

1 break;

return FALSE; default:

1 return TRUE; } I* END OF UPDATEMSGPROC *I

void Tipo(FILE *fpl,char *Formato,char *Numero){

int num,Format ;

num= atoi(Numer0); Format=atoi(Formato); switch(Format) { Case 2: I1 PATRON DE ENTRENAMIENTO

switch(num) { case O : fprintf(fp1,"l O O O O O O O O O b");

case 1 : fprintf(fp1,"O 1 O O O O O O O O b");

case 2 : fprintf(fp1,"O O 1 O O O O O O O b");

case 3 : fprintf(fp1,"O O O 1 O O O O O O b");

case 4 : fprintf(fp1,"O O O O 1 O O O O O W);

case 5 : fprintf(fp1,"O O O O O 1 O O O O W');

case 6 : fprintf(fp1,"O O O O O O 1 O O O b");

case 7 : fprintf(fp1,"O O O O O O O 1 O OW);

case 8 : fprintf(fp1,"O O O O O O O O 1 O b");

break;

break;

break;

break;

break;

break;

break;

break;

45

break;

break; case 9 : fprintf(fP1,"O O O O O O O O O 1 h");

default: break; )//SWITCHNUM

break; Case 1 : // CON NUMERO SOLAMENTE ,ES DECIR PATRON DE RECONOCIMIENTO

fprintf(fpl,"o/od h",num); break;

default : //SIN TIPO break;

} //SWITCH FORMATO

1

COMPLEX1 inputwl] w2]; I* DATOS DE ENTRADA PARA FFT *I

BOOL SaveFile(HWND hWnd,BOOL fState[Nl][N2],char *Formato-FP,char "FileName-FP ,int SalvaTipo)

BOOL bSuccess; int i&m; PSTR m; FILE *Sal; FILE *SalIWT; FILE *SalFFT ;

switch(SalvaTipo){ case 1 : /INEW

if((Sal=fopen(FileName-FT,"w")) = NULL){ sprintf(str, "El archivo no se puede crear : YOS.", FileName); MessageBox(hWnd, str, NULL, MB-OK I MB-ICONEXCLAMATION); return (FALSE); 1 FFT= ExtFFT(FileName-~,"mag");//Magnitud if((SalMFT=fopen(FFT,"w")) = NULL) {

sprintf(str, "El archivo no se puede crear : %s.", m); MessageBox(hWnd, str, NULL, MB-OK I MB-ICONEXCLAMATION); return (FALSE); 1

m= ExtFFT(FileName-FP,"fft");//Fase if((SalFFT=fopen(FFT,"w")) == NULL) {

sprintf(str, "El archivo no se puede crear : %s.", m); MessageBox(hWnd, str, NULL, MB-OK I MB-ICONEXCLAMATION); return (FALSE); 1

break;

if((Sal=fopen(FileName-FP,"a")) = NULL) { Case 2: // UPDATE

sprintf(str, "El archivo no se puede crear : %s.'r, FileName); MessageBox(hWnd, str, NULL, MB-OK I MB-ICONEXCLAMATION); return (FALSE); 1

m= ExtFFT(Fi1eName-FP,"mag"); //MAGNITUD if((SalMFT=fopen(FFT,"a")) == NULL) {

sprintf(str, "El archivo no se puede crear : %s.", m); IMessageBox(hWnd, str, NULL, MB-OK I MB-ICONEXC1,AMATION);

46

return(FALSE); 1 FFT= ExtFFT(Fi1eName-FP,"f€t"); //FASE if((SalFFT=fopen(FlT,"a")) = NULL) {

sprintf(str, "El archivo no se puede crear : %s.", FFT); MessageBox(hWnd, str, NULL, MB-OK I MB-ICONEXCLAMATION); return(FALSE); 1

break; 1

hSaveCursor = SetCursor(hHourG1ass); Tipo (Sa1,Formato-FP,Numero) ; for(i=O; i<N2; i++) {

for(j=O; j<N1; j++) { if(fState [i][j])

else

1

fprintf(Sal,"%d ",TRUE);

fprintf(Sal,"-Yd ",TRUE);

fprintf(Sal,"\n"); 1 fprintf(Sa1,"Mn"); fclose(Sal);

for(j4; j<N2; j++) for(i4; i<N1; i++) {

if(fState [i] [i])

else inputb][i].x=(float)l;

input[i][i].x=(float)-1; 1

// FFTSALIDA MAGNITUDLOG && FASE

Tipo (SalFFT,Fonnato_FP,Nwnero) ; Tipo (SalMFT,Formato-FP,Numero) ; AplicaFFT(Saula,SalFFT,input); fclose( SalMFr); fclose(SalFFT);

,, SetCursor(hSaveCursor); return (1);

1

BOOL FAR PASCAL export AboutDlgProc (HWND hDlg, WORD message, WORD wParam,LONG Waram)

{ switch (message) {

case WM-INITDIALOG: return TRUE ;

case WM-COMMAND: switch (wparam) {

case IDOK: EndDialog (hDlg, O) ; return TRUE ;

1 break ;

47

1 return FALSE ; 1 I* END ABOUT DLGPROC*I

void UpdateListBox(hD1g) HWND hDlg; f

strcpy(str, DefPath); strcat(str, DefSpec); DlgDirList(hDlg, str, IDC-LISTBOX, IDC-PATH, 0x4010); if (!strchr (DefPath, I:')) DlgDirList(hDlg, DefSpec, IDC-LISTBOX, IDC-PATH, 0x4010); if (strstr (DefPath, "..")) DefPath[O] = 70'; SetDlgItemText(hDlg, IDC-EDIT, DefSpec);

1

void ChangeDefExt(Ext, Name) PSTR Ext, Name; {

PSTR pTptr,

pTptr = Name; while (*pTptr && *pTptr != l.')

pTptr++; if (*PTPtr)

if (!strchr(pTptr, '*I) && !strchr@Tptr, '7')) StrcpY(Ext, pTptr);

1

void SeparateFile(hDlg, IpDestPath, IpDestFileName, IpSrcFileName) HWND hDlg; LPSTR IpDestPath, IpDestFileName, IpSrcFileName; {

LPSTR 1pTmp; char cTmp;

lpTmp = 1pSrcFileName + (long) lstrlen(lpSrcFi1eName); while (*lpTmp != I:' && *lpTmp != 7Y && lpTmp > IpSrcFileName)

lpTmp = AnsiPrev(lpSrcFileName, 1pTmp); if (*lpTmp != I:' && *lpTmp != Y') {

lstrqy(lpDestFileName, IpSrcFileName); lpDesPath[O] = O; return;

1 lstrcpy(lpDestFileName, lpTmp + 1); cTmp = *(lpTmp + 1); lstrcpy(lpDestPath, IpSrcFileName); *(lpTmp + 1) = cTmp;

lpDestPath[(lpTmp - IpSrcFileName) + 11 = O; 1

48

void AddExt(Name, Eat) PSTR Name, Ext; {

PSTR pTptr;

pTptr = Name; while (*pTptr && *pTptr != l.')

if (*pTptr != l.') pTptr++;

strcat(Name, Ext);

PSTR ExtFFTPSTR Name,char ext[3]) { PSTR tmp,tmpl; int i;

tmpl=strdup(Name); tmp = strdup(Name); for (i=l;*tmp && *tmp != '.';tmp++,i++)

, stmcpy( tmpl + i, ext, 3 ); return(tmp 1);

} BOOL CheckFileName(HWND hWnd,PSTR pDest, PSTR pSrc) {

PSTR pTmp;

if (!pSrc[O])

pTmp = pSrc; while (*pTmp) {

return (FALSE);

switch (*pTmp++) { case '*I: case I?':

MessageBox(hWnd, "Wildcards not allowed.",

return (FALSE); NULL, MB-OK I MB-ICONEXCLAMATION);

f I AddExt@Src, DefExt); if (OpenFile(pSrc, (LPOFSTRUCT) &OfStruct, OF-EXIST) >= O) {

sprintf(str, "Reemplaza el que existe %s?", pSrc); if (MessageBox(hWnd, str, "Edicion Archivo",

MB-OKCANCEL I MB-ICONHAND) == IDCANCEL) return (FALSE);

1 strcpy(pDest, pSrc); return (TRUE);

f

49

/* Archivo de Entrenamiento de la RED Artificial de ADALINE */ #define N1 8 #define N2 8 #define N N1 *N2 /* Numero de elementos */ #define M 10 /* Numero de Clase */ #define Num-Train 100 /* Numero de datos para entrenamiento */

#include <stdio.h> #include <stdlib.h> #include <math.h>

void initqeso(float P e s o M N ) ; void leer-datos-entrenamiento(int ent[Num-Train] N,float d[Num-Train] M); void Guardar-Peso(float pesoFrJN);

void main() { int ent[Num-Train]N;

/* int datN;*/ float Peso[lO]N; float YIM]; float D[Num-Train]FrJ; double errorFrJ; int ij,k,count; float suma,Mu,sqt,alfa4. 1;

/* float max; char *am; */ clrscr(); initqesopeso); leer-datos-entrenamiento(ent,D); /** * * debugging *****I while(1) {

for(k=O; k<Num-Train; k++) { /* Num-Train es numero de entrenamiento */ printf("%d",k); sqt4.0; for(j4; j<N; j++)

sqt=sqt+(ent[k]u] * ent@]u]); Mu=alfa/sqt; for(i4; i<M; i++) { /* M es numero de clase */

suma4.0; for(j=0; j<N; j++)

Y[i]=suma; error[i]=D[k][i]-Y[i]; for(j=O; j<N; j++)

suma+=Peso[i] u]*ent@]u];

Peso[i]u]=Peso[i]~]+Mu*ent[k]u]*error[i]; I 1

/* printf(" error = %f%ffo/of \n",error[O],error[I],error[2]); */

\n~~,fabs(error[O]),fabs(error[l]),fabs(error[2]),fabs(error[3]),fabs(error[4]));

\n",fabs(error[5l),fabs(error[6]),fabs(error[7]),fabs(error[8]),fabs(error[9]));

printf("abs error \n o/$ %f Yóf %f %f

printf(" %f %f Y' %f %f

50

count*; for(k4; k<M; k++) if( fabs(error[k]) < 0.05) count++; if(c0unt >= 7) break;

I printf(" La red esta entrenada W'); printf(" Guardar Pesos a un archivo b"); Guarda-Peso(Peso);

1

void initqeso(Pes0) float Peso[ lO]N; {

int ij;

for( i4; i40; i++) for(i4; j<N; j++)

Peso[i][i]=0.5; I

void lee-datos-entrenamiento(ent,d) int ent[lOO]N; float d[100][10]; {

FILE *archl; int i&k; char nom-arch1[40];

printf(" Tecla nombre de archivo de datos de entrenamiento : b"); scanf("%s",nom-archl);

if((archl==fopen(nom-arch1,"r")) = NULL) { printf(" El archivo no se puede abrir In"); exit( 1);

1

for(k4; k-400; k++) { for( i4; i40; i++)

fora*; j<N; j++) fscanf(archl,"O/af',8rdF][i]);

fscanf(archl,"O/od",&ent[k][i]); I fclose(arch1);

I

void Guardar-Peso(peso) float pe~[MjN; {

FILE *arch2; int ij,k,ii; char *nom-arch2="peso.d";

printf(" Nombre de archivo para Peso : %S ",nom-arch2);

if((arch2=fopen(nom_arch2,"w")) = m L ) { printf(" El archivo no se puede crear W); exit( 1);

1

for(k=O; k<M; k++) { for(i=O,ii=O; i<N2; i++) { for(j4; j<N1; j++,ii++) fprintf(arch2,"%f ",peso@c] [ii]);

fprintf(arch2,"b"); 1

fprintf(arch2,"bbh");

fclose(arch2); 1

52

CONCLUSIONES En base a lo que se describio y comentó en el Capitulo 4 de la Sección SIMULACI6N (pag 21) y al algoritmo de entrenamiento tenemos que se propuso una estructura en paralelo de esta red artificial para el reconocimiento de caracteres. Pero, hay una pregunta que tal vez se este haciendo ;Por qué se hicieron las 2 fases en ambientes diferentes, es decir por qué la fase de entrenamiento se hizo utilizando la Transputer y el reconocimiento en DOS ? La respuesta es muy sencilla ,porque desgraciadamente en DOS o en WINDOWS el espacio de Memoria para guardar la imagen de 16*16 no es suficiente y en ambos casos se Escribió el Algoritmo para Correr en DMPI(Dos Mode Protected Interface) que nos permite manejar mas memoria (arriba de 640Kb) y resulto ser muy lento el entrenamiento (para mostrarme un solo resultado de la adaptación de un coeficiente tardaba alrededor de 2 minutos para una sola ;IMAGEN!; Es decir para entrenar toda la red se necesitaría 500 O00 hrs ) en cambio en la TRANSPUTER se necesitaba 2 hrs. Una de las ventajas e innovaciones de este algoritmo desarrollado por mi asesora (ya que se le hizó algunas modificaciones al algoritmo original) es que los coeficientes generados por La TRANFORMADA DE FOURIER de un patron es el mismo para diferentes patrones en CUALQUIER POSICION por lo tanto la red puede reconocer mejor y más rapidamente un patrón ; sin embargo para reconocer el 6 y el 9 no se puede distinguir ya que estamos utilizando l o s coeficientes de la transformada de Fourier y los valores generados son l o s mismos; ya que el 6 rotado 360 grados es el ;NUEVE!. Para solucionar esto se introdujo la transformadas de Fourier de Fase (Para reconocer las diferencias entre posiciones), sin embargo esto hace más tardado y más complejo el algoritmo para Reconocer el Patrón. Los Datos finales que Obtuve son Sin Utilizar la Transformada de Fourier hay un Reconocimiento del 98%(debido a la posicion del 6 y 9) Utilizando la Tranformada de Fourier hay un Reconocimiento en Fase del 70% y en Magnitud del 80% (debido a que el algoritmo de Reconocimiento es más Complejo y existen muchos algoritmos que puede utilizarse para el reconocimiento).

Finalmente cuando se tratada de reconocer (cero con una diagonal ) la red no la puede identificar co la clase de los ceros originales, debido al "ruido" de la diagonal.

Q

53

BIBLIOGUAFIA

AN INTRODUCTION TO COMPUTING WITH NEURAL NETS Richard P. Lippmann IEEE ASSP MAGANIZE APRIL 1987 Pags 4-22.

ADAPTIVE, ASSOCIATE, AND SELF-ORGANIZING FUNCTIONS IN NEURAL COMPUTING

Teuvo Kohonen Optical Society of America 1987 Pags 42-50.

THE "NEURAL" PHONETHIC TYPEWRITE Teuvo Kohonen IEEE Computer March 1988 Pags 11-22

COUNTPROPAGATION NETWORKS Robert Hecht Nielsen Applied Optics Vol 26. No 23 Dec 1987 Pag 4979-4983

THE FAST FOURIER TRANSFORM AND ITS APPLICATION Ullman & & AH0 Algoritmos de Ordenacion Pags 252-275

BINARY PATTERN RECOGNITION ALGORITM WITH LOW SENSITIVITY TO CHANGES ON SIZE AND POSITION

Mariko Nakano M, Hector Perez M, Adriano de Luca P. Departamento de Ingenieria Electrica UAM Iztapalapa

NEURAL NETWORKS. ALGORITMS, APPLICATION AND PROGRAMMING TECHNIQUES

James A. Freeman , David M. Skapura. Addison Wesley.

54