UNIVERSIDAD AUTON,OMA METROPOLITANA iztapalapa

CIENCIAS BÁSICAS E INGENIERÍA

PROYECTO DE INVESTIGACI~N .. , ,

LICENCIATURA EN COMPUTACI~N

CONTROL DE UN ROBOT CON UNA RED NEURONAL

Responsables del proyecto:

Angel Hernandez Rivera 92223742

Gustavo Silva Santos 93222201

M.C. Joel Ricardo Jiménez Cruz

IZTAPALAPA, DISTRITO FEDERAL, A 09 DE FEBRERO DE 1999

.

CONTENIDO

1)

11) Redes neuronales artificiales

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Introducclon

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

e La neurona y la sinapsis .....................

111) El simulador Khepera versión 2.0 . . . . . . . . . . . . .

o El simulador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . .

. . .

. . .

. . .

....................... 1

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

. . . . . . . . . . . . . . . . . . 5

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

e Red neuronal utilizada en el ejemplo 2 del simulador . . . . . . . . . . . . . . . . . . 16

e Contenido archivo Robot (file.robot) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

IV) Redes de retropropagación 30

0 Algoritmo de retropropagación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

V) Obtención de patrones de entrada y salida 33

VI) Código de la red de retropropagación en lenguaje ANSI C 36

VII) Implantación del código de la red en el simulador . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

VIII) Resultados y conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

u0 Blbllografía 53

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

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

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

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

1

1) Introd ucci6n

El hombre siempre ha tenido interés por conocerse a sí mismo y al mundo que lo rodea y este interés ha sido uno de los motores que le ha permitido, en su estancia relativamente corta sobre la tierra, lograr una transformación tan grande del mundo. Esta transformación se ha llevado a cabo primero muy lentamente, a lo largo de miles de años, y después, de una forma cada vez más acelerada. Así, tenemos que durante este siglo se ha logrado un gran avance en el conocimiento de la naturaleza hndamental de la materia, y por otro, la ciencia se ha involucrado, muy prohndamente, con la industria y la agricultura. Algunas de las características que describen el desarrollo científico - técnico del presente siglo son el inicio de la producción en serie, el control automático de los procesos industriales, la disponibilidad y control de la energía, la aparición de los medios de comunicación masiva y la substitución del hombre en la ejecución de ciertos trabajos por máquinas o dispositivos electrónicos.

Uno de los desarrollos más sobresalientes del siglo XX es el de las computadoras. Estos han sido tan importantes que a menudo nuestra época se denomina “la era de las computadoras”. Las computadoras han sido, por un lado, un logro técnico de primera línea, y por otro han desempeñado un papel muy importante por sí mismas. Primero, en el avance de la ciencia, ya que constituyen una herramienta muy útil en la investigación científica. Segunda, en el desarrollo tecnológico, ya que han contribuido como herramienta de diseño e instrumento de control en los procesos industriales. Y tercero, han contribuido como medio para el manejo y almacenamiento de la información.

El uso de las computadoras no ha quedado restringido a los ámbitos técnico, científico y administrativo. En los últimos años su existencia ha cambiado radicalmente nuestras vidas, pues ahora forman parte esencial de la mayoría de los aspectos del quehacer humano.

En la actualidad, una computadora pequeña es capaz de efectuar, en cuestión de segundos, una cantidad tal de operaciones matemáticas, que a un hombre le tomaría meses o años realizarlas. Sin embargo, hay otro tipo de trabajos para los cuales las computadoras están claramente en desventaja. Estas tareas suponen la solución de problemas que se caracterizan por tener un gran número de soluciones, y por no ser posible dar instrucciones concretas para encontrarlas. En lo sucesivo denominaremos a estos problemas complejos’.

Entre los problemas complejos, tenemos los de optimización o toma de decisiones, de reconocimiento, etcétera. Por ejemplo, “un niño de tres años es mucho más eficiente reconociendo imágenes como caras de personas, que una poderosa computadora que trabaja con los programas más elaborados. Asimismo, un niño es capaz de efectuar generalizaciones y clasificar imágenes que nunca ha visto, mediante el uso de elementos extraídos de la experiencia previa, es decir, haciendo comparaciones y analogías entre el

I Aquí la palabra “complejo” no se utiliza como sinónimo de “complicado”. Pam evitar confusiones entre ambas acepciones, !as pondremos en itálicas.

2

contenido de una imagen nueva que se presenta y el contenido de las imágenes que ha visto en el pasado'.

El origen de esta diferencia de eficacia radica en que los procedimientos utilizados por los humanos y las computadoras son en esencia de carácter diferente. Las computadoras trabajan ejecutando instrucciones precisas. Las cuales pueden definirse de una manera sucinta en un algoritmo o receta del procedimiento a seguir. Una computadora puede ser programada para hacer comparaciones, pero es necesario que el programador defina, de manera concisa y exhaustiva, todos los criterios necesarios para efectuar dichas comparaciones.

Muy recientemente ha regresado con mucha herza una disciplina llamada inteligencia art!'fcial. La inteligencia artificial es el estudio de los problemas complejos de procesamiento de información que a menudo tienen sus raíces en algún aspecto del procesamiento biológico de la información. El objetivo de esta disciplina es identificar problemas interesantes y resolubles del procesamiento de información para solucionarlos.

El campo de la inteligencia artificial se divide actualmente en lo que parecen ser varios paradigmas en contienda. Los contendientes actuales difieren en lo que respecta a las formas que se necesitan para capturar todas las formas de inteligencia. Existen en general 2 visiones opuestas, cada una con su programa de investigación correlativo. Una fracción ve a las computadoras como sistemas para manipular símbolos mentales, ésta busca usar las computadoras para instanciar una representación formal del mundo y toma la resolución de problemas como su paradigma de inteligencia. La otra, ve a las computadoras como un medio para modelar el cerebro, para simular las interacciones de las neuronas, utilizando la estadística como su paradigma de inteligencia.

El hombre se ha caracterizado siempre por una búsqueda constante de nuevas vías para mejorar sus condiciones de vida. Estos esherzos le han servido para reducir el trabajo en aquellas operaciones en las que la herza juega un papel primordial. Los progresos obtenidos han permitido dirigir estos esfberzos a otros campos, como por ejemplo a la construcción de máquinas calculadoras que ayuden a resolver de forma automática y rápida determinadas operaciones que resultan tediosas cuando se realizan a mano.

Uno de los primeros en acometer esta empresa fue Charles Babbage, quien trató infiuctuosamente de construir una máquina capaz de resolver problemas matemáticos. Posteriormente otros tantos intentaron construir máquinas similares, pero no h e hasta la segunda guerra mundial, cuando ya se disponía de instrumentos electrónicos, que empezaron a recoger los primeros frutos. En 1946 se construyó la primera computadora electrónica, ENIAC. Desde entonces los desarrollos en este campo han tenido un auge espectacular.

Estas máquinas permiten implementar fácilmente algoritmos para resolver multitud de problemas que antes resultaban engorrosos de resolver. Sin embargo, se observa una limitación importante: ¿qué ocurre cuando el problema que se quiere resolver no admite un

' Viana. Laura. "Mmoria naturaly artIfjdne'. pp. 1 S, !W5, Fondo de Cultura Econbmica.

tratamiento algorítmico, como es el caso, por ejemplo, de la clasificación de objetos por rasgos comunes?. Este ejemplo demuestra que la construcción de nuevas máquinas más versátiles requiere un enfoque del problema desde otro punto de vista. Los desarrollos actuales de los científicos se dirigen hacia el estudio de las capacidades humanas como una fuente de nuevas ideas para el desarrollo de estas máquinas, Así, la inteligencia artificial es un intento por descubrir aspectos de la inteligencia humana que pueden ser simulados mediante máquinas. Esta disciplina se ha desarrollado füertemente en los últimos años teniendo aplicación en algunos campos como visión artificial, demostración de teoremas, procesamiento de información expresada mediante lenguajes humanos, etcétera.

Uno de los paradigmas de la inteligencia artificial se ve concretado en los llamados sistemas expertos. Un sistema experto es un método para capturar la experiencia humana el cual consiste en tres subsistemas interconectados.

1. Una base de datos de conocimientos, que comprende hechos, supuestos, creencias, heurísticas3 y métodos para tratar con la base de datos para alcanzar los resultados deseados, tales como un diagnbstico, una kterpretación o una solución a un problema.

2. Una base de datos, una colección de datos sobre objetos y sucesos sobre la cual la base de conocimientos ha de operar para alcanzar los resultados deseados.

3 . Una máquina de inferencia, que permite trazar inferencias a partir de las interacciones entre el conocimiento y las bases de datos.

El modo de operación es el siguiente: se presenta un problema al sistema, que solícita datos de quien efectúa la consulta, y eventualmente, ofrece consejos para llegar a la solución. A veces se puede preguntar al sistema en lenguaje natural, lo que hace que sea no solamente valioso para profesionales ocupados, sino que lo torna en un perfecto dispositivo de instrucción para novatos.

Una ley cualitativa de la inteligencia artificial que se ve resuelta por los sistemas expertos es que resuelven problemas generando soluciones potenciales y las prueban mediante una búsqueda. Las soluciones se buscan por lo general creando soluciones simbólicas y modificándolas secuencialmente hasta que satisfagan las condiciones de una solución. Así, los sistemas de símbolos resuelven problemas a través de una búsqueda. Sin embargo, como los problemas tienen recursos finitos, la búsqueda no puede efectuarse de una sola vez, debe ser secuencial. Deja tras de sí una sola trayectoria a partir del punto de inicio hasta la meta o, si se requieren correcciones y sustituciones, todo un árbol de esas trayectorias.

Objetivo de este proyecto.

La finalidad que nos hemos propuesto en este proyecto es la de llevar acabo la implantación de una red neuronal de retropropagación para el control de un pequeño robot

3 La palabra heurística se refiere al “conocimiento experto”, es decir. a las reglas generales que siguen los

expertos en la materia para resolver un problema.

llamado Khepera. El cual cuenta con un simulador" que muestra el ambiente en el que se desenvuelve el robot y los datos que tiene en cada instante del robot. El simulador fbnciona bajo el ambiente Linux. Este simulador está escrito en lengzje C estándar. El códigii de la red neuronal también será escrito en este lenguaje.

Dicha red neuronal se implanta en el código del simulador, el cual por la manera en que está diseñado permite la manipulación del robot de manera fácil con solo introducir código en algunas funciones.

La red neuronal de retropropagación que se implantará tiene por objetivo hacer que el robot Khepera evite obstáculos, en los diferentes ambientes que se le presenten.

Para cumplir este objetivo se estudia primero como funcionan las redes neuronales y en especial el algoritmo de retropropagación. Posteriormente se analiza a fondo el funcionamiento de una red neuronal que trae de ejemplo el software del simulador del robot Khepera, ya que éste utiliza la mayoría de las funciones que se permiten modificar. Por último se hace un análisis sobre el hncionamiento del robot para la adaptación del algoritmo de la red al robot y así poder llevar acabo la implantación de la red en el simulador indicando que funciones o procedimientos se afectaran.

11) Redes neuronales artificiales.

Las redes neuronales artificiales son una forma de emular otra de las características propias de los humanos: la capacidad de memorizar y asociar hechos. Si examinamos con atención aquellos problemas que no pueden expresarse a través de un algoritmo nos daremos cuenta que todos ellos tienen una característica común: la experiencia. El hombre es capaz de resolver estas situaciones acudiendo a la experiencia acumulada. Así, parece claro que una forma de aproximarse al problema consista en la construcción de sistemas que sean capaces de reproducir esta característica humana. En definitiva, las redes neuronales no son mas que un modelo artificial y simplificado del cerebro humano, que es el ejemplo más perfecto del que disponemos de sistema que es capaz de adquirir conocimiento a través de la experiencia. Una red neuronal es “un nuevo sistema para el tratamiento de la información cuya unidad básica de procesamiento está inspirada en la célula fbndamental del sistema nervioso humano, la neurona”.

La neurona y la sinapsis.

El cerebro humano contiene aproximadamente 12 billones de células nerviosas o neuronas. Cada neurona tiene de 5,600 a 60,000 conexiones dendríticas provenientes de otras neuronas. Estas conexiones transportan los impulsos enviados desde otras neuronas y están conectadas a la membrana de la neurona. Cada neurona tiene una salida denominada axón. El contacto de cada axón con la dendrita se realiza a través de la sinapsis. Tanto el axón como las dendritas transmiten la señal en una única dirección.

6

La sinapsis consta de un extremo presináptico de un axón conectado a un extremo postsináptico de una dendrita, existiendo normalmente entre estos un espacio denominado espacio sináptico.

Las neuronas son eléctricamente activas e interactúan entre ellas mediante un flujo de corrientes eléctricas locales. Estas corrientes se deben a diferencias de potencial entre las membranas celulares de las neuronas. Un impulso nervioso es un cambio de voltaje que ocurre en una zona localizada de la membrana celular. El impulso se transmite a través del axón hasta llegar a la sinapsis, produciendo la liberación de una sustancia química denominada neurotransmisor que se esparce por el fluido existente en el espacio sináptico. Cuando este fluido alcanza el otro extremo transmite la señal a la dendrita. Los impulsos recibidos desde la sinapsis se suman o restan a la magnitud de las variaciones del potencial de la membrana. Si las contribuciones totales alcanzan un valor determinado (alrededor de 10 milivoltios) se disparan uno o más impulsos que se propagarán a lo largo del axón.

Aunque todavía no está del todo claro, parece que este impulso se inicia en la conexión entre el axón y la membrana. Su amplitud y velocidad dependen del diámetro del axón y su frecuencia del número de disparos que se efectúen.

Las redes neuronales artificiales basan su fkcionamiento en las redes neuronales reales, estando formadas por un conjunto de unidades de procesamiento conectadas entre sí. Por analogía con el cerebro humano se denomina “neurona” a cada una de estas unidades de procesamiento. Cada neurona recibe muchas señales de entrada y envía una única señal de salida (como ocurre en las neuronas reales).

Uno de los primeros modelos matemáticos de una neurona h e el propuesto por McCulloch y Pitts en 1943 y es en el que se basan las redes neuronales actuales.

Las redes neuronales tiene dos faces:

Aprendizaje: Se utiliza un conjunto de patrones de entrenamiento para determinar

Prueba: Ya que está entrenada, se hace la prueba de la red en la que se presentan los pesos de las sinapsis.

los patrones y se analiza el funcionamiento de la red.

El aprendizaje de una red se puede producir de tres formas:

0 Aprendizaje supervisado: Consiste en introducir una serie de patrones de entrada a la red y a su vez mostrar la salida que se quiere tener. La red es capaz de ajustar los pesos de las neuronas de forma que a la presentación posterior de esos patrones de entrada la red responde con salida memorizada. Aprendizaje no supervisado: Se presentan los patrones de entrada a la red y esta los clasifica en categorías según sus rasgos más sobresalientes.

0 Aprendizaje autosupervisado: La propia red corrige los errores en la interpretación empleando una realimentación.

7

Una de las primeras reglas de aprendizaje h e propuesta por Donald Hebb en 1949, y se basa en un hecho biológico constatado: cuando dos neuronas se activan simultáneamente su conexión se refuerza. Esta idea se expresa matemáticamente como:

dw, I dt alpha Si Xj

En una red neuronal existen tres tipos de capas de neuronas: La de entrada, la oculta y la de salida. También hay modelos que constan de una sola capa. Entre dos capas hay una serie de conexiones (sinapsis), como se mencionó anteriormente, que pueden ser total o parcialmente conectadas. También es posible conectar varias redes neuronales entre sí.

Las conexiones pueden ser hacia adelante, hacia atrás y de retardo

Capa de entrada

Capa interneda

Capa de salida

Red neuronal totalmente concectada.

Red neuronal parcialmente conectada.

8

111) El Simulador Khepera versión 2.0

El Simulador del robot khepera es un software de dominio público escrito por Oliver Michel en la Universidad de Nice Sophia-Antipolis.

Este software permite escribir algoritmos de control de cualquier tipo (redes neuronales, clasificadores, o cualquier otro que se pueda imaginar) utilizando los lenguajes c o c++.

El simulador provee una librería de funciones que permite manejar al robot, además de mostrar sus resultados.

El simulador.

El diagrama general de operación nos muestra una secuencia de instrucciones que realiza el simulador desde que arranca hasta el momento en que pulsamos el botón de salida.

D Principal + I Leer Archivo configuracibn 1

G Abrir Programa

+ 1 b o t h = Presionar B o t h

1 Robot.X=SOO Robot.Y=500 Robot.Alpha=PiM Robot.State=O

Una vez que el simulador se haya inicializado, prosigue el rastreo de 10s botones del simulador.

La pantalla del simulador está dividida en dos partes: la parte del mundo situada en la parte izquierda y la parte del robot encontrada al lado derecho. En la parte del mundo se puede observar el desenvolvimiento del robot en su ambiente, mientras que en el área del robot se puede observar lo que ocurre dentro del mismo (sensores, motores y controlador).

Diferentes mundos están disponibles en el directorio SIM/WORLD/. Para poder ver alguno de ellos se debe presionar el botón “koad” y escribir el nombre del robot (sin la extensión.world). Es mas, es posible editarlo o diseñar un mundo totalmente nuevo presionando el botón “new”. Los mundos resultantes se pueden guardar utilizando el botón “save ”. Ladrillos y lámparas son situados en el mundo construyendo así laberintos de mayor o menor complejidad.

11

El área del mundo representa en escala un mundo de 1 m x 1 m

Para insertar un objeto, se debe seleccionar el tipo de objeto que se desea insertar utilizando para ello los botones “+” y “-“. Si se desea girar el objeto sobre sí mismo se debe presionar el botón “turn” las veces que sea necesario. A continuación, para insertar el objeto en algún lugar del mundo se debe presionar el botón ‘‘add” y arrastrar el objeto hasta el lugar deseado, presionando finalmente el botón add para terminar. Si se desea borrar algún objeto del mundo, se presiona el botón “remove” y se hace click en los objetos que se desea remover, y para salir del modo de borrado debe presionar nuevamente el botón ‘‘remo~~e ”. Una vez que los objetos se hayan colocado, es necesario presionar el botón “ S C L ~ ” antes de que el robot pueda percibirlos. Es posible checar que es lo que percibe el robot presionando el botón ’‘ ! ”.

Para situar al robot en algún lugar específico del mundo se debe presionar el botón “set robot ”, y a continuación se debe hacer click en el lugar en donde se desee localizar al robot.

La parte del robot contiene los botones que controlan la operación del mismo. Cada botón realiza una serie de acciones descritas con los siguientes diagramas.

i

I Leer Robot De Archivo 1 I

12

i

I

i

13

+ I n i c i a t i z a r S e n s o r e s

* 1 ~ o s t r a r S e n s o r e s I R I

I

1

RA o s t r a r E f e c t o r e s R o b o t

M o s t a r R o b o t P e q u e ñ o I

I l v I

-7 7, Inicializar Sensores

1

Corre Robot

+ 4

Robot.Valorfvlotores=O

I Mostrar efectores Robot 1

t

+

f

4 Leer Comando

4 Comando=Asignar Angulo

9 Comando de usuario

Robot.Angulo=Radianes(Angulo) , Mostrar Robot Pequeño

I

t B Boton Presionado

\I Iniciatiza Sensores

I

Mostrar Sensores IR

I I I

n Siguiente I

i Seleccionar Siguiente

T i p o Informacion 1 *

Mostrar Informacion I

v Boton Salir

c

En estos diagramas podemos encontrar tanto ia descripción de los procesos de los botones, como descripciones de los procesos auxiliares más importantes para la comprensión de la operación de! robot.

Los procesos que heron encerrados en cajas de doble raya indican las funciones que el usuario del simulador puede modificar para implantar su propio controlador.

:’:::_: Salir=Verdadero

16

Red neuronal utilizada en el ejemplo 2 del simulador.

La red neuronal encontrada en este ejemplo consta de una estructura conformada por una tabla, la cual contiene 3 diferentes tipos de estructuras que representan los diferentes componentes de la red. Estas estructuras están representadas en el esquema siguiente:

ESTRUCTURAS DE LA RED NEURONAL NEURONA

SlNAPSlS

La Estructura “RED NEURONAL” es la principal, ya que ella contiene los datos generales de la red, así como los apuntadores a las diversas capas que conforman a la red.

El “Número de sinapsis” y el “Número de neuronas” indican la cantidad total de estos elementos que posee la red. Los datos correspondientes a las tres diferentes capas de neuronas contienen un apuntador a la primer neurona de la capa especificada, a partir de ahí se genera una lista ligada de elementos “neurona”, lo cual permite una gran libertad en la cantidad de neuronas que pueden ser incluidas en cada capa, teniendo como única restricción la cantidad de memoria del sistema en donde será implantada la red.

Para nuestro caso de estudio se tienen 2 restricciones. Una capa de entrada de no más de 17 neuronas, lo cual corresponde a los ocho sensores IR de distancia junto con los ocho sensores IR de luz, además de una neurona inicial que no recibe información externa. Por otra parte se tiene una capa de salida de 4 neuronas como máximo, correspondientes a los valores positivos y negativos de velocidad que pueden asociarse a cada una de las dos ruedas con que cuenta el robot para su desplazamiento en el mundo virtual.

17

La estructura “NEURONA” contiene los datos referentes al “Tipo” de neurona (el cual no es utilizado en el ejemplo), la “Posición X e Y en la gráfica de la red” que se muestra en la pantalla de información del simulador, el “valor de salida” que representa el valor a pasar como información de propagación a la siguiente neurona, el “valor acumulado”, que es el que se incrementa con la propagación de las neuronas que comparten una sinapsis con esta neurona receptora, el ‘%xcin” que es un apuntador a la primer sinapsis de salida de esta neurona, de la cual se genera una lista ligada de elementos sinapsis hasta obtener todos los elementos de conexión sináptica de la neurona, y “Sigz~iente” que es un apuntador a neurona, necesario para la construcción de la lista ligada de neuronas que constituyen la capa a la cual pertenece la neurona mencionada.

La estructura “SINAPSIS” contiene los datos referentes al tipo de sinapsis, el cual tiene una relación directa con el peso asociado con esta sinapsis. El peso indica la fuerza de esta conexión sináptica entre neuronas. “Dirigida a” es un apuntador a neurona que indica hacia cual neurona se tiene la conexión sináptica, y “Siguiente” es un apuntador a sinapsis necesario para la construcción de la lista ligada de sinapsis relacionadas con el axón del cual surge esta sinapsis.

En la siguiente figura se muestra un pequeño esquema de posibles conexiones en la construcción de una red neuronal.

En este esquema se puede apreciar como la capa de neuronas de entrada es alimentada por los datos proporcionados por los sensores del robot, además es posible que

18

estas neuronas también sean alimentadas por información de sinapsis provenientes de neuronas de su misma capa o de capas inferiores.

La parte correspondiente a la forma de la red neuronal se muestra con un poco más de detalle en la siguiente figura.

Red Neuronal

¡=Número de neuronas de Entrada

h=Número de neuronas Ocultas

o=Número de neuronas de Salida

Aquí se muestra la forma en que están construidas las capas de la red neuronal y como se tiene una lista ligada asociada a cada una de ellas.

La figura nos muestra la forma en que los apuntadores contenidos en la estructura de la red neuronal solo apuntan al primer elemento de “neurona” y como a través del uso del apuntador “siguiente” de la neurona se forma la capa correspondiente. El apuntador “Axor2” estará conectado con la primer sinapsis de salida de esta neurona, o en su defecto apuntará a nulo en caso de que esta neurona no tenga ninguna sinapsis de salida asociada con su axón.

19

La lista ligada de neuronas correspondientes a cualquiera de las capas de la red tendrá una estructura como la representada en la siguiente figura.

Neuronas

I

J

En este diagrama se muestra la forma en que está construida la capa de neuronas. Aquí podemos ver como el “axón” de la neurona apunta a la primer sinapsis, y a partir de ella se genera la lista ligada, auxiliándose para ello del apuntador “siguiente” de la sinapsis. El apuntador ‘‘Dirigih a” apuntará a la neurona receptora de la información de la salida de la neurona a la que pertenece la sinapsis mencionada. Por otra parte el apuntador “siguiente” de la neurona permite realizar la construcción de la lista que representa la capa, donde finalmente el apuntador siguiente de la última neurona apuntará a NULO, representando con esto el fin de la lista.

20

Finalmente se tiene el elemento faltante para la descripción de la red, la sinapsis, la cual está representada en la siguiente figura.

Sinapsis (Neurona)

En este esquema podemos ver como la construcción de la lista ligada de sinapsis parte del axón de un elemento “neurona”. A continuación se tiene la unión de los elementos de la lista a través del uso del apuntador “siguiente” del elemento “sinapsis”. Observamos como cada sinapsis tiene dentro de su estructura su peso y su tipo asociado, así como el apuntador “Dzrigih a”. Aquí podemos ver como una neurona puede recibir información de dos o más sinapsis, sin embargo en este caso es dificil que se tengan asociadas más de una sinapsis por cada axón dirigidas a una sola neurona, ya que esto podría representarse con una sola sinapsis en donde su peso asociado hera la suma de los pesos de las sinapsis.

Para llevar a cabo la implantación de este modelo de redes el simulador, es necesario modificar las hnciones contenidas en el archivo user.c.

La primer fbnción analizada es la de Inicio Usuario, que es llamada al momento de iniciar la corrida del simulador. En este proceso se inicializa la red neuronal, se crea una configuración de red básica y se actualizan los valores generales de la red.

21

+ Crear Red Neural Loca

t Capa Entrada=Crear Neurona(9)

A Y

Capa Oculta=Crear Neurona(3) i

1 Capa Salida=Crear Neurona(2) t

1

Actualizar Red Neuronal

e Actualizar Pesos(Capas) - Actualizar Coordenadas

22

La función "Nuevo Robot" es llamada al presionar el botón "nuevo robot". Esta función abre un archivo que únicamente contiene una configuración de red, sin contener ningún dato adicional acerca del robot. A continuación se libera la memoria que utiliza la configuración de red que estaba cargada y finalmente se leen los datos del archivo y se carga en memoria la nueva configuración de red.

Cabe resaltar que el archivo "NEURAL/neural.network" es en particular diferente a los archivos grabados con la función de grabar robot, ya que está función graba además de la configuración de red, la configuración del robot en el momento en que se grabó.

Red Neuronal 2- > I

I Mostrar tnformacion Usuario(1,I) 1

I Abrir Archiva("Neural~neural.nehhlord") I t I Liberar Red Neurai 1

+ ICapa Entrada=Crear Neurona@-entrada)/

4

I Capa Salida=Cre& Neurona(n-salida) 1 I

1 Generar Sinapsís' Neuronas Entrada I I

1 I Generar Sinapsis Neuronas Salida I

' Actualizar ked Neural I +

FIN

Las funciones "cargar robot " y "guardar robot " son complementarias una de otra, y permiten leer y guardar el estado del robot en un determinado momento.

Estas fbnciones accesan a archivos con un formato de grabación preestablecido por el simulador para la parte del robot, y con formato a elección del usuario en la parte del archivo que contiene los datos del estado del controlador.

Escribir Red Neural A Archivo

4

k Crear Arreglo Neuronas(Tota1 Neuronas) 1

I Asinar Neuronas al Arreglo i

t Asinar Sinapsis I al Arreglo ! I

Escribir A Archivo(Capa Entrada) 1

1 Escribir A ArchiiotCapa I Salida) 1 + 1

I Escribir A Archivo(Sinapsis Neuronas Ocultas) 1 I

I

[ Escribir A Archivo(Sinapsis Neuronas Salida) 1 I

La hnción “Paso Robot” es la más importante ya que en ella se encuentra el código que controla la evolución del robot en el mundo imaginario.

Para el ejemplo analizado encontramos que esta hnción permite asignar los valores de los sensores de luz y de distancia a cada una de las neuronas de la capa de entrada.

Posteriormente se realiza la propagación de los datos de entrada y finalmente se calculan los valores de salida de las capas oculta y de salida.

1

Inicializar Neuronas Entrada I

1 Mostar Actividades Capa Salida I I

I inicializar Neuronas Luz I

I

T

Calcular salida(Capa Ocutta)

25

Propagar (Capa)

i /

ra Cada Neurona

N Para Cada Sinapsis

Sinapsis.Peso+= P.05*Sinapsis.tlacia.Salida

*(Neurona.Salida-Sinapsis.Pesa) . I I

3 Calcular Salida(Capa)

i

Normatizar(Neurona.Suma) 1 I

i Neurona.Salida=Neurona.Suma

26

Las hnciones “Inicia Corrida Robot ’’ y “Ilermina CorricZn Robot ’’ preparan al simulador para comenzar y terminar la ejecución del controlador del usuario.

Para este caso en particular sólo se prepara y se cierra el archivo de ploteo, el cual permite tener un seguimiento de la evolución del robot en el medio ambiente.

La hnción de “Reset robot” permite realizar las acciones necesarias para que el robot quede en un estado parecido al de un nuevo robot.

t Borrar Archivo Ploteo

I

27

El simulador da la opción de tener fbnciones adicionales a las que é1 ofrece. La manera de implementar estas hnciones es a través de la fbnción “Comando de Usuario”. En esta función se tiene un case que evalua los diferentes comandos implementados. Para el caso particular de l a red analizada se tienen 2 comandos adicionales: “print network” (imprime la configuración de la red en un archivo de texto) y “plot” (muestra en pantalla el recorrido del robot en esa ejecución). - Comando de usuario

F=7 Comando=“print network”

““““‘““ ,q I I I

i Mostrar Camino Ploteado 1

I

“Comando Desconocido”

I

Finalmente tenemos la fbnción de “Cerrar de usuario”, la cual sirve para liberar los recursos utilizados por el controlador, y en este caso para cerrar el archivo que guarda el recorrido del robot.

2s

Contenido del archivo Robot (file.robot)

El archivo robot es generado por el simulador al presionar el botón de salvar robot. Este archivo contiene los datos necesarios para reconstruir el estado del robot al momento de ser salvado.

Para el caso del ejemplo 2, el archivo guarda dentro de sí los datos necesarios para la reconstrucción de la red neuronal, teniendo así la posibilidad de conservar el estado de la red neuronal en un momento determinado.

Dentro del archivo se guardan como mínimo los siguientes datos :

Datos de posición y estado del robot.

0 robot --> x 0 robot --> y o robot --> Alpha 6 robot --> Diameter 0 robot --> State

Datos de sus efectores.

0 robot -->Motor[i].x 0 robot -->Motor[i]. y 0 robot -->Motor[i].Alpha 0 robot -->Motor[i].Value

para i=l,2

Datos de los sensores.

0 robot -->IRSensor[i].x robot -->IRSensor[i].y

0 robot -->IRSensor[i].Alpha 0 robot -->IRSensor[i].DistanceValue

para i=1,2, ..., 8

Los datos asociados a la posición del robot son relativos con la esquina superior izquierda de la pantalla de mundo virtual, mientras el ángulo del robot (Alpha) es relativo a el eje X en su región positiva.

Para los datos de los sensores, así como de los efectores, se tiene que las coordenadas de posición son relativas al centro del robot, mientras que su ángulo (Alpha) asociado es relativo al eje frontal del robot.

29

Para el ejemplo de la red neuronal, el archivo robot contiene además de los datos anteriores los siguientes datos relacionados con la reconstrucción de la red neuronal:

Datos generales de la red :

n input nhidden

0 n - output 0 n - synapse

Estos datos corresponden a los números de neuronas de cada una de las capas, además del número total de sinapsis contenidos en la red.

Datos de las neuronas

Tipo de neurona Salida de neurona

0 Posición en arreglo de sinapsis axón 0 Posición en arreglo de neurona siguiente.

Estos datos serán guardados por cada una de las (n-input + nhidden + noutput) neuronas.

Datos de las sinapsis

o Tipo de sinapsis Peso

0 Posición en el arreglo de neurona Dirigih a 0 Posición en el arreglo de sinapsis siguiente.

30

IV) Redes de Retropropagación.

Rumenlhart, Hinton y Willian en año de 1986, realizaron un método para que una red neuronal aprendiera a relacionar los patrones de entrada con sus respectivas reacciones. Utilizando más capas ocultas, a este método se le conoce como retropropagación, el cual es un método supervisado.

El aprendizaje de retropropagación consiste en dos fases: Primero se aplica un patrón de entrada a la primera capa de la red, el cual se va propagando por las demás capas hasta la capa de salida. Esta salida se compara con la reacción correspondiente al patrón presentado. Después se calcula el grado de error que existe entre la salida y el patrón deseado, estos errores se retransmiten hacia las capas intermedias. Una vez obtenidos los grados de error de las capas intermedias y de salida se procede a reajustar los pesos de las sinapsis. Así la próxima vez que se presente este patrón el grado de error será menor que el actual y podrá reconocer más fácil el patrón.

La gran ventaja de este método es la capacidad de reajustar los pesos para poder aprender la relación entre el patrón presentado y su respectiva reacción.

Algoritmo de retropropagación.

A continuación se presenta el algoritmo de entrenamiento de la red de retropropagación que se implantó en lenguaje ANCI C (Algoritmo de aprendizaje).

a) Se debe iniciliazar los pesos de la red con valores aleatorios entre uno y cero

b) Una vez inicializados los pesos de la red, se dede cargar un patrón en la capa de

c) Obtener los valores de la actividad de cada neurona de todas las capas.

(procedimiento InicializaArray y create-in-out-links)

incio ( procedimiento init-input-units).

El nivel de activación de las neuronas de la primera capa es el valor de los patrones que se cargaron (inciso b). El nivel de activación de las neuronas de la capa intermedia y de salida se calcula con la función sigmoidal ( hnción out-f)de la siguiente manera:

31

S’ es la suma de todos los niveles de activación de las unidades “k“ que entran hacia la unidad “ i “, multiplicados por el peso de cada sinapsis que une la neurona “ k ” con la neurona “ i ”.

No necesariamente para obtener el nivel de activación tiene que ser la función sigmoidal, sino que puede ser cualquier función que cumpla con tres requisitos: derivable, continua y acotada.

d) Una vez obtenidos los niveles de activación de la última capa o capa de salida, éste se compara con el patrón deseado y se obtiene el grado de error.

El grado de error “ si ” para las neuronas de la capa de salida se obtiene con la siguiente fórmula( función delta-tout):

4 = 21, (1 - 11, >(P.! - ?l., )

Donde U j es el nivel de activación de la j-ésima neurona de la capa de salida y Pj es el j-ésimo patrón a comparar con la j-ésima neurona o unidad.

Si la neurona pertenece a alguna capa intermedia el nivel de activación se calcula de la siguiente forma (función delta-f-hid):

si es la suma de todas las deltas “ WC ‘S ” de las unidades que reciben entrada de neurona “j” multiplicadas por el peso correspondiente de la unidad “k” a la ‘3”. A esta suma se le multiplica por la derivada de la hnción sigmoidal, esto para escalar el error y forzar a una mejor corrección.

e) El reajuste de los pesos se calcula de la siguiente manera (procedimiento bp-adjust-weights):

Donde Wij(‘~+I) es el nuevo peso entre la unidad ‘Y la unidad “j”, Wij(t) es el peso actual entre las unidades “i” y “j” a es factor de aprendizaje los valores que puede tomar están entre 0.25 y

0.75. Este valor se elige antes de comenzar cualquier aprendizaje. sj es el grado de error de la unidad “j” . Ui es el nivel de activación de la unidad ‘3’’. /3 es un factor de caída exponencial para determinar la contribución del gradiente. Este factor toma valores entre O y l .

f) Para cada patrón de entrada se repiten los pasos anteriores desde la presentación del patrón hasta el reajuste de pesos.

32

g) Por último ya que se presentaron todos los patrones se calcula el error cuadrático ‘‘E” para poder decidir si se detiene el aprendizaje o se continúa hasta obtener el error deseado (fbnción pattern-error). Se dice que cuando “E’ está próximo al cero el algoritmo a convergido para los patrones que se presentaron, es decir, que la red neuronal podrá reconocer cualquiera de los patrones y tener una reacción correcta.

Donde ‘ Y ’ es el i-ésima unidad y ‘7’ el j-ésimo patrón, “y”es el valor del patrón y “u” es el valor de activación de la unidad.

3 3

VI Obtención de los patrones de entrada y de salida.

Los patrones de entrada son aquellos que se cargan en la capa de inicio para que cada uno de estos se propague calculando los niveles de activación de cada neurona de la capa oculta y la de salida.

Los patrones de salida son aquellos que se comparan con los niveles de activación de la capa de salida para poder obtener el grado de error (delta) y realizar los cambios necesarios en los pesos (retropropagación).

El robot Khepern consta de 8 sensores de luz y 8 sensores de distancia. Como nuestro objetivo es hacer que el robot evite obstáculos, tomamos los valores de los sensores de distancia en diferentes puntos de choque y las respectivas reacciones que debe tener el robot ante tal circunstancia como patrones de entrada y de salida respectivamente.

Los patrones de entrada se obtienen de la siguiente manera: 2 3

1

o

7 6

En la figura anterior se puede observar el robot y sus ocho sensores de distancia los cuales regresan un valor entre O y 1023. Se considera a 1023 como contacto directo con un obstáculo, aunque no necesariamente este chocando sino que este muy cerca del obstáculo

Contactos Reacciones Descripción

W Contacto frontal y su respectiva reacción (Un giro hacia la derecha)

Contacto lado izquierdo. (Gira hacia la izquierda)

Contacto lado derecho.

Contactos Reacciones

a- - a 8

Descripción

Contacto del lado derecho e izquierdo

+ Contacto frontal y por ambos lados.

+ Contacto frontal y lateral izquierdo

* Contacto frontal y lateral derecho.

+ Contacto superior izquierdo.

+ Contacto superior derecho.

t t t

Contacto inferior izquierdo.

Contacto inferior derecho.

No hay contacto, se continúa hacia adelante.

Tomando nota de los valores de los sensores en cada contacto se forman los patrones de inicio y sus respectivas reacciones ejemplo:

Con el contacto frontal los valores de los sensores son los siguientes:

Sensor O: 0050 Sensor 5 : 0050 Sensor 1 : 1 O00 Sensor 4: 1000

I Sensor 2: 1023 Sensor 6: O002 Sensor 3: 1023 Sensor 7 : 0002

I I

Por lo tanto nuestro patrón de entrada queda de la siguiente manera:

{ 0050, 1000, 1023, 1023, 1000, 0050, 0002,0002 f Contactofrontal.

Y el patrón de salida (la reacción) debe ser hacia la derecha, es decir, el motor de la rueda derecha cambia de sentido (hacia atrás) y el motor de la rueda izquierda se le asigna un valor positivo (hacia adelante), para poder provocar el giro hacia la derecha.

+ Reacción

Giro hacia la derecha

La reacción hacia adelante se considera como 0.9. Y la reacción hacia atrás se considera como 0.1. Por lo tanto el patrón de salida queda de la siguiente manera:

{0.9,0.1 } Vuelta hacia la derecha

Este es el valor a comparar con la salida de la red.

Así sucesivamente se calculan los demás patrones de entrada y de salida tomando en cuenta los contactos y sus respectivas reacciones.

36

Código de la red de retropropagacion en lenguaje ANSI C.

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

#define NUM-IN 8 Número de unidades en la capa de entrada #define NIIM-HID 5 Número de unidades en la capa oculta #define NUk-OUT 2 Número de unidades en la capa de salida #define TOTAL (NUM-IN + NUM-HID + NUM-OUT) Total de neuronas #define BIAS-UID (TOTAL) Posición de la unidad bias dentro del arreglo

Macros para obtener indices

#define IN-UID(X) (X) #define HID-UID(X) (NUM-IN + X) #define OUTUID(X) + I"-HID + X) #define TARGET-INDEX(X) (X - (NW-IN + NUMHID))

#define PATRONES I 1 Número de patrones a reconocer #define ERROR-TOLERABLE 0.00 1 Error máximo esperado para cada reconocimiento #define ON-TOLERANCE 0.75 Valor a comparar para las reacciones #define NOTIFICAR 10 Cada 10 iteraciones se notifica el aprendizaje #define DEFAULT-ITER 15800 Iteraciones por default #define TOTAL-LIGAS ( NUM-IN+l)*NUIb-HID+(NUM-HID+l)*~-OUT

struct unit { Declaración de la estructura de cada unidad o neurona int uid: Identificador de la unidad char *label; double output: Nivel de activación double (*uni-out-f)(): Apuntador a la función de activación double delta: Valor delta para cada unidad double (*wit-delta-f)(); Apuntador a la función para calcular delta struct link *idinks: Para la propagación stmct link *outlinks: Para la retropropagación

1 *pu[TOTAL+I];

Cada UNIDAD contiene los siguientes datos

LABEL OUTPUT

*(UNIT-OUT-F()) DELTA

"UNIT-DELTA-F() "INLINKS

*OUT-

37

stnlct lmk { Declaración de cada liga o sinapsis entre dos unidades char *label: double weight; Peso de la liga double data; Diferencia de pesos entre el peso actual y anterior int from-unit: Ident. de donde proviene la liga int to-unit; Ident. a donde se dirige la liga struct link *next-inlink; Apuntadores para el ligado entre las sinapsis struct li+ *next-outlink:

f : Cada LIGA contiene los siguientes

LABEL WEIGHT

DATA FROM-UNIT

*NEXTINLINK “NEXT-OUTLINK

I I

int iteraciones =( DEFAULT-ITER); double learning-rate = 0.2; Grado de aprendizaje double momentum = 0.9; Variable para escalar el grado de error (delta) double pattern-err[PATRONES]; Arreglo para guardar los errores de reconocimiento (delta)

PATRONES DE ENTRADA {Sensor O, Sensor 1. Sensor 2, Sensor 3. Sensor 4. Sensor S. Sensor 6, Sensor 7)

double inputpt[PATRONES][NLJ”IN] = { i0.0 , 100.0, 850.0, 850.0, 100.0, 0.0 . 0 . 0 , 3 0 . 0 ), t8SO.0, 200.0. 850.0, 850.0, 100.0, 0.0 . 0.0 ~ 30.0 f . C0.0 . 100.0, 850.0, 850.0. 200.0, 850.0, 30.0 . 0.0 f , {850.0, 100.0. 10.0 . 10.0 . 100.0, 850.0. 30.0 , 30.0 1, {SSO.O. 100.0, 10.0 . 0.0 . 0.0 , 0.0 ~ 850.0, 850.0). iO.0 . 0.0 , 0.0 . 30.0 , 200.0. 850.0, 850.0. 850.0). {850.0, 100.0, 30.0 .0.0 , 0.0 ,0.0 , 10.0 . 50.0 ),

fS00.0. 850.0. 200.0, 100.0. 0.0 . 0.0 , 0.0 , 0.0 1, (0.0 .0.0 , 100.0, 200.0. 850.0, 500.0,O.O . 0.0 1 1:

.[0.0 . 0.0 .0.0 . 10.0 . 100.0. 850.0. 30.0 . 0.0 f .

PATRONES DE SALIDA {Motor izquierdo. Motor derecho]

double targetqat[PATRONES][NU”UT] = { t0.9.0. 1;. {0.9.0.1;,. {O. 1.0.9:. {0.9.0.9), {0.9,0.9). {0.9.0.91.. {0.9.0.9). {O.l.O.S), {0.9.0.1]. {0.1,0.9)

Declaración de prototipos y variables globales. l. :

38

double out-f(), delta-f-out(), delta-f-hido, randomso, pattemperror( 1: long double unidad[TOTAL+21[2],ligas[TOTAL,-LIGAS][2];

void main(void) Función principal f

char ch: int res: exTern struct unit *pu[]:

FILE *fp; Apuntador al arreglo que contendrá la red

InicializaArrap(unidad,ligs); Valores iniciales para las unidades y las ligas

actpatron(): Se escala el patrón de entrada

do '{ printf("Qué desea hacer? \n"): printf("0->Aprender. 1->Reconocer:"):

scanf("%d".&res); if(res==O) fp=fopen("Re~ewollal' '. ' '~' ')~

else f fp=fopen("ReclNeUTonal"."r")l LeerRedNeural(unidadligas,fp):

?

createqrocessing-units(pu,unidad): Se crean las unidades createin-out-links(pu.1iga.s): Se crean las ligas if( res==()) { learn(pu); Se aprenden los patrones GuardaRedNeural@u.fp): fclose(fp):

1 I

else .[ fclose( f p ) : reconocer(pu):

I }while(res!=2): I

El procedmiento creategrocesing-units crea las neuronas de la capa de entrada. oculta y de salida y también crea la neurona bias. Todas la dxecciones a las neuronas quedan en el arreglo "pu". Primero se guardan las direcciones de las neuronas de entrada, luego las neuronas de la capa oculta , después las neuronas de la capa de salida y por último se guarda la duección de la capa de salida. Cada valor de las neurona es inicializado con números por default, como se muestra en la siguiuente figura.

"pu" es el arreglo donde se colocan los apuntadores a las unidades. "unidad" arreglo con los valores iniciales de las unidades.

39

Pu(0) 4 4B Pu(1) 4 aD

Pup) 4 am Pu(2) +

creategrocessing-units(pu,unidad)

struct unit *pu[]: double unidad[][2]:

c stmct unit *createpunit(): int id:

for (id = IN-UID(O); id < IN-UID(NUh-IN); id++) Se crean la neuronas de entrada

for (id = HID-UID(0); id < HID-UID(NUh-HID); id++)

for (id = OUT-UID(0); id < OUT-UID(NUh-OUT); id++)

pu[BIASUID] = create-unit(B1AS-UID, "bias",unidad[id] [O], NULL. unidad[id)[ I]. NULL);

pu[id] = create-unit(id "input", unidad[id][O], NULL,unidad[id][lI, NULL):

pulid] = create-unit(id "hidden".unidad[id][O]. out-f,unidad[id][ 11, delta-fhid);

pu[id] = create-unit(i4 "output". unidad[id][O]. out-f, unidad[id]ll], delta-f-out):

ProceQmiento create-in-out-links crea el ligado total de las capas como se muestra en la figura que sigue. Cada valor de los pesos son números aleatorios. Las ligas de cada neurona de la capa inferior con la capa superior quedan ligados entre sí, en una lista como se muestra en la figura 3. El apuntador o u t W de cada neurona al final queda apuntando al principio de cada lista. para tener acceso a las ligas.

"pu" es el arreglo que contiene apuntadores a las unidades. "ligas" arreglo con los valores iniciales de las ligas (sinapsis). Nota: El Bias tiene una liga para cada unidad de la capa oculta y de salida

Creación de la red neuronal en memoria.

create-h-out-links(pu.liga) struct unit *pu[]; double liga[][2]:

int i, j.1: struct l i n k *create-lmk():

for (i = HID-UID(0); i < HID-UID(NUM_HID); i t t ) { Ligas de la capa oculta 1=0; Indice para la lectura de los arreglos

pupIAS-UD]->outlinks = puli]->inlinks = create-link(pu[i]->inlinks, i, pu[BIAS-UIDI->outlinks, BIAS-UID,(char *)NULL,

liga[l][O].liga[l][l]): 1++: for (j = IN-UID(0); j < N-UID(NUMIN); j++,l++) puLi]->outlillks =

puli]->inlinks = create-link(pu[i]->idinks. i, pulj]->outlinks, j, (char *)NULL,liga[l][O],liga[l][l]); I

for (i = OUT-UID(0); i < OUTUID(NUM - OUT): i++) { Ligas de la capa de salida pu[BIAS-UID1->outlinks =

pu[i]->mlinks = create-link(pu[i]->inlinks, i,pu[BIAS-UIDI->outlinks, BIAS-UID.(char *)NULL. liga[ll[Ol.liga[l][ll)~ 1++: for (i = HID-UID(0); j < HU-UID(NUM_HID); j++,ltt) puu]->outlinks = pu[i]->inlinks = create-link(pu[i]->inlinks, i, pufi]->outlinks, j,(char *)NULL,liga[1][0],liga[lJ[l] );

I

I 9

41

Al terminar, el ligado total de la red neuronal queda como muentra la siguiente figura.

INLINK Ligas entre la capa de inicio y la capa oculta

INLINK

Ligas entre la capa oculta y la de salida

42

La función randoms calcula un número aleatorio entre O y 1

double randoms() t return((rand() % 327278) / 327378.0);

I

La función create-unit crea la unidad solicitando memoria al procesador e inicializa los valores de la unidad. ‘úid” : identificador de la unidad. “label” : etiqueta de la liga “output” : variable para contener el valor de activación. “out-f : apuntador a la función para calcular el nivel de activación “delta” : variable que para contener el error entre el patrón deseado y el valor obtenido. “delta-f’: apuntador a la función que calcula el valor delta.

struct unit *create-unit(uid label, output. out-f, delta. delta-fl int uid: char *label: double output. delta: double (*out-fl(). (*delta-fl(): í

struct unit “unitptr:

if (!(unitptr= (struct unit *)calloc(sizeof(struct unit>,l>>) { Eprintf(stderr. “Error de memoria al crear la unidad h”): esit( 1):

I I

unitptr->uid = uid unitptr->label = label: unitptr->output = output: unitptr->unit_out-f = out-f. unitptr->delta = delta; unitptr->unit-deltaf = delta-C unitptr->inlinks=NULL: unitptr->outlinks=NULL: return (unitptr):

1

La función create-link “start-inlist” “to-uid“ “start-outlist” “from-uid ‘‘label’’ “wt” “data”

crea la liga pidendo memoria al procesador e inicializa los valores de ésta. : apuntador a la liga de entrada de la primera neurona : identificador de la segunda neurona. : apuntador a la liga de salida de la segunda neurona : identlficador de la primera neurona. : etiqueta de la liga. : peso de la liga. : derencia de pesos entre el actual y el peso anterior.

struct link *create-link(stxt-inlist, to-uid start-outlist, f romuid label. wt. data) struct link *start-inlist, *staroutlist: int to-uid fromuid: char * label: double W. data: t

struct link *linkptr:

if (!(linkptr = (struct link *)calloc(sizeof(struct link).l))) f fprintf(stderr, "Error de memoria al crear la liga h"): exit( 1):

1 I

Valores iniciales de las ligas linkptr->label = label: linkptr->from-unit = frotn-uid: linkptr->to-unit = to-uid: linkptr->weight = wt: linkptr->data = data: linkptr->nextinlink = start-mlist; linkptr->next outlink = start-outlist: return(1inkptr):

1

L a función learn llama a la función bp-learn dentro de un ciclo el número de iteraciones por default. Y también presenta el grado de error en el reconocimiento de cada patrón.

"pu" arreglo con los apuntadores a las unidades.

learn(pu) struct unit *puu;

register i. temp; char tempstr[TAM]: extern int iteraciones; extern double learning-rate, momentum: printf("\nAprendiendo 'I); for (i = O; i < iteraciones: i++) { if ((i % NOTIFICAR) == O) { printf( 'l. 'I):

fflush(stdout): 1 bp - learn(pu, (i >= iteraciones-(PATRONES-1)));

1

printf("\n"); for(i=O:i<PATRONES:i++)

printf(" Hechoh\n"): printf("error :%If \n".patternerr[i]);

3

L a función bp-learn realiza la propagación del patrón presentado, hace el reajuste de pesos si aún no se ha obtenido el grado de error máximo para el reconocimiento de los patrones de entrada. Todo esto se realiza con todos los patrones de entrada. En esta parte se realiza el aprenduaje.

L'PU" : arreglo con los apuntadores a las unidades. "save-error" : variable boleana que es verdadero en las últimas PATRONES iteraciones.

bp-learn(pu, saveerror) struct unit *pu[]: int sal'eerror: t static int count = O : static int pattern = O: ex-ern double pattern-err[PATRONES]:

init-input-units(pu, pattern); Carga el patrón en las unidades de entrada

if (save-error)

bp-adjust-weights(pattern, pu); Se reajustan los pesos if (pattem < PATRONES - 1)

else

coullt++:

propagaWp@ ; Calcula la salida de las neuronas de salida

pattern-err[pattern] = patternerror(pattern, pu);

pattern++ :

pattern = (1:

3 f

El procedmiento init-input-units se encarga de cargar el patrón de entrada en la capa de inicio. Este patrón es el que se analizará en la hnción bp-learn.

“U” : arreglo de apuntadores a las neuronas. “pattern” : número del patrón a cargar.

init-input-units(pu, pattern)

int pattern: struct Unit *pu[]:

f

int id:

for (id = IN-ULD(O); id < IN-UID(NUM-IN); id++) pu[id] ->output = inputpt[pattern] [id]:

1.

El procedimiento propagate llama a una función para calcular el nivel de activación de las capas oculta y de salida. propagando así el patrón de entrada por toda la red.

for (id = HID-UID(0); id < HID-UID(NUM-HID): id++)

for (id = OUT-UID(O); id < OUT-UID(NUM_OUT); id++) (*(pu[id]->unit-out_f))(pu[id], pul:

(*(pu[id]->unit-out-f))(pu[id]. pu): 1 f

La función out-f calcula el nivel de activación de las capas oculta y de salida. El nivel de activación se obtiene con la función sigmoidal.

“pu-prt” apuntador a la neurona que se le calcula el nivel de activación.

double out-f(puqtr, pu) struct unit *puqtr, *pu[]; f

double sum = 0.0 , expo: struct link *tmp-ptr.

tmpgtr = puqtr->idinks: while (tmpgtr) {

sum += pu[tmpptr->from-unitl->outpLlt * tmpqtr->weight; tmpgtr = tmpgtr->next-inlink.

1 puqtr->output = l.O/( 1 .O + exp(-sum)); Implantación de la función sigmoidal

I I

La función pattern-error calcula el error cuadrático meQo para los patrones de salida como se indcó en el algoritmo.

double pattern-error(pat-num pu) int pat-num; Número de patrón struct unit *pul]: r

int i; double temp. sum = 0.0:

for (i = OUT-UID(O); i < OUT-UID(m-OUT); i++) { temp = targetgat[patnum] [TARGET_INDEX(i)] - pu[il->output: sun += temp * temp;

1

return (~1.d2.0): 1

El procedmiento bp-adjust-weights hace el ajuste necesario en los pesos de la red .Primero se calculan los grados de error. es decir los deltas de cada neurona de la capa de salida y después de la capa oculta tomando en cuenta el patrón analizado y su reacción respectiva. Segundo se reajustan los pesos utilizando la h c i ó n que se mostró en el algoritmo.

bp-adjust-~eights(pat-n~. pu) int pat-num: Número de patrón struct unit *pu[]; .r

int i: double templ, temp2, delta, error-sum: struct link "inlinkgtr, *outlinkgtr:

Chlculo de las deltas for (i = OUT-UID(O): i < OUT-UID(NUM_OUT): i++) Para cada unidad de salida

for (i = HID-UID(0); i < HID-UID(NUM-HID); i t t ) Para cada unidad oculta

Se calculan los pesos for (i = OUT-UID(0); i < OUT-UID(NUM - OUT): i t t ) { para las unidades de salida

(*(pu[i]->unit-deltZ-~)(pu, i, pat-num):

(*(pu[i]->unit-delta-f))(pu. i): Cálculo de delta

inlinkgtr = puli]->inlinks: while (inlinkgtr) { Para cada inlink de la unidad de salida templ = learninggrate * pu[i]->delta *pu[inlinkqtr->from-unit]->output; temp2 = momentum * inlinkqtr->data: inli&gtr->data = templ + temp2; Diferencias de pesos inlinkgtr->weight += inlinkJtr->data; Nuevo peso de la liga

inlinkgtr = inlink-ptr->next-inlink: I I

1 for (i = HID-UID(0); i < HID-UID(NUIV-HID); i++) { Para cada unidad Oculta inllnkptr = puli]-hnlinks: while (inlinkgtr) { temp1 = learning-rate * pu[i]->delta * pu[inlinkgtr->from-unit]->ou~tput;

temp2 = momentum * inlinkqtr->data: inlinkqtr->data = templ + temp2; inlinkgtr->weight += inlinkqtr->data: inlinkgtr = inlinkgtr->nea-inlink;

1 I

1

1

La función delta-f-out calcula el delta para cada unidad o neurona de salida, éSta se calcula como se indxó en el algoritmo.

üid": identificador de el número de entrada del patrón, es decir. es el número de unidad de la capa de salida. "pat-num": número de patrón.

double delta-f_out(pu. uid pat-num)

int uid pat-num: struct unit *pu[l;

< I

double templ, temp2, delta;

templ = (Qrgetgat[patnuml[TARGET-INDEX(uid)] - pu[uid]->output): temp2 = (1.0 - pu[uid]->output); delta = templ * pu[uid]->output * ten432; Se obtiene el valor de delta pu[uid]->delta = delta:

1.

La función delta-f-hid calcula la delta para la capa oculta como se indicó en el algoritmo.

Double delta-f-hid(pu, uid)

int uid:

"uid": identificador de el número de unidad de la capa de oculta.

struct unit *puu:

.(

double templ, tenlp2, delta. error-sum; struct link *inlinkgtr. *outlinkgtr;

outlinkqtr = pu[uid]->outlinks; error-sum = 0.0; while (outlikgtr) { error-sum += pu[outlinkqtr->to-~~nit]->delta * outlinkqtr->weight; outlinkgtr = outlinkgtr->nex~-outlink:

>.

delta = pu[uid]->output * (1.0 - pu[uidl->output) * error-sum; pu[uid]->delta = delta:

1 1

El procedimiento GuardaRedNeural como su nombre lo inQca guarda la estructura de la red neuronal en un archivo de tal manera que se pueda cargar desde el archvo con las funciones create-processing-units y create-in-out-links

"pu": Arreglo de apuntadores para acceder a la red -fp": apuntador al archwo donde se guardarán el nivel de activación y el delta de cada neurona . S el peso y el data de cada liga.

GuardaRedNeural(pufp)

FILE *fp:

int i.j,k; struct link *ligas[TOTAI-LIGAS].*ligtemp;

struct unit *pu[];

Se guarda el nivel de activación (output) y delta de cada neurona o unidad for(i=IN UID(O);i<IN-UID(NUMIN);i++) Capa de entrada

for(i=HID-UlD(O);i<HID-UID(NW-HID);i++) Capa oculta

for(i=OUT-UID(O);i<OUT-UID(NUh-OUT);i*) Capa de salida

fprintf(fp,"%lf.%llf\n",pu[i]->output,pu[i]->delta);

fprintf(fp,"%lf,%If\n".pu[il->output,pu[i]->delta);

fprintf(fp,"%lf,%lf\n".pu[i]->output.pu[i]->delta);

fprintf(fp,"O/~lf,O/ollf\n".pu[i]->output,pu[i]->delta); Se guardan los datos de la neurona BIAS k=NUM-IN:

Por la forma en que fue construida la red se guardan los valores de las ligas en un arreglo temporal pan después vaciar estos datos en el archivo.

for(i=HID-UID(O);i<HID-UID(NUM-HID):i++) { ligtemp=pu[i]->inlinks: j=O; nhile(1igtemp) { ligas[k-j]=ligtemp; ligtemp-ligtemp>next-i~illk: j++;

1

k=k+(NUM-IN)+l: 1

kk+(NUM-HID)-(NUh-IN); for(i=OUT-UID(O);i<OUT-UID(NUM-OUT):i++) f

ligtemp=pu[i]->inlinks:

while(1igtemp) [ j=o;

ligas[k-j]=ligtemp; ligtemp=ligtemp->next-inlink; j++:

1

k=k+NLIM-HID+l: 1.

for(i=O:i(TOT&-LIGAS;i++) fprintf(fp,"%lf,%lfln".ligas(i]->weight,ligasli]->data):

1.

El procedmiento actpatron escala el patron en un rango comprenddo entre O y l. porque se uso la función sigmoidal.

actpatron() { int i.j: for(i=O:i<S;i++) for(j=O;j<l l;j++) inputpt[ilu]=inputpt[i]lj]/1023.0:

1

El procedmiento reconocer se encarga de reconocer el patrón indlcado reconocer(pu) struct unit *pu[];

int pt; do [ printf("Patron:"); scanf("%d",&pt): init-input-units(pu,pt): propagate(pu): if(pu[OUT-UID(O)]->output> ON-TOLERANCE &&pu[OUTUID( l)J->output> ON-TOLERANCE )

printf( "Adelante\n"): else if(pu[OUT~UID(O)]->output> ON-TOLERANCE && pu[OUT-UD( 1

ON-TOLERANCE) printf("Derechab");

else if(pu[OUT-UID(O)J->output<= ON-TOLERANCE && pu[OUT UID( printf("1aq.h"): printf("%lf.O/olf\n",pl~[OUT_UID(O)~->output,pu[OUT_UID( l)]->outp~~t): )while(pt!=-1);

-

> )

El procedmiento LeerRedNeural se encarga de leer los datos de la red neuronal de un arcluvo donde fueron guardados.

LeerRedNeural(unidadligas,fp) FILE *fp: double unidadU[Z],ligas[][2]; fint i:

for(i=O;i<=TOTAL;i++) Se leen el "output" y el "delta" de todas las unidades fscanf(fp,"%lf.%llnn".&unidad[i][O~,&unidad[i][ 1 I):

for(i=O;i<TOTAL-LIGAS$++) Se leen el "weight" p el "data" de todas las ligas fscanf(fp,"%lf,%lAn",&ligas[i][O],&ligas[i][l]);

f

El procedimiento InicializaArray se encarga de inicializar los arreglos de Unidades y Ligas las unidades a cero y las ligas. El peso es aleatorio y el data es cero

InicializaA.rray(UnidadLigas) double Unidad[J[Z],Ligas[l[2]:

int i j : FILE *fp: for(i=O;i<TOTAL:i++)

r t

Unidad[i][O]=Unidad[i][l]=0.0; Output y delta a cero

Unidad(i][0]=1.0: Datos del BIAS Unidad[i][ 11 =().O:

for(j=O:j<TOTAL-LIGAS:j++) f Ligaslil[Ol=randoms(); Pesos aleatorios Ligas~][l]=O.O: Diferencias de pesos a cero ?

3

VII) Implantación del código de la red en el simulador.

Para poder hacer el reconocimiento de algún patrón se hacen las siguientes llamadas a diferentes procedimientos:

CargaPatron(pu, robot); Inicializahay(. . .); LeerRedNeuronal(. . .); createqrocessing-units(. . .); create ” in out - links(. . .); Reconocer(pu,robot);

El procedimiento CargaPatron carga el patrón en el arreglo input-pat en la última casilla de &e.

“pu”: Es el arreglo de apuntadores a las neuronas de la red. “robot”: Es un apuntador a la estructura del robot Khepera, este argumento se uliliza para poder obtener los valores de los sensores de obstáculos “robot-> IRSensor[i]. Distancevalue /1023”. Como se puede observar el valor del sensor está ya escalado a un valor entre cero y uno. La variable “i” se refiere al número de sensor.

void cargapatron(pu,robot) struct unit*pu[ 1: struct Robot *robot:

int i: for(i=O;i<8,i++) inputgat[PATRONES][i]=(double)robot-~Irensor[i].Dis~nceValue/l023;

.f

1

El procedimiento reconocer se adaptó para poder hacer los movimientos del robot hacia donde indicará la red de acuerdo a lo que aprendió en el entrenamiento, se compara el valor de salida (output) con el valor 0.75 que se considera como reacción hacia adelante de la rueda en cuestión.

“pu”: Arreglo de apuntadores a las neuronas. “robot”: Estructura del robot Khepera.

void reconocer(pu,robot) struct Robot*robot; struct united*robot:

char text[S0]: if(pu[OUT_UID(O)]->output>O.75&&pu[OUT_UID(l)]-~~OUTPUT>0.75)f

.f

robot->Motor[0].Value=robot->Motor[l].Value=5:M~vimiento hacia adelante

51

>.

else if(pu[OUT~UID(O)->o~~tput~O.75&&pu[0UT~UID( l)]->output<=O.75){ robot->Motor[ 1].Value=5; Movimiento hacia la derecha robot->Motor[O].Value=-5:

> I

else if(pu[OUT-UID(O)->output>O.75&&pu[OUT-UID( l>]->output>=0.75){ robot->Motor[ 1].Value=-5; Movimiento hacia la izquierda robot->Motor[O].Value=5;

?

else { Movimiento hacia la derecha para un patrón desconocido robot->Motor[ll.VaIue=-IO: robot->Motor[O].Value=lO:

1

1

Los demás procedimiento son idénticos a los descritos en el tema anterior.

Los llamdos a estos seis procedimientos se colocaron en las siguientes hnciones del simulador:

Las fimciones InicializaArray, LeerRedNeuronal, creategrocessing-units y create in out links, se colocan en el procedimiento UserInit en ese orden , porque el código de estos procedimientos se realiza una sola vez y es al principio. " -

Los procedimientos CargaPatron y Reconocer en ese orden se colocan en el procedimiento StepRobot, ya que estos deben ejecutarse a cada paso que da el robot.

Estos procedimientos se colocan haciendo los arreglos pertinentes como son agregar las variables globales, la definición de prototipos, etc. Todas las fkciones se deben agregar en el archivo user.c del software del simulador, además la definición de los procedimientos en sí se pueden colocar ahí mismo o en otro archivo, Al realizar esto se debe compilar de nuevo el código del simulador y por último se debe ejecutar el programa del simulador para ver como fimciona la red neuronal entrenada.

52

VI1 I) Resultados y Conclusiones

En el entrenamiento de la red neuronal se obtuvo un rango de error mínimo en el reconocimiento de de cada patrón presentado. Al observar el comportamiento del robot en el simulador, se pudo ver que no le era dificil reconocer obstáculos en su camino, tal como se esperaba.

Al momento de realizar varias pruebas de la red en el simulador, al introducir más y más obstaculos y en diferentes formas , se puede dar el caso de que el robot quede en la misma posición durante un buen periodo, oscilando entre dos patrones que no tenga muy reconocidos y uno Io lleve al otro, debido a que los patrones que se presentan son muy pocos comparados con los que realmente existen.

Nuestra conclusión es que para obtener un resultado excelente en el reconocimiento se deben obtener más patrones de entrada. Estos se pueden obtener cuando el robot está en posiciones clave como por ejemplo: cuando está frente a un obstáculo se puede girar el robot cada 10 ó 15 grados junto al obstáculo y asi obtener más patrones de entrada para el entrenamiento de la red, otra posición puede ser cuando el robot está en una esquina. Hay que recordar que entre más patrones se tengan para aprender ,claro con sus respectivas reacciones, mejor será el desplazamiento del robot en el mundo que se coloque.

No importa cuantos patrones de entrada se quiera introducir en el código de la red por la manera en que está diseñado se pueden agregar los patrones modificando sólo algunas variables. Tomando en cuenta los recursos de hardware con que se disponen.

En este proyecto se ha tratado de mostrar de manera sencilla un panorama general de lo que son capaces las redes neuronales y su utilidad. En la siguiente sección se proporciona una bibliografia que esperamos sirva a aquellas personas interesadas para que puedan averiguar lo que les interesa.

Por otra parte, esperando que las redes neuronales alcancen mayor auge, ya que se tienen una multitud de aplicaciones en campos tan diversos y pueden dar soluciones sencillas a problemas cuya solución resulta complicada cuando se emplean máquinas algorítmicas. Claro hay que tomar en cuenta dos límites en los recursos determinarán el avance. Uno es la cantidad de poder que estará disponible. El segundo, y quizá el más importante, es la cantidad de científicos de la computación que se sentirán atraídos por este campo de investigación como el principal reto que puedan enfrentar. La propuesta se ha dado.. .

m) Bibliografía

o

o

o

Bodet, Margaret A,, “Filosofin de la inteligencia art@cial”, Fondo de Cultura Económica, México, 1994. Graubard, Stephen R., “El nuevo debate sobre la inteligencia artificial: Sistemas simbólicos y redes neuronales ”, Editorial Gedisa, Barcelona España, 1993. Hilera, José R., “Redes Neuronales Artificiales: Fundumentos, m o d e h y aplicaciones ”, Addison-Wesley Iberoamericana, Delaware U. S.A., 1995. Jackson Jr., Philip C., “Introduction to art@ial iiztelligence” , Dover Publications Inc., N.Y. U. S.A., 1985. McCorduck, Pamela, ‘i2láquinas que piemair: Una incursih persorzal en la historia y las perspectivas de la inteligencia art{ficial”, Tecnos S.A. de C.V. Madrid España, 199 l . Viana, Laura, “Memoria natural y artificial ”, Fondo de Cultura Económica, México, 1995. Wendl, Karl, “Mentes y máquinas”, Direccion general de publicaciones. UNAM. México, 1970. Werbos, Paul, “The roots of backpropagation: from ordered derivates to neural networks a~~dpoliticaI.foreca~sti?lg”. John Wiley & Sons Inc., N.Y. U.S.A., 1994. White, Halbert, ‘;lrf@ial Neural Networks: Aproximafiorz and Learning Theory”, Blackwell Publishers, Cambridge, Massachusetts U. S.A., 1992. http:/www.gc.ssr.upm.es/inves/neuralann2/anntutorial.html. http:/www.fciencias.unam.mx/revista/soluciones/N 17/Coello2.html.