'1148.206.53.84/tesiuami/Complemento primer lote/UAM0116.pdf · neuronales tales como la red de...

..

Proyecto de Ingeniería electrónica

Redes neuronales de entrada binaria

Juan Carlos Garcia Vázquez Gustavo Alejandro Luna Alciintar

Asesora: Profra. Mariko Alakano .) '1 k J

Iztapalapa, México D.F.; Diciembre 7, 1995


INTRODUCCI~N ..................................................................................................................................... 3

CLASIFICADORES TRADICIONALES Y DE REDES NEURONALES ............................................. 5

ELCLASIFICADOR TRADICIONAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 CLASIFICADORES ADAPTATIVOS DE REDES NEURON ..ES ................................................................................. 7

DEFINICIóN DE RED NEURONAL ...................................................................................................... 9

ELELEMENTO DE PROCESAMIESTO GENER AL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

LA RED DE HOPFIELD ........................................................................................................................ 14

INTRODUCCI~N .......................................................................................................................................... 14 DESCRIPCI~N DE LARED DEHOPFIELD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 ALGORITMO DE LA RED DE HOPFIELD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 LIMITACIONES DE LARED DE HOPFIELD ....................................................................................................... 19

LA RED DE HAMMING ....................................................................................................................... 20

INTRODUCCI~N .......................................................................................................................................... 20 DESCRIPCI~N DE LA RED DE H ~ ~ I I N G . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 ALGORITMO DE LA RED DE HAMMING . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 LIMITACIONES Y VENTAJAS DE LARED DEHAhlMING .................................................................................... 24

EL CLASIFICADOR DE CARPENTER-GROSSBERG ...................................................................... 25

INTRODUCCI~N . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2~ DESCRIPCI~N DE LA RED DE ChRPEN'rEK-GKOSSBI~R ................................................................................... 26

LIMITACIONES Y VENTAJAS DE LARED DE CARPENTER-GROSBERG ............................................................... 30

IMPLEMENTACION ............................................................................................................................. 31

ALGORITMO DE LA RED DE CARPENTEK-GROSSUEIlG .................................................................................... 28

PR0GRAMAPARALASIMULACIi)N DE LARED DE HOPFIELD ........................................................................... 31 PROGRAMAPARASIMULAR LA RED DE CARPENTER-GROSSBERG ................................................................... 38

BIBLIOGRAFIA ..................................................................................................................................... 53

2


Introducción El desarrollo de las redes neuronales artificiales comenzó

aproximadamente hace 50 años, motivado por por un deseo de tratar de comprender ambos, el cerebro y para simular algunas de sus capacidades.

Las redes neuronales son básicamente modelos matemáticos de procesamiento de información. La.s redes proporcionan un método de representar relaciones que son bastante diferentes de las maquinas de programa almacenado. Como con otros métodos numéricos, la disponibilidad de recursos de computadora, sea hardware o software, mejora en mucho la utilidad del enfoque, especialmente para problemas grandes.

Hay muchas tareas que son adecuadas para resolverse en las computadoras convencionales, corno por ejemplo : solución de problemas científicos y matemáticos, creación, manipulación y mantenimiento de bases de datos, comunicación electrónica y procesamiento de palabras entre otras.

En contraste hay muchas aplicaciones que desearían automatizarse debido a la complejidad asociada con programar una computadora para realizar tareas. Hay una amplia variedad de problemas que pueden resolverse, pero su solución es difícil empleando sistemas secuenciales; esta distinción es importante. Si la única herramienta de que se dispone es una computadora secuencial, entonces trataremos de atacar cada problema en términos de algoritmos secuenciales.

En muchas aplicaciones se desea que las computadoras resuelvan problemas complejos de reconocimiento de patrones.

Una ventaja significativa del enfoque de redes neuronales para resolver problemas es que no SE? requiere tener un proceso bien definido para convertir a través de un algoritmo, una entrada a una salida. Mas que nada se requiere, para la mayoría de las redes una colección de ejemplos representativos de interpretación deseada. Una red neuronal se adapta a si rnlisma para producir las salidas deseadas cuando se le proporciona una entrada.

Por otra parte una red neuronal es una estructura robusta en el sentido que responderá con una salida aun cuando se presenten entradas desconocidas, tales como patrones conteniendo ruido,

Recientemente el campo de las redes neuronales artificiales ha cobrado mayor importancia, provocada principalmente por la creación de nuevas topologías y algoritmos, así como también por el desarrollo de técnicas analógicas \/LSI y la creencia de que el

3


procesamiento en paralelo es esencial para el reconocimiento eficiente de voz e imagen.

Los clasificadores óptimos de error mínimo son una clase de modelos de redes neuronales que se emplean en el reconocimiento de patrones binarios alterados.

En vez de ejecutar un programa de instrucciones secuencialmente como en el caso de una computadora de Von Neumann, los modelos de redes neuronales exploran muchas hipótesis compitiendo simultáneamente, usando redes masivas en paralelo compuestas de muchos' elementos computacionales conectados por ligas con pesos variables.

!

Los modelos de redes neuronales se especifican por la topología de la red, las características de los nodos y las reglas de aprendizaje. La adaptación o aprendizaje es la parte central en la investigación sobre redes neuronales La capacidad para adaptación y aprendizaje continuo es esencial en áreas tales como el reconocimiento de voz donde los datos prácticos son limitados y donde se encuentran continuamente nuevos hablantes, nuevas palabras, dialectos, frases y ambientes.

Los beneficios potenciales de las redes neuronales se extienden mas allá de las altas tasas de computación proporcionadas por el paralelismo masivo. Las redes neuronales típicamente proveen un mayor grado de robustez que las computadoras secuenciales de Von Neumann porque hay muchos mas nodos de procesamiento, cada uno de ellos con conexiones locales principales. El daño a unos cuantos nodos o ligas no deteriora significativamente el funcionamiento total. La mayoría de los algoritmos de redes neuronales también adaptan pesos de conexión en el tiempo para mejorar el rendimiento basado en los resultados del momento.

El trabajo en redes neuronalles artificiales tiene una larga historia. El desarrollo de modelos matemáticos detallados comenzó hace mas de 40 años con el trabajo de McCulloch y Pitts, Hebb, Rosemblatt y otros. Trabajos mas recientes como los de Hopfield y Grossberg han hecho que este campo recobre importancia.

4


Clasificadores tradicionales y de redes neuronales

En la siguiente figura se muestran diagramas a bloques para clasificadores tradicionales y de redes neuronales.

_____*

Símbolos de entrada

Calculo de "matching score" Almacenar valores y seleccionar

el máximo

Clasificador Tradicional

Símbolo de salida para la clase mas parecida

entrada, valores analógicos scores intermedios

x0 b x0

Calculo de "matching Selección y score" máximo mejoramiento

b

b x1 b X.¡

X m : b

A

Adaptar'pesos, dados ambos salidas y clase correcta

__c_

Clasificador de Red Neuronal

Ambos tipos de clasificadores determinan cual de las M clases es la mas representativa de un patrón de entrada estático desconocido el cual contiene N elementos de entrada.

5


En un reconocedor de voz las entradas pueden ser los valores de la envolvente de salida del muestre0 de un analizador espectral a un instante del tiempo y las clases pu,eden ser diferentes vocales. En un clasificador de imagen las entradas pueden ser el nivel en la escala del gris de cada pixel para una fotografía y las clases pueden representar objetos diferentes.

El clasificador tradicional El clasificador tradicional tiene dos etapas. La primer etapa

calcula los matching scores para cada clase y la segunda selecciona la clase con el máximo score. Las entradas a la primer etapa son símbolos que representan valores de los N elementos de entrada. Estos símbolos entran secuencialmente y son decodificados de una forma simbólica externa en una representación interna útil para realizar operaciones aritméticas y simlbólicas. Un algoritmo calcula un matching score para cada una de las M clases el cual indica que tan cercanamente la entrada apareja el patrón muestra para cada clase. Este patrón muestra es aquel patrón el cual es el mas representativo de cada clase. En muchas situaciones se emplea un modelo probabilistico para modelar la generación de patrones de entrada a partir de muestras y los matching scores representan la probabilidad de que el patrón de entrada haya sidlo generado de cada una de las M posibles muestras. En esos casos ~ se hacen suposiciones fuertes concernientes a las distribuciones subordinadas de los elementos de entrada. Entonces se pueden estimar parámetros de distribuciones usando un datos de entrenamiento como se muestra en la figura. A menudo se emplean distribuciones Gaussianas multivariadas para algoritmos relativamente simples para calcular matching scores. Los matching scores se codifican en representaciones simbólicas y pasan secuencialmente a la segunda etapa del clasificador. En esta segunda etapa son decodificadas y La clase con el máximo score es seleccionada. Un símbolo representando esa clase se envía al exterior para completar la tarea de clasificación.

6


i

Clasificadores adaptativos de redes neuronales En este tipo de clasificadores' los valores de entrada van en

paralelo a la primer etapa a través de N conexiones de entrada. Cada conexión lleva un valor analtjgico el cual puede tomar dos niveles para entradas binarias o puede variar en un amplio rango para entradas con valores continuos. La primer etapa calcula los matching scores y saca estos scores en paralelo a la siguiente etapa sobre M líneas de salida analógicas. Aquí el máximo de estos valores es seleccionado y mejorado. La segunda etapa tiene una salida para cada una de las M clases. Des'pués que la clasificación es completada, solo aquella salida correspondiente a la clase mas parecida estará en alto; las otras salidas estarin en bajo.

Notar que en este diseño, existen salidas para todas las clases y que esta multiplicidad de salidas debe preservarse en etapas de procesamiento posteriores tanto tiempo como las clases sean consideradas diferentes. En el sistema de clasificación mas simple estas líneas de salida pueden ir directamente a indicadores con etiquetas que especifiquen identidades de clase. En casos mas complicados pueden ir a etapas posteriores de procesamiento donde se tienen en cuenta entradas a partir de otras modalidades o dependencias temporales. Si es proporcionada la clase correcta, entonces esta información y las slalidas del clasificador pueden retroalimentarse a la primer etapa del clasificador para adaptar pesos empleando un algoritmo de aprendizaje. La adaptación creara una respuesta correcta mas parecida para patrones de entrada subsecuentes que son similares al patrón en cuestión.

Los clasificadores pueden realizar tres tipos de tareas diferentes.

1. Pueden identificar que clase representa mejor un patrón de entrada, donde se supone que las entradas se han alterado por ruido o algún otro proceso. Este es un problema clásico de teoría de decisiones.

2. Los clasificadores pueden emplearse como memoria asociativa, donde la clase muestra es deseada y el patrón de entrada se usa para determinar la muestra a producir. Una memoria direccionable de contenido es útil cuando solo parte de un patrón de entrada esta disponible y se requiere del patrón completo, como en el caso de la

7


consulta bibliográfica de referencia de revistas a partir de información parcial. Esto normalmente requiere la adición de una tercera etapa para generar la muestra para la clase mas parecida.

Una etapa adicional es imecesaria para algunas redes neuronales tales como la red de Hopfield la cual se diseña específicamente como memoria direccionable de contenido.

3.Otra tarea que estos clasificadores pueden realizar es agrupar las N entradas en M grupos. Cuantificadores vectoriales se emplean en sistemas de transmisión de voz e imagen para reducir el número de bits necesarios para transmitir datos analógicos. En aplicaciones de reconocimiento de imagen y voz se emplean para comprimir la cantidad de datos que deben proc.esarse sin perder información importante. En cualquier aplicación e l número de grupos puede ser pre-especificado o se puede permitir crecer a un limite determinado por el número de nodos disponible en, la primer etapa.

8


Definición de red neuronal Una red neuronal es una estructura de procesamiento de

información distribuida en paralelo, en la forma de un grafo dirigido, con las restricciones y subdefiniciones siguientes:

1. Los nodos del grafo son llamados elementos de procesamiento. 2. Las ligas del grafo son llamadas conexiones. Cada conexión funciona

3. Cada elemento de procesamiento puede recibir cualquier número de

4. Cada elemento de procesamiento pulede tener cualquier número de

como una trayectoria de conducción de señal instantánea unidireccionai.

conexiones de entrada.

conexiones de salida, pero las señales en cada una debe ser la misma. De hecho, cada elemento de procesamiento tiene una sola conexión de salida que puede ramificarse en copias para formar conexiones de salida múltiples (también llamadas colaterales), cada una de las cuales lleva la misma señal (la señal de salida del elemento de procesamiento).

5. Los elementos de procesamiento pueden tener memoria local. 6. Cada elemento de procesamiento posee una función de

transferencia, la cual puede usar (y alterar) memoria local, puede también usar señales de entrada y producir así la señal de salida del elemento de procesamiento.

7. Las señales de entrada a una red neuronal, del exterior de la red llegan a través de conexiones que se originan en el mundo exterior. Las conexiones que abandonan la red son salidas al exterior.

Una red puede pensarse como una función y(x). Este enfoque permite apreciar que las redes neuronales pueden encajar en los sistemas de computación programados (tradicionales).

La palabra arquitectura se emplea en la descripción matemática formal de una red neuronal; cabe destacar que la arquitectura de una red neuronal no tiene relación con la implementación de tal o cual arquitectura.

Las redes neuronales tienen slus elementos de procesamiento divididos en subconjuntos disjuntos, llamados niveles, en los cuales todos los elementos de procesamiento poseen esencialmente la misma función de transferencia.

Muchas redes neuronales incluyen un tipo de nivel llamado nivel de entrada, en el cual cada elemento de procesamiento recibe

9


exactamente una entrada, la cual llega del exterior. Los elementos de procesamiento del nivel de entrada típicamente no tienen otra función mas que distribuir las señales incidentes en ellos a otros elementos de procesamiento de la red. Tales elementos de procesamiento son llamados unidades; de entrada.

La señal portada por una conexión puede ser cualquiera de una variedad ilimitada de tipos de datos matemáticos. Por ejemplo el tipo de datos matemático de la señal en una conexión puede ser un entero, un numero real o un numero complejo.

Para implementar redes neuronales en hardware analógico pueden usarse números reales restringidos (por ejemplo una señal tal puede implementarse como un voltaje o una corriente). En un ambiente de implernentacion digital, una variedad de tipos matemáticos tales como enteros y reales de punto flotante pueden estar presentes en una señal de conexión.

Muchas redes neuronales tienen elementos de procesamiento con señales de salida en los rangos [-l,I o[OJ]o en los conjuntos discretos {-l,l) o [0,1].

Dado un conjunto de n elementos de procesamiento de alguno de estos tipos (indexados de 1 a M), se puede ver el conjunto completo de sus n señales como un vector Único X = ( ~ 1 ~ x 2 , ..., xM], donde x i es la señal de salida del elemento de procesamiento con índice i .

A los dominios de tales vectores se les llama cubos y son :

n [OJ] = (x= (X l ,X2, ..., xn) E & I o < xi I 1 v 1 si I n )

Los dos últimos cubos se llaman cuba binario discreto respectivamente.

discreto y cubo bipolar

!

Los vectores en son llamados vectores binarios y los vectores en

{-l,l]' son llamados vectores bipolares.

10

Reldes neuronales de entrada binaria

N elernento de procesamiento general Los elementos de computación individuales que conforman la

mayoría de los modelos de sistemas neuronales artificiales se llaman elementos de procesamiento.

No siempre es apropiado pensar en los elementos de procesamiento en una red neuronal como en una relación uno a uno con las neuronas biológicas. A1guna.s veces es mejor imaginar un elemento Único de procesamiento como representativo de la actividad colectiva de un grupo de neuronas.

En la figura siguiente se ilustra el modelo de procesamiento general. Cada elemento de procesamiiento se numera, el de la figura es el i-esimo elemento.

Como una red neuronal un elemento de procesamiento tiene muchas entradas, pero tiene una salida única, la cual puede conectarse a muchos otros elementos de procesamiento en la red. La entrada en i desde el nodo j se indica como xj(este es la salida

del nodo j , tal como la salida del nlodo i es etiquetada como X i ) .

Cada conexión al i - esimo elemlento de procesamiento esta asociado con una cantidad llamada un peso de conexión. El peso sobre la conexión del nodo j al nodo i se denota como wg .

Todas estas cantidades tienen analogía en el modelo neuronal estándar : la salida del EP correspondle a la frecuencia de encendido de la neurona, y el peso corresponde a la intensidad de la conexión sinaptica entre neuronas.

i 11


Como se muestra en la figulra, las entradas al EP están separadas en varios tipos. Una entrada de conexión puede ser excitadora o inhibitoria.

Cada EP determina un valor de entrada total basado en todas sus conexiones de entrada. En ausencia de conexiones especiales, típicamente se calcula la entrada total sumando los valores de entrada, multiplicados por sus correspondientes pesos.

La entrada total a la i-esima unidad es : netí = S xjwij

Donde el índice j corre sobre todas las conexiones al elemento de procesamiento. Las excitacio,nes e ihnibiciones pueden determinarse por el signo de los pesols. Dado que hay por lo general un numero muy grande de interconexiones en una red , la rapidez a la cual pueda realizarse este calculo determina generalmente la ejecución de la simulación de cualquier red dada.

Una vez que la entrada es calculada, esta se convierte a un valor de activación, para el EP. Este valor de activación se puede escribir como sigue:

ai(t) = Fi (ai(t-l),neti(t))

Para denotar que el valor (le activación es una función explícita de la entrada total net. Notar que la activación actual puede depender del valor de la activación previa a(t-I). En la mayoría de los casos, la activación y la entrada total son las mismas.

Una vez que la activación del EP es calculada, podemos determinar el valor de salida aplicando una función de salida:

xi = fi (ai) o bien xi = fi(neti)

El termino función de activación algunas veces se utiliza para referirse a la función fi, que convierte el valor de entrada a la red, al valor de salida del nodo xi.

Cuando se describen las bases; matemáticas, para modelos de redes, es útil pensar en la red conno un sistema dinámico. Para describir una red de este tipo , se emplean ecuaciones diferenciales que describen la razón de cambio re.specto al tiempo de las salidas de varios elementos de procesamiento. Por ejemplo xi=gi(xi,neti) representa una ecuación diferencial general para la salida del i- esimo elemento de procesamiento. Dado que net¡ depende de las

12

‘I

Redes neuronales de entrada bharia

salidas de muchas otras unidades, Io que en realidad se tiene es un sistema de ecuaciones diferenciales.

Es útil también observar la colección de valores pesados como un sistema dinámico. Tener en cuenta que el aprendizaje es el resultado de las modificaciones de la intensidad de las uniones sinapticas entre neuronas.

En una red neuronal artificial, el aprendizaje se lleva a cabo a través de modificaciones en los valorres pesados. Se puede escribir un sistema de ecuaciones diferenciales para los valores pesados, wij = Gi(wij,xi,xj, ...), donde Gi representa la ley de aprendizaje.


La red de Hopfield

Introducción La memoria asociativa parece ser una de las funciones

principales del cerebro. Nosotros fácilmente asociamos el rostro de un amigo con su nombre, o bien un nombre con un numero telefónico.

Muchos dispositivos exhiben características de memoria asociativa. Por ejemplo, el banco de memoria en una computadora es un tipo de memoria asociativa: este asocia direcciones con datos.

La memoria de Hopfield, en particular juega un papel importante en el resurgimiento actual de interés en el área de sistemas neuronales artificiales.

La red de Hopfield es una red de entrada binaria del tipo supervisada; estas redes son mas apropiadas cuando es posible una representación binaria exacta como er;l el caso de patrones.

En el presente trabajo se realiza la implementacion de la red de Hopfield tratándola como una memoria direccionable de contenido, aplicándola al reconocimiento de patrones.

Hopfield escribió dos documentos altamente confiables sobre redes neuronales en 1982 y 1984 y esto persuadió a cientos de científicos altamente calificados, matemáticos y técnologos a unirse al campo naciente de las redes neuronlales. El trabajo de Hopfield fue la mas importante contribución al revitalizado campo.

14


Descripción de /a red de Hopfield Típicamente las redes asociativas recurrentes comienzan en

algún estado inicial y entonces convergen a uno de un número finito de estados estables. Hay tres metas básicas en el diseño de redes asociativas recurrentes.

1.

2.

3.

Dado cualquier estado inicial, la red siempre deberá converger a algún estado estable El estado estable al cual converge la red deberá ser lo mas próximo al estado inicial Seria posible tener tantos estados estables como se desee

La función de transferencia del elemento de procesamiento de la red de Hopfield esta dada por

para i = 42, . . . y

Los elementos de procesamiento de la red se actualizan uno a la vez. La única restricción en lo que se refiere a estas actualizaciones es que todos los elementos de procesamiento deben actualizarse a la misma razón promedio.

La red de Hopfield no tiene una1 ley de aprendizaje asociada a

su función de transferencia. La matriz de pesos (n x n ) W= ( WIJ) (la

cual por lo tanto es fija) se supone que se ha especificado en todo lo que sigue. No hay restricciones en 110s valores de números reales WIJ, excepto que la matriz debe ser‘ simétrica y tener una diagonal cero. En otras palabras,

w . . = w . .para todo i, j E {1,2!7...7n}, y Y Y w.. = O para todo i E {1,2 ,..., n]

I1

15


La red de Hopfield normalmente se emplea con entradas binarias. Estas redes son mas apropiadas cuando son posibles representaciones binarias exactas como lo es con imágenes blanco y negro donde los elementos de entrada son valores de pixeles, o con texto ASCII donde valores de entrada podrían representar bits en la representación ASCII de 8 bits de cada carácter.

Hopfield recobro el interés en redes neuronales por su extensivo trabajo en diferentes versiones de la red de Hopfield. Esta red puede usarse como una memoria asociativa o para resolver problemas de optimización. Aquí se trata una versión original de la red la cual puede emplearse como una memoria direccionable de contenido.

Red neuronal de Hopfield que puede emplearse como una rnernoria direccionable de contenido

Esta red tiene n nodos conteniendo no linealidades limitantes duras y entradas binarias, y salidas tomando los valores +1 y - 1. La salida de cada nodo es retroalimentada a todos los otros nodos a través de pesos denotados t y.

Primero, los pesos se establecen usando el conjunto dado de patrones muestra para todas las clases. Entonces se impone un patrón desconocido a la red a tiempo cero, forzando la salida de la

16


red para aparejar el patrón desconocido. Siguiendo esta inicialización, la red itera en pasos de tiempo discretos, empleando la formula dada. Se considera que la red converge en el momento en que las salidas no cambian en iteraciones sucesivas. El patrón especificado por las salidas de los nodos después de la convergencia es la salida de la red.


Algoritmo de /a red de Hopfield

Paso Uno Asignar pesos de conexidn

En esta formula t . . es el peso de conexión del nodo i al

nodoj y la cual puede ser a+ o - es el elemento i de la muestra para la clase S .

!I

Paso Dos Inicializar con un patrcbn de entrada desconocido

p,(o) =x,, Ori < N - - 1

En esta formula p, ( t ) es la salida del nodo i a tiempo t y X, la cual puede ser + o - es el elemento i del patrón de entrada.

Paso Tres Iterar hasta convergencia

La función f, es la no linealidad limitante difícil, mostrada en una figura anterior. El proceso se repite hasta que las salidas de los nodos permanecen sin cambio con iteraciones subsecuentes. Las salidas de los nodos representan entonces el patrón muestra que mas se asemeja a la entrada desconocida.

Paso Cuatro Repetir, yendo al paso dos.

18


Hopfield y otros probaron que esta red converge cuando los pesos son simétricos ( t u = t,,) y las salidas de los nodos son actualizadas asincronamente usando las ecuaciones del algoritmo. Hopfield también demostró que l a red converge cuando no linealidades graduadas similares a la no linealidad sigmoid son usadas.

Cuando la red de Hopfield es empleada como clasificador, la salida después de convergencia debe ser comparada a las M muestras para determinar si esta se apareja a un patrón exactamente. Sí lo es, la salida es aquella clase cuya muestra apareja el patrón de salida. Sí no Io es entonces ocurre un no aparejamiento.

Limitaciones de la red de Hopfield La red de Hopfield tiene dos limitaciones principales cuando

se emplea como memoria direccionable de contenido. En primera, el número de patrones que puede almacenar y

llamar exactamente esta severamente limitado. Si son almacenados muchos patrones, la red puede converger a un patrón espurio nuevo diferente de todos los patrones muestra. Tal patrón espurio producirá una salida sin aparejamiento cuando la red se usa como un clasificador.

Hopfield mostró que esto ocurre con poca frecuencia cuando los patrones muestra son generados 'aleatoriamente y el número de clases M es menor que 0.15 veces el número de elementos de entrada o nodos en la red N . El número de clases es así típicamente conservado bien abajo de 0.15N. Por ejemplo, una red de Hopfield para solo 10 clases puede requerir mas de 70 nodos y mas de 5000 pesos de conexión.

Una segunda limitación de la red de Hopfield es que un patrón muestra será inestable sí este comparte muchos bits en común con algún otro patrón muestra. Aquí se considera una muestra inestable, si es aplicada a tiempo cero y la red converge a alguna otra muestra.

19


La red de Hamming

lntroducción

La memoria es crítica para cualquier sistema de procesamiento de información que recuerde o deduzca la misma. La memoria de una red neuronal reside en los pesos, los cuales pueden ser prealmacenados o entrenados adaptivamente por un mecanismo de aprendizaje.

En términos de cómo los pe:;os son obtenidos, las redes neuronales pueden ser clasificadas en tres categorías, a saber: pesos fijos, supervisadas y no supervisadas.

Vamos a estudiar un tipo de red de memoria asociativa conocida como Red de Hamming. Dicha red pertenece a la categoría de pesos fijos, es decir, éstos son almacenados previamente. Este tipo de redes están diseñadas para recuperar el patrón original (libre de errores) de una señal que se considera ha sufrido distorsión.

20


Descripción de la red de Hamming

La red calcula primero (ep su parte baja) los pesos y offsets para que las salidas generadas sean igual :I N menos las distancias de Hamming’ a los patrones de entrada. Estas salidas variarán de O al número de elementos (N) en la entrada de la red, y son mayores para aquellos nodos cuyos patrones de entrada se asemejen más a los patrones almacenados. Los pesos y offsets se fijan en la subred MAXNET. Todos los offsets se ponen (a O y los pesos de cada nodo a éI mismo son 1. Los pesos entre los nodos son inhibidos dándoles un valor de -5 donde 5 -i 1 / M.

Después de que los pesos y offsets han sido calculados, un patrón de entrada con N elementos es presentado en la parte baja de la red de Hamming. Este patrón debe presentarse en la entrada el tiempo suficiente para permitir a la red inicializar y calcular tanto pesos como offsets y las salidas que se presentarán a la subred MAXNET. El patrón es entonces retirado de la entrada y la MAXNET itera hasta que la salida de solamente un nodo sea positiva. Así se completa la clasificación y la clase seleccionada es aquella que corresponde al nodo con una salida positiva. La siguiente figura ilustra la estructura de la red de Hamming:

YO Y1 ym-2 ym-I

..................

MAXNET, selecciona el máximo ....................

Cálculo de matching scores

x0 X I xn-2 xn-I

’ La distancia de Hamming es el número de bits en los que difiere el patron de entrada con los patrones almacenados en la red.


Algoritmo de la red de Hamming

A continuación se muestra el algoritmo de la red de Hamming. En este podemos ver que primero se asignan los pesos y offsets, se inicializa la red con un patrón desconocido como entrada y se itera hasta que se encuentra el patrón que más se apegue al de entrada.

Pasol. Asignación de Pesos y Offsets En la subred inferior:

w = - 8 1"- x: N

V 2 ' J 2

O r Z < N - l , O ~ j I " l

En la subred superior: k = l

En estas ecuaciones wli son los pesos de conexión de la entrada i al nodoj en la subred inferior y 8 e:; el offset en ese nodo. El peso de la conexión del nodo k al nodo 1 en la subred superior es t , y todos los o:ffsets en esta subred son cero.

Paso II . Inicializar con un patron de entrada desconocido.

En esta ecuación , u J (1) es la salida del nodoj en la

subred superior al tiempo I , x, es el i - é simo elemnto del patron de entrada yS, es el valor de la función no lineal.

22


Se asume que la má xim entrada a esta función nunca causa que la salida sea indefinida.

Paso III. Iterar hasta Converger

Este proceso se repite hasta convergencia, despué S

de que solamente la salida de un nodo permanece positiva.

Paso I V . Repetir yendo al paso II

23


Limitaciones y ventajas de la red de Hamming

Las simulaciones con diferentes probabilidades de invertir bits en patrones de entrada y con diferentes números de clases y elementos en los patrones de entrada han demostrado que la MAXNET converge típicamente en menos de 10 iteraciones en este tipo de aplicaciones. Además puede probarse que la MAXNET siempre convergerá y hallara el nodo con el valor máximo cuando

La red de Hamming tiene una cantidad de ventajas obvias sobre la red de Hopfield. ÉSta implementa el clasificador de error mínimo cuando los errores en los bits son aleatorios e independientes, y así el rendimiento de la red de Hopfield puede ser peor o equivalente a la red de Hamming en tales circunstancias. Las comparaciones entre las dos redes en problemas tales como reconocimiento de caracteres, reconocimiento de patrones aleatorios y consulta bibliográfica han demostrado esta diferencia en rendimiento. La red de Hamming también requiere mucho menos conexiones que la red de Hopfield. Por ejemplo, con 100 entradas y 10 clases la red de Hamming requiere únicamente 1100 conexiones, mientras que la red de Hopfield requiere casi 10000. Mas aun, la diferencia en el número de conexiones requeridas se incrementa cuando el número de entradas se incrementa, dado que el niimero de conexiones en la red de Hopfield crece como el cuadrado del número de entradas, mientras que el número de conexionesl en la red de Hamming crece linealmente. La red de Hamming tambien puede modificarse para ser un clasificador de error mínimo cuarndo los errores se generan invirtiendo los elementos de entrada de +I a -1 y de -1 a +I asimétricamente con diferentes probabilidades y cuando los valores de elementos de entrada especificos son desconocidos. Finalmente, la red de Hamming no .sufre de patrones de salida espurios los cuales pueden producir un resultado no-match.

5 + 1 I M .

24


El clasificador de Carpenter-Grossberg

/nffoducción Carpenter y Grossberg en el desarrollo de su teoría de

resonancia adaptativa han diseñado una red la cual forma grupos y es entrenada sin supervisión. Esta red implementa un algoritmo de agrupamiento guía que selecciona la primera entrada como la muestra para el primer grupo. La siguiente entrada es comparada a la primera muestra agrupada. Esta “sigue al guía” y es agrupada con la primera, si la distancia a la primeral es menor que un umbral. De otra forma esta es la muestra para un nuevo grupo. El numero de grupos entonces crece con el tiempo y depende de ambos, el umbral y la distancia métrica empleada para comparar entradas a muestras agrupadas.

25


Descripci6n de la red de Carpenfer-Grossberg La estructura de esta red es similar a la red de Hamming.

Matching scores son computados empleando conexiones feed- forware y el máximo valor es realzado usando inhibición lateral entre los nodos de salida. Esta red difiere de la red de Hamming en que las conexiones de retroalimentación se proveen de los nodos de salida a los nodos de entrada. También se proveen mecanismos para apagar ese nodo de salida con un valor máximo, y para comparar muestras a la entrada para la prueba de umbral requerida por el algoritmo guía.

Esta red se describe completamente usando ecuaciones diferenciales no lineales, incluye retroalimentación extensiva y a demostrado ser estable.

Red de Carpenter-Grossberg con tres nodos de entrada y dos nodos de salida

Salida

Entrada

El algoritmo supone que se emplea “aprendizaje rápido”, así que los de ambas entradas y muestras almacenadas, solo toman los valores O y 1. La red es inicializada estableciendo efectivamente todas las muestras representadas por pesos de conexión a cero. Además, un umbral de aparejamiento 11,amado vigilancia el cual va de 0.0 a 1 .O debe establecerse. Este umbral determina que tan cerca un nuevo patrón de entrada debe estar para almacenar una muestra que deba considerarse similar. Un valor cerca de uno requiere un aparejamiento cerrado y valores mas pequeños aceptan un aparejamiento mas pobre. Se presentan secuencialmente nuevas entradas en la parte baja de la red, como en la red de Hamming. Después de la presentación, la entrada es comparada a todas las muestras almacenadas en paralelo corrto en la red de Hamming para producir matching scores. La muestra con el mas alto matching score es seleccionada usando inhibición lateral . entonces esta es comparada a la entrada calculando la razón del ’producto cruz de la

26


entrada y la muestra de mejor matching (numero de bits uno en común) dividida por el número de bits 1 en la entrada. Si esta razón es mayor que el umbral de vigilancia, entonces se considera que la entrada es similar a la muestra de mejor matching y esa muestra es actualizada realizando una operación AND lógica entre sus bits y aquellos de la entrada. Si la razón es menor que el umbral de vigilancia, entonces la entrada se considera diferente de todas las muestras y es adicionada como una nueva muestra. Cada muestra nueva adicional requiere un nodo y 2N conexiones para calcular matching scores.

27


Algoritmo de la red de Carpenter-Grossberg

Paso Uno Inicialización

O < i < N - l O < j < M - 1

setp, 0 1 p < l

En estas ecuaciones bu( I) es el inferior y es el superior, pesgs de conexión entre el nodo de entrada i y el nodo de salidaj a tiempo t . Estos pesos definen la muestra especificada por el nodo de salida j . La fracción p es el umbral de vigilancia el cual indica que tan cercana debe estar una entrada a una muestra almacenada para aparejarse.

Paso Dos Aplicar una entrada nueva

Paso Tres Computar las cuentas de aparejamiento

En esta ecuación p, es la salida del nodo de salida j y xi es el elemento i de la entrada el cual puede ser a0 o 1.

Paso Cuatro Seleccionar la muestra 'de mejor aparejamiento

Esto se realiza usando inhibición lateral extensiva.

28

Redes neuronales d e entrada binaria

Paso Cinco Prueba de vigilancia

IIT* XI1 llxll sí - > p entonces ir a1 paso 7,

Otro ir al paso 6

Paso Seis Deshabilitar la muestra de mejor apareamiento

La salida del nodo de mejor apa#reamiento seleccionada en el paso 4 se pone temporalmente a cero y no toma mas parte en la maximixación del paso 4. Entonces ir al paso 3.

Paso Siete Adaptar la muestra de mejor apareamiento

? * ( t + l ) = ? *(?)x. i j ij 1

Paso Ocho Repetir, yendo al paso dos

Primero habilitar cualquier nodo deshabilitado en el paso seis.

29


Limitaciones y ventajas de la red de Carpenter-Grosberg

El Algoritmo de Carpenter-Grolssberg puede tener un buen rendimiento con patrones de entrada perfectos pero que aun una pequeña cantidad de ruido puede provocar problemas. Sin ruido el umbral de vigilancia puede establecerse tal que los dos patrones los cuales sean mas similares sean consilderados diferentes. Con ruido, sinembargo este nivel puede ser tan alto y el número de muestras almacenadas puede crecer rápidamente hasta que todos los nodos disponibles sean empleados. Se requieren modificaciones para mejorar el rendimiento de este algoritmo en presencia de ruido. Esto puede incluir adaptar pesos mas lentamente y cambiar el umbral de vigilancia durante el entrenamiento y prueba.

30


Implementación Los programas para la simulación del comportamiento de las

redes aquí tratadas fueron escritos en lenguaje C, empleando la versión 2.0 del compilador “Turbo C de Borland”.

Programa para la simulación de la red de Hopfield El número de clases M es 6 El número de elementos por clase N es 120 En el programa las representaciones de las muestras se leen de

archivos de texto. La trayectoria para estos archivos de texto es: c:\proyecto\salida y los nombres de los archivos para las muestras ejemplo son EJEMPLOx.TXT y para las muestras que pueden ser proporcionadas por el usuario MUESTFIAx.TXT.

El programa guarda dos archivos como salida; el primero es un archivo con la muestra alterada por el porcentaje de alteración proporcionado y se almacena en c:\proyecto\salida\MUALTER.TXT y el segundo es la muestra final cuando la red a convergido (c:\proyecto\salida\MUFlNAL.TXT).

El usuario puede hacer pruebas con sus propios patrones modificando las archivos MUESTRAx.TXT. Como se podrá apreciar si se editan estos archivos, estos son solo una línea de texto conteniendo O’s y ?’S, con la única condición que el número de O’s o 1 ’S debe ser N.

El numero de muestras y de elementos por muestra puede variar y para alguien interesado en hacer pruebas puede modificarse fácilmente el código fuente del programa.

Para correr el programa se requieren 3 parámetros en la línea de comandos, como se muestra. <NombreDelPrograma Opción PorcentajeDeAlteraciÓn> Donde: NombreDelPrograrna: Es el nombre del programa ejecutable Opción: Puede ser el valor O(muestras ejemplo) o 1 (muestras del usuario) PorcentajeDeAlteración: es el porcentaje de alteración a la que será sometida la muestra en cuestión

Ejemplo : HOPFIELD O 15 Esto significa que se esta corriendo el programa ejecutable

llamado HOPFIELD, empleando las muestras proporcionadas como ejemplo y con un porcentaje de alteraci6n (o ruido) de 15%.

31


#include <stdio.h> #include cctype.h> #include <conio.h> #include <stdlib.h>

#define NumClases 6 #define NumElem 120

#define TarnHor 1 O /* Tamaño horizontal */ #define TamVeFt 12 /* Tamaño vertical */ #define CIERTO 1 #define FALSO O #define M 6 #define N 120

#define NUMREN 6 #define NUMCOL 120 #define NUMARCH 6

void LeeMuestra(int Ren,char NomArch[r,int Matriz[][]); void LeePatrones(char Indicador[],int Matriz[][]); void SeleccionaPat(int Sel,int MatrizP[[,int PatronSel[]); void BuscaValor(int Lista[],int Valor,int Ind,int *Esta); void AlteraPatron(int PatronSel[],int PatronAlt[],int PorcAlteracion); void GuardaPatron(int Arreglo[,char NomArchU); void CalculaMatrizT(int MatrizPUnjnt MatrizTUU); void InicializaSalida(int PatronEnt0,int PatronSaln); void ActualizaSalida(int MatrizTnOjnt PatronAnt0,int PatronAct0,int PatronlnicialU,int Cont); void RealizaComparacion(int PatronSal0,int PatronSalActU,in,t *Continua); void AlgoritrnoDeHopfield(int MatrizP[][],int PatronAltU,int PatronSalU,int *Cont);

/* Función principal para la simulación de la red de Hopfield *I

void main(int argc,char *argv[) {

int MatrizP[NumClases][NumElem]; int Sel,PorcAlteracion,Cont; int PatronSel[l20],PatronAlt[l20],PatronSal[l20];

LeePatrones(argv[l],MatrizP); Sel=atoi(argv[2]); SeleccionaPat(Sel,MatrizP,PatronSel); PorcAlteracion=atoi(argv[3]); AlteraPatron(PatronSel,PatronAlt,PorcAlteracion); GuardaPatron(PatronAIt,"c:\ \proyecto\\s\O"); AlgoritmoDeHopfield(MatrizP,PatronAlt,PatronSal,&Cont); GuardaPatron(PatronSal,"c: \ \proyecto\ \s\O");

}I' main *I

32

Reides neuronales de entrada binaria

I* Esta función lee una muestra de un archivo */

void LeeMuestra(int Ren,char NomArch[],int Matriz[NUMREN][NUMCOL]) {

FILE *Arch; int Col; char Caracter;

if ( (Arch=fopen(NomArch,"rl"))==NULL) { printf("Error : ");

1 else {

Col=O; do {

Caracter=getc(Arch); if ( Caracter-='O ) {

Matriz[Ren][Col++]=l ;/*atoi(Caracter);*/ 1 if ( Caracter=='l' ) {

Matriz[Ren][Col++J=-1 ;/*atoi(Caracter);*/ 1

} while (!feof(Arch)); fclose(Arch);

1 }/* LeeMuestra *I

/* Esta función lee todo el conjunto de muestras almacenadas en archivos de texto, las cuales pueden ser muestras proporcionadas como ejemplo o bien mluestras proporcionadas por el usuario *I

void LeePatrones(char Indicadoru,int Matrizuu) {

static char NomArchEjemplo[NUMREN][NUMCOL] := { ("c:\\proyecto\\salida\\ejemplol .txt\O"}, {"c:\\proyecto\\salida\\ejemplo2.txt\O"}, {"c:\\proyecto\\salida\\ejemplo3.txt\O"}, ("c:\\proyecto\\salida\\ejemplo4.txt\O"}, {"c:\\proyecto\\salida\\ejemplo5.txt\O~'}, ("c:\\proyecto\\salida\\ejemplo6.txt\O"}

1;

static char NomArchMuestra[NUMREN][NUMCOL] =: { ("c:\\proyecto\\salida\\muestral .txt\Ol'}, ("c:\\proyecto\\salida\\muestra2.txt\0"}, {"c:\\proyecto\\salida\\muestra3.txt\O"}, ("c:\\proyecto\\salida\\muestra4.txt\O}, {"c:\\proyecto\\salida\~uestra5.txt\O"}, ~c:\\proyecto\\saIida\\muestra6.txt\O")

33


1; int Ind,Valor;

Valot=atoi(lndicador); switch (Valor) {

case O : for ( Ind=O ; IndcNUMARCH ; Ind++ ) { LeeMuestra(lnd,NomArchEjemplo[lnd],Matriz);

1 break;

case 1 : for ( Ind=O ; IndcNUMARCH ; Ind++ ) { LeeMuestra(lnd,NomArchMuestra[lnd],Matriz);

1 break;

default : break;

1 }P LeePatrones */

/* SeleccionaPat : Esta funcion solo selecciona uno de los renglones de la matriz de patrones */

void SeleccionaPat(int Sel,int MatrizP[M][120],int PatronSel[l20])

int Ind;

for ( Ind=O ; lndc120 ; Ind++ ) PatronSel[lnd] = MatrizP[Sel][lnd];

}/* SeleccionaPat */

/* Buscavalor : Esta funcion solo verifica si un elemento se encuentra en una lista *I

void BuscaValor(int Lista[l20],int Valorjnt Ind,int *Esta) {

int Ap;

*Esta = CIERTO; Ap = O; if (Ind==O)

else { *Esta = FALSO;

while ( (Lista[ApJ!=Valor)&&(Ap<lnd) ) Ap++;

if ( Ap>=lnd ) *Esta = FALSO;

1 }/* Buscavalor */

34


/* Esta función altera aleatoriomente un patron en un porcentaje dado por el parametro PorcAlteración */

void AlteraPatron(int PatronSel[l20],int PatronAlt[l20],int PorcAlteracion) {

int Ap,i,lnd,Valor,Esta,Cant; int Lista[l20];

Cant = (N*PorcAlteracion)/lOO; for ( Ap=O ; ApcN ; Ap++ )

Ind = O; while ( IndcCant ) {

PatronAlt[Ap] = PatronSel[Ap];

Valor = random(N); BuscaValor(Lista,Valor,lnd,&Esta); if ( !Esta ) {

Lista[lnd] = Valor; Ind++;

1 1 for ( ¡=O ; ¡<Cant ; i++ ) {

if ( PatronAlt[Lista[i]] == -1 )

else PatronAlt[Lista[i]] = 1 ;

PatronAlt[Lista(i]] = -1 ; 1

}/* AlteraPatron */

/* Esta función guarda la representación de un patron en un archivo de texto *I

void GuardaPatron(int Arreglo[],char NornArchI]) {

int Ind; FILE *Salida;

if ( (Salida=fopen(NomArch,"wt"))!=NULL ) { for ( Ind=O ; lnd420 ; Ind++) {

switch (Arreglo[lnd]) { case 1 : fprintf(Salida,"O");

break; case -1 : fprintf(Salida,"l");

break; default : break;

1 1 fclose(Sa1ida);

1 else {

printf("E1 archivo no se abrio ... \n"); 1

35


}/* GuardaPatron */ /* CalculaMatrizT : */

void CalculaMatrizT(int MatrizP[M][120],int MatrizT[120][120]) {

int i,j,s;

for ( ¡=O; icN ; i++ ) for (j=O; jcN ; j++ ) {

MatrizT[i][j] = O; i f ( i ! = j ) {

for ( s=O ; s<M ; S++ ) MatrizT[i]Lj] =

MatrizT[i)[j] + MatrizP[s][i]*MatrizP[s]h]; 1

}/* for */ }/* CalculaMatrizT *I

/* InicializaSalida : Esta funcion solo copia un vector en otro “I

void InicializaSalida(int PatronEnt[l20],int PatronSal[l20]) {

int Ind;

for ( Ind=O ; Ind<N ; Ind++ ) PatronSal[lnd] = PatronEnt[lnd];

}/* InicializaSalida *I

/* ActualizaSalida : Esta funcion realiza el calculo para los N nuevos valores de salida */

void ActualizaSalida(int MatrizT[120][120],int PatronAnt[l20], int PatronAct[l20],int Patronlnicial[l20],int Cont)

{ int Ind,i,Aux;

for ( Ind=O ; IndcN ; Ind++ ) { Aux = O; for ( i=O ; icN ; i++ )

if ( Cont==l )

else Aux = Aux + (MatrizT[i][lnd]*PatronAnt[i])+Patronlnicial[i];

Aux = Aux + (MatrizT[i][lnd]*PatronAnt[i])+F’atronAct[i]; if ( Aux>O )

else PatronAct[lnd] = 1;

PatronAct[lnd) = -1; 1

36


}/* ActualizaSalida */ /* RealizaComparacion : Esta funcion determina si se continua o no con el

proceso */

void RealizaComparacion(int PatronSal[l20],int PatronSalAc:t[l20],int *Continua) {

int Ind;

Ind = O; while ( (PatronSal[lnd] == PatronSalAct[lnd])&&(Ind<N) )

Ind++; if ( Ind==N )

*Continua = FALSO; }/* RealizaComparacion */

/* AlgoritmoDeHopfield : */

void AlgoritmoDeHopfield(int MatrizP[M][120],int Patronlnicial[l20], int PatronSalAct[l20],int *Cont)

{ int MatrizT[l20][120]; int Continua=CIERTO; int PatronSal[l20];

*Cont=O; CalculaMatrizT(MatrizP,MatrizT); InicializaSalida(Patronlnicial,PatronSalAct); do { (*Cant)++;

InicializaSalida(PatronSalAct,PatronSal); ActualizaSalida(MatrizT,PatronSal,PatronSal,kt,

RealizaComparacion(PatronSal,PatronSalAc~,&Continua); Patronlnicial,*Cont);

} while (Continua); }/* AlgoritmoDeHopfield */


Programa para simular la red de Carpenter-Grossberg El programa esta hecho para simular el comportamiento de M

muestras con N elementos por muestra, donde el valor de M es 5 y N es 35; auque el programa facilmente podria modificarse para cambiar estos valores.

En el programa las representaciones de las muestras se leen de archivos de texto. La trayectoria para estos archivos de texto es: c:\proyecto\carpent\entrada y los nombres de los archivos para las muestras ejemplo son EJEMPLOx.TXT y para las muestras que pueden ser proporcionadas por el usuario MUESTRAx.TXT.

El usuario puede hacer pruebas con sus propios patrones modificando las archivos MUESTRAx.TXT. Como se podrá apreciar si se editan estos archivos, estos .son solo una línea de texto conteniendo O's y 1 'S, con la única condición que el número de O's o 1 'S debe ser N.

El numero de muestras y de elementos por muestra puede variar y para alguien interesado en hacer pruebas puede modificarse fácilmente el código fuente del programa.

Para correr el programa se requieren 3 parámetros en la línea de comandos, como se muestra. CNornbreDelPrograma Opción ValorDeRHO:* Donde: NombreDelPrograma: Es el nombre del programa ejecutable Opción: Puede ser el valor O(muestras ejemplo) o l(muestras del usuario) VaiorDeRHO: Es el valor de RHO el cual debe ser un valor real entre O Y 1.

Ejemplo : CARPENT O 0.9 Esto significa que se esta corriendo el programa ejecutable

llamado CARPENT, empleando las muestras proporcionadas como ejemplo y con un valor para RHO de 0.9.

38


#include <stdio.h> #include cconio.h> #include <stdlib.h> #include <process.h> #include <math.h> #include <ctype.h> #include <string.h>

#define CIERTO 1 /* Constante empleada como un valor booleano */ #define FALSO O /* Constante empleada como un valclr booleano */ #define M 4 /* Número de muestras */ ##define N 35 I* Número de elementos por muestra */ #define B-IN1 0.02777778 /* l /(N+l) */

#define NUMENTEJEMPLO 5 /* Nfmero de muestras del ej'emplo */ #define NUMENTMUESTRAS 5 /* N f mero de muestras proporcionadas por el usuario */

struct text-info Iniciallnfo;

/* Definicien de los encabezados de las funciones */

void ValidaArgumentosDeEntrada(int argc,char *argvn,float *RHO); int ValidaNumEntrada(void); void LeeMuestra(char NomArchnjnt VectorX[]); void MuestraEntradasDisponibles(char Indicador!); void LeeEntrada(char Indicador0,int VectorX[]); void ComputeMatchingScores(f1oat MatrizB[N][M],int VectorX[N],float VectorU[M]); void SelectBestMatchingExemplar(f1oat VectorU[M],int *India?J); void VigilanceTest(int VectorX[N],int MatrizT[N][M],int lndiceJ,float RH0,int *EsMayor); void TemporarilySetToZero(f1oat MatrizB[N][M],int IndiceJ,float MatrizAuxiliar[N][M],int Arreglolndicador[M]); void AdaptBestMatchingExemplar(int MatrizT[N][M],int VectorX[N],int IndiceJ,float MatrizB[N][M]); void EnableNodes(f1oat MatrizAuxiliar[N][M],float MatrizB[N][hA],int Arreglolndicador[M]); void MuestraVectorX(int VectorX[N],int x0,int y0,char Titulo[); void MuestraMatrizT(int MatrizT[N][M]);

39


/* Este programa tiene como objetivo simular el comportamiento de la red de

*/ Carpenter-Grossberg

void main(int argc,char *argv[]) {

static int MatrizT[N][M] = {

40


I* Este programa tiene como objetivo simular el comportamiento de la red de

*I Carpenter-Grossberg

void main(int argc,char *argv[) {

static int MatrizT[N][M] = {

40


static float MatrizAuxiliar[N][M] = {

I;

static float MatrizB[N][M] = {

{B_INI,B_INI,B_INI,B_INI), {B_INI,B_lNl,B_INl,B_INI}, {B_INI,B_INI,B_INI,B_INI), {B_lNl,B_lNl,B_lNl,B_INI}, {B_INI,B_INI,B_INI,B_INI), {B~lNl,B~lNl,B_lNI,B_INI}, {B~lNl,B~lNl,B_lNl,B_INI), {B_lNl,B_lNl,B_lNI,B_lNI},

41


{B_lNl,B_lNI,B_INI,B_lNI}, {B_lNl,B_lNl,B~lNI,B_INI), {B_INI,B_INI,B_INI,B_lNI}, {B_INI,B_INI,B_INI,B_INI}, {B_INI,B_INI,B_INI,B_INI}, {B_INI,B_INI,B~INI,B_INI}, {B_INI,B_INI,B_INI,B_INI}, {B_INI,B_INI,B_INI,B_INI}, {B~lNl,B_lNl,B~lNl,B~lNI}, {B_lNl,B~lNl,B_lNl,B~INI},

{B_INI,B_INI,B_INI,B~INI}, {B_INI,B_INI,B_INI,B_INI}, {F3_INl,6_lNI,B_INI,B~INI}, {B_lNl,B_lNl,B_lNl,B_INI), {B~INl,B_INI,B_INl,B~INI}, {B_INI,B_INI,B_INI,B_INI}, {B_INl,B~lNl,B~lNl,B_INI), {B_lNl,B~lNl,B_lNl,B~iNI}, {B_INl,B~INI,B_INI,B_INI}, {B_INI,B_INI,B_INI,B_INI},

static int Arreglolndicador[M] = {O,O,O,O};

int IndiceJ,EsMayor,VectorX[N]; float RHO,VectorU[M];

ValidaArgumentosDeEntrada(argc,argv,&RHO); gettextinfo(&lnicialInfo); textcolor@VHITE); textbackground(6LUE); MuestraEntradasDisponibles(argv[l]); LeeEntrada(argv[l],VectorX); for(; ; 1 {

CornputeMatchingScores(MatrizB,VectorX,VectorU); SelectBestMatchingExernplar(VectorU,&lndiceJ); VigilanceTestO/ectorX,MatrizT,lndiceJ,RHO,&EsMayor); if ( !EsMayor) {

TemporarilySetToZero(MatrizB,IndiceJ,MatrizAuxiliar, Arreglolndicador);

}

42


else {

AdaptBestMatchingExemplar(MatrizT,VectorX,lndiceJ,

EnableNodes(MatrizAuxiliar,MatrizB,Arreglolndicador); MatrizB);

gotoxy(2,17); printf("Ultima"); gotoxy(2,18); printf("Entrada"); MuestraVectorX(VectorX,10,14,"");

gotoxy(l7,17); printf("Muestras"); MuestraMatrizT(Matriz~; LeeEntrada(argv[l],VectorX);

1 J

}/* for */ textmode(lnicial1nfo.currmode);

}/* main */

/* Esta funci$n tiene como objetivo validar los parametros de entrada al programa.

Entrada : Argumentos de entrada de la linea de comandos Salida : Valor validado para RHO

*/

void ValidaArgumentosDeEntrada(int argc,char *argv[J,float *RHO) {

1 h'3;

clrscro; if ( argc!=3 ) {

printf("Nfmer0 de parametros incorrecto ...by; printf("La linea de comandos debe ser : \n\n"); printf("<NombreDelPrograma Opcion ValorRHO>\n\n"); printf("Donde ... \n\n"); printf("NombreDe1Programa : CARPNEW\n"); printf("0pcion : O (Ejemplo), 1 (Muestras Propias)\n"); printf("ValorRH0 : Valor Real en [O,l]\n"); exit (O);

1 else {

switch ( atoi(argv[l]) ) { case O : break;

, case 1 : break; default : printf("E1 parametro 2 es incorrecto ... \n");

printf("Su valor debe ser O o

exit (O); break;

1 if ( (atof(argv[2])<0)[[(atof(argv[2])>1) ) {

printf("E1 parametro 3 es incorrecto ... \n\n");

43


printf("Su valor debe ser real\n"); printf("y estar en el intervalo [O,l]\n"); exit (O);

1 else {

1 *RHO=atof(argv[2]);

1 }/* ValidaArgumentosDeEntrada */

/* Esta funcien tiene como objetivo validar que la entrada que sera leida de un archivo sea valida. La funci$n pregunta al usuario si se desea continuar, si la respuesta es NO, el programa termina; en caso contrario se valida que la entrada seleccionada sea valida.

*I

int VaIidaNumEntrada(void) {

int NumEntrada; char Respuesta,Car; char NumEntradaCad[3]="1 O\O";

do { gotoxy(2,22);príntf(""Desea continuar (S/N) : 'I); Respuesta=toupper(getcheO);

} while ( Respuesta!='N' && Respuesta!='S' ); if ( Respuesta=='N' ) {

exit (O); 1 else {

do { gotoxy(2,23);printf("Numero de entrada : "); if ( isdigit(Car=getcheO) ) {

NumEntradaCad(O]=Car; NumEntradaCad[l]='\O';

1

NumEntrada=atoi(NumEntradaCad); if ( (NurnEntradacl) 11 (NumEntrada>S) ) {

gotoxy(2,25);printf("La entrada debe ser un valor entero en [l ,S]");

1 }while( ((NumEntrada)<l) 11 ((NumEntradapS) );

1 return NumEntrada;

}/* ValidaNumEntrada */

44


I* Esta funcien tiene como objetivo leer una entrada de un archivo */

void LeeMuestra(char NomArch[],int Vector><[]) {

int i; FILE *Arch; char Caracter;

if ( (Arch=fopen(NomArch,"rt"))==NULL ) { printf("Error al tratar de abrir el archivo ... \n"); exit (O);

1 else {

)I* else

¡=O; do {

Caracter=getc(Arch); if ( Caracter=='O' ) {

1 VectorX[i++]=O;

if ( Caracter=='l' ) {

1 VectorX[i++]=l ;

}while( !feof(Arch) ); fclose(Arch); *I

I/* LeeMuestra */

/* Esta funcign muestra en modo texto las entradas que pueden estar

*I disponibles desde un conjunto de archivos

void MuestraEntradasDisponibles(char Indicadorn) {

int VaIorlx0=26,y0=5,lnd,Aux; int VectorX[N]; char CadAux[3];

static char NomArchEjemplo[5][50] = {

rc:\\proyecto\\carpent\\entrada\\ejemplol .txt\O"},

("c:\\proyecto\\carpent\\entrada\\ejemplo5.txt\O"} 1:

45


static char NomArchMuestra[5][50] = {

{"c:\\proyecto\\carpent\\entrada\\muestral .txt\O"},

Valot=atoi(lndicador);

clrscro; gotoxy(l5,2); printf("Programa para simular la red de Carpenter-Grossberg"); gotoxy(2,8); printf("Entradas"); gotoxy(2,9);printf("Disponibles"); switch (Valor) {

/* Para el ejemplo */

case O : for ( Ind=O ; IndcNUMENTEJEMPLO ; Ind++ ) {

LeeMuestra(NomArchEjemplo[lnd],VectorX); Aux=lnd+l; itoa(Aux,CadAux, 1 O);

MuestraVectorX(VectorX,xO,yO,CadAux); xO=xO+7;

1; break;

/* Para las muestras proporcionadas por el usuario *I

case 1 : for ( Ind=O ; IndcNUMENTMUESTRAS; Ind++ ) {

LeeMuestra(NomArchMuestra[lnd],VectorX); Aux=lnd+l ; itoa(Aux,CadAux,l O);

MuestraVectorX(VectorX,xO,yO,CadAux); xO=xO+7;

1; break;

default : break; }/* switch */

} P MuestraEntradasDisponibles */

46


/* Esta funcign lee una entrada a partir de un archivo. Aqui se tiene en cuenta el valor del argumento el cual indica si la entrada ser leida del conjunto de muestras ejemplo o bien del conjunto de muestras dado por el usuario (dando la opcign de terminar el programa antes de leer la entrada

*I

void LeeEntrada(char Indicador[],int VectorX[]) {

static char NomArchEjemplo[5][50] = {

("c:\\proyecto\\carpent\\entrada\\ejemploí .txt\O"},

static char NomArchMuestra[5][50] = {

{"c:\\proyecto\\carpent\\entrada\\muestral .txt\O"},

int NumEntrada,Valor;

Valot=atoi(lndicador);

switch (Valor) {

/* Para el ejemplo */

case O : NumEntrada=ValidaNumEntradaO; LeeMuestra(NomArchEjemplo[NumEntrada-l],VectorX); break;

/* Para las muestras del usuario *I

47


case 1 : NurnEntrada=ValidaNumEr:tradaO; LeeMuestra(NomArchMuestra[NumEntrada-l],VectorX); break:

default : break; }/* switch *I

}/* LeeEntrada */

/* Esta funci$n es la implementaci$n del paso 3 del algoritmo para la red de


void ComputeMatchingScores(f1oat MatrizB[NJ[M],int VectorX[N],float VectorU[M]) {

int iJ;

for ( j = O : j<M ; j++ ) { VectorUh]=O; for ( i=O ; ¡<N ; i++ )

VectorU[j] = VectorUo] + MatrizB[i][j] * VectorX[i]: I

}/* ComputeMatchingScores */

/* Esta funci$n es la implementaci$n del paso 4 del algoritmo para la red de


void SelectBestMatchingExemplar(f1oat VectorU(M1,int *IndiceJ) {

int ¡=O; float Maximo;

*IndiceJ = O; Maximo = VectorU[i]; for ( ¡=I ; icM ; i++ )

if ( VectorU[i]>Maximo ) { Maximo = VectorU[i];

I 'IndiceJ = i;

}/* SelectBestMatchingExemplar */

48


/* Esta funcig!n es la implementaci#n del paso 5 del algoritmo para la red de


void VigilanceTest(int VectorX[N],int MatrizT[N][M],int IndiceJ,float RHO, int "EsMayor)

{ float Razon,NormaX=O.O,NormaTPuntoX=O.O; int i;

*EsMayor=FALSO; for ( i=O ; ¡<N ; i++ ) {

NormaX = NormaX + VectorX[i]; NormaTPuntoX = NormaTPuntoX + MatrizT[i][lndiceJ]*VectorX[i];

1 if ( NormaX==O ) {

exit (O); 1 else {

Razon = NormaTPuntoNNormaX; if ( RazowRHO )

*EsMayor = CIERTO; 1

}/* VigilanceTest */

/* Esta funcien es la implementacig!n del paso 6 del algoritmo para la red de


void TemporarilySetToZero(f1oat MatrizB[N][M],int IndiceJ,

Arreglo!ndicador[M]) {

float MatrizAuxiliar[N][M],int

int i;

Arreglolndicador[lndiceJ]=l; for ( i=O ; icN ; i++ ) {

MatrizAuxiliar[i][lndiceJ1 = MatrizB[i][lndiceJ]; MatrizB[i][lndiceJ) = 0.0;

} }/* TemporarilySetToZero */

4s


/* Esta funcien es la implementaci$n del paso 7 del algoritmo para la red de


void AdaptBestMatchirigExemplar(int MatrizT[N][M],int VectorX[N],int IndiceJ,float MatrizB[N][M]) {

float Denominador; int i,NormaTPuntoX=O.O;

for ( ¡=O ; ¡<N ; i++ )

Denominador = 0.5 + NormaTPuntoX; for ( ¡=O ; ¡<N ; i++ )

for ( i=O ; ¡<N ; i + + )

}/* AdaptBestMatchingExemplar */

NorrnaTPuntoX = NormaTPuntoX + MatrizT[i][lndiceJ]*VectorX[i];

MatrizB[i][lndiceJ] = (MatrizT(i][lndiceJ]*VectorX[i])/Denominador;

MatrizT[i][lndiceJ] = MatrizT[i][lndiceJ]*VectorX[i];

/* Esta funci@n es la implementaci$n del paso 8 del algoritmo para la red de


void EnableNodes(f1oat MatrizAuxiliar[NJ[M],float MatrizB[N][M], int Arreglolndicador[M])

{ int i,lnd; float Auxiliar:

for ( Ind=O ; Ind<M ; Ind++ ) { if ( Arreglolndicador[lnd]==l ) {

for ( i=O ; ¡<N ; i++ ) { Auxiliar = MatrizAuxiliar[ij[lnd]; MatrizAuxiiiar[i][lnd] = MatrizB[i][lnd]; MatrizB[i][lnd] = Auxiliar;

Arreglolndicador[lnd]=O; 1

}/* for */ }/* EnableNodes */

50

Redes neuronales de eptrada binaria

/* Esta funci$n solo despliega en modo caracter la representaciGn de una

*/ muestra

void MuestraVectorX(int VectorX[N],int x0,int y0,char Titulo[]) {

int i,lnd; int x,y;

i = o; x = xo; Y = yo;

gotoxy(xO+Z,yO-l); printf("%s",Titulo); while ( ¡<N ) {

for ( Ind=O; lndc5 ; Ind++ ) { if ( VectorX[i]==l ) {

} else {

I i++; x++;

gotoxy(x,y); printf("k");

gotoxy(x,y); printf(" ");

1 x = xo; y++;

}/* MuestraVectorX */ }/*while */

/* Esta funci$n solo despliega un conjunto de muestras, las cuales se

*/ encuentran almacenadas en la MatrizT

void MuestraMatrizT(int MatrizT[N][M]) {

int i,lnd,lnd2; int x0=26,y0=14; int x,y;

i = o; x = xo; Y = Yo;

for ( lnd=O ; hd<M ; Ind++ ) { ¡=O; gotoxy(x0+2,y0-1); printf("M%d",lnd); while ( ¡<N ) {

for ( lnd2=0 ; l n d 2 4 ; Ind2++ ) { if ( MatrizT[i][lnd]==l ) {

Redes neuronales d e entrada binaria -

/* Esta funcign solo despliega en modo caracter la representacign de una

*/ muestra

void MuestraVectorX(int VectorX[N],int x0,int y0,char Titulo[]) {

int i,lnd; int x,y;

i = o; x = xo; Y = Yo;

gotoxy(x0+2,y0-1); printf("%s",Titulo); while ( ¡<N ) {

for ( Ind=O; l n d 4 ; Ind++ ) { if ( VectorX[i]==l ) {

1 else {

1 i++; x++;

gotoxy(x,y); printf("k");

gotoxy(x,y); printf(" ' I ) ;

1 x = xo; y++;

I/* MuestraVectorX */ }/* while */

/* Esta funcien solo despliega un conjunto de muestras, las cuales se

*I encuentran almacenadas en la MatrizT

void MuestraMatrizT(int MatrizT[N][M])

int i,lnd,lnd2; int x0=26,y0=14; int x,y;

i = o; x = xo; Y = yo;

for ( Ind=O ; IndcM ; Ind++ ) { ¡=O; gotoxy(x0+2,y0-1); printf("M%d",Ind); while ( ¡<N ) {

for ( lnd2=0 ; l n d 2 ~ 5 ; lnd2++ ) { if ( MatrizT[i][lnd]==l ) {

51


ibliografia 1. An introduction to Computing with Neural Nets

Richard P. Lippmann /E€€ ASSP Magazine, April 1987

2. Neural Networks, Algorithms, Applications and Programming Techniques

James A. Freeman David M. Skapura

3. Neurocomputing Robert Hetch-Nieisen Addison- Wesley

4. Fundamentals of Neural Networks, Architectures, Algorithms and Applications Laurene Fausett Prentice Hall

5. Turbo C Reference Guide Borland lnternational

53

'1148.206.53.84/tesiuami/Complemento primer lote/UAM0116.pdf · neuronales tales como la red de...

Documents

Transcript of '1148.206.53.84/tesiuami/Complemento primer lote/UAM0116.pdf · neuronales tales como la red de...