control de un robot con una red neuronal148.206.53.84/tesiuami/uam1609.pdf · el hombre se ha...
TRANSCRIPT
Casa abierta al tiempo
UNIVERSIDAD AUTONOMA METROPOLITANA iztapalapa
CIENCIAS BASICAS E INGENIERÍA
PROYECTO DE INVESTIGACI~N LICENCIATURA EN COMPUTACIóN
CONTROL DE UN ROBOT CON UNA RED NEURONAL
Responsables del proyecto:
Ángel Hernandez Rivera 92223742
Gustavo Silva Santos 93222201
Asesor: M.C. Joel Ricardo Jiménez Cruz
IZTAPALAPA, DISTRITO FEDERAL, A 09 DE FEBRERO DE 1999
Y . .
CONTENIDO
111)
Introducción ........................................................................... 1
Redes neuronales artificiales ....................................................... 5
o La neurona y la sinapsis ......................................................... 5
El simulador Khepera versión 2.0 ................................................. 8
0 El simulador ....................................................................... 8
0 Red neuronal utilizada en el ejemplo 2 del simulador .................. 16
0 Contenido archivo Robot (file.robot) ....................................... 28
Redes de retropropagación ........................................................ 30
0 Algoritmo de retropropagación ............................................... 30
Obtención de patrones de entrada y salida .................................... 33
Código de la red de retropropagación en lenguaje ANSI C ................ 36
Implantación del código de la red en el simulador .......................... S O
Resultados y conclusiones ......................................................... 52
Bibliografía ........................................................................... 53
1
Introducción
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 fundamental de la materia, y por otro, la ciencia se ha involucrado, muy profundamente, 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. Segundo, 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”. Para evitar confusiones entre ambas acepciones, las 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 pasado2.
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 fuerza una disciplina llamada inteligencia artzjkial. 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 esfuerzos le han servido para reducir el trabajo en aquellas operaciones en las que la fuerza juega un papel primordial. Los progresos obtenidos han permitido dirigir estos esfuerzos 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ó infructuosamente de construir una máquina capaz de resolver problemas matemáticos. Posteriormente otros tantos intentaron construir máquinas similares, pero no fue 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, "Memoria natural y arttficial", pp. 18, 1995, Fondo de Cultura Económica.
3
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 fuertemente 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 diagnóstico, una interpretació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 solicita 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.
L a 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
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.
4
llamado Khepera. El cual cuenta con un simulador4 que muestra el ambiente en el que se desenvuelve el robot y los datos que tiene en cada instante del robot. El simulador funciona bajo el ambiente Linux. Este simulador está escrito en lengaje C estándar. El código 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 funcionamiento 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.
5
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 fundamental 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 funcionamiento 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 fue 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:
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. Aprendizaje autosupervisado: La propia red corrige los errores en la interpretación empleando una realimentación.
7
Una de las primeras reglas de aprendizaje fue 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 refberza. Esta idea se expresa matemáticamente como:
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.
O O Capa de entrada
Capa intermedia
n Capa de entrada
Capa intermedia
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 hnciones 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.
Q Principal
1 Leer Archivo configuración I
1 Abrir Programa I
Inicio usuario I
F
VI I botón = Presionar Botón 1 I Realiza Acción (botón) I
I Cerrar Programa I
9
La función ‘‘Abrir programa ”, muestra el proceso de inicialización del simulador, el cual implica desde la generación de botones, el robot básico, etc.
Crear Mundo Vacio
I Leer Mundo (WORLD/home.world)l
I Crear Robot Default
I Crear Botones Del Simulador
1 Inicializar Sensores
Los siguientes diagramas nos muestran el proceso de creación del robot básico, el cual siempre es seguido por la función de inicio del usuario.
1 Crear Robot Default
I +
Crear Robot I
4 I Activa Sensores Distancia1
+ I Activa Valores Motores I
1
10
9 Crear Robot
Robot.X=500 Robot.Y=500 Robot.Alpha=Pi/2 Robot.State=O
1 Asigna Valores a Motores Motor.X=PosicionX Motor.Y=PosicionY Motor.Alpha=Angulo Motor.Valoi.0
Asigna Valores a Sensores Sensor.X=PosicionX Sensor.Y=PosicionY
Una vez que el simulador se haya inicializado, prosigue el rastreo de los 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 “load” 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 l m x lm.
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 “remove ”. Una vez que los objetos se hayan colocado, es necesario presionar el botón “sca~y1” 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.
% Boton Nuevo Robot
+
I + I Mostrar Sensores IR 1
1 Mostrar Efectores I I I
I
&--
I Leer Nombre Robot I
I Mostrar Robot I I I
I I I lnicializar Sensores
1
12
I I Leer robot 7
1 Leer Colocacion Robot 1
I I 1 Leer Colocacion Motores 1
I 1 1 Leer Colocacion Sensores
i (FIN)
3 Boton Guardar Robot
I Leer Nombre Robot 1
1 Escribir Robot En Archivo I
ribir Robot En A
I 1 I
Escribir Robot
1 I Grabar Robot 7
I +
I
I Guardar Colocación Robot 1 I + 1 Guardar Colocación Motores
/Guardar Colocación Sensores
13
a Boton Paso Robot
/I Inicia Corrida Robot 11 1
I Corre Robot 1
11 Termina Corrida Robot 11
2 C o r r e R o b o t
v M 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
F IN
X=Sensor[i].PosicionX
Y=Sensor[i].PosicionY
Alpha=Sensor[i].Alpha
I Sensor[i].ValorDistancia=
lRSensorValorDistancia(X,Y,Alpha)
Sensor[i].ValorLuz= lRSensorValorDistancia(X,Y,Alpha)
Calcular NuevoAngulo con 5 5% error
Calcular Posiciones XY con 5 10% error
14
a Boton Corre Robot
I I 1 I
Corre Robot I I I
c I Robot.ValorMotores=O -1
c
Gen Reset R o b k
I Inicializa Robot
1 Mostrar Sensores IR 1 I
1 Mostrar Efectores Robot I
Inicializar Robot
1 Robot.ValorMotores=O 1
Reset Robot
Lsz- Boton Comando
Leer Comando I
I Comando de usuario
Robot.Angulo=Radianes(Angulo)
I Mostrar Robot P e q u e 4
15
Q Boton Ayuda
L Boton Presionado
L Inicializa Sensores
1 1 Mostrar Sensores IR 1
/ Boton Siguiente Info
-
Seleccionar Siguiente Tipo Informacion
i Mostrar Inform acion
> Sal i r=Verdadero
i
i Cerrar de usuario
Liberar Robot
I i I I Liberar Mundo I I 4 I
Liberar Botones
I 4 I I Liberar Contexto 1
I Cerrar Graficos 1 I I
En estos diagramas podemos encontrar tanto la 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 del robot.
Los procesos que fueron encerrados en cajas de doble raya indican las funciones que el usuario del simulador puede modificar para implantar su propio controlador.
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
RED NEURONAL 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 “Ax&” 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 “Siguiente” 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.
Esquema General Red Neuronal
CAPA DE ENTRADA CAPA DE SALIDA
I RED NEURONAL I
NULO NULO NULO
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 “Axon” 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
. . .
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 “Dirigida 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
[M- 1”l- Siguiente (Neurona) ............
Tipo I Peso
Tipo
Neurona Sinapsis Dirigida a Siguiente
Peso -
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 “Dirigida 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 fuera 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 fimciones contenidas en el archivo user.c.
La primer funció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
I * Crear Red Neural Loca
1 Abrir Archivo Ploteo 1
b Inicializa Red Neuronal
I Apuntadores Capas=NULL 1
I Numero Neuronas=O
1 Numero Sinapsis=O 1
+ [Capa Entrada=Crear Neurona(9) I I Capa Oculta=Crear N e u r m
~~~
I Capa Salida=Crear Neurona(2)
ICrear Sinapsis(Capalni,CapaFin,Neu,Tipo) I
I + Actualiza Red Neural +
I
FIN
I
1
Actualizar Num Neuronas Actualizar Num Sinapsis
Actualizar Pesos(Capas)
1 Actualizar Coordenadas
I
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ó.
Leer Red Neuronal >
1 Leer Red Neuronal 1
I Mostrar lnformacion Usuario( I ,I) 1
1 Abrir Archivo(“Neural/neuraI.netword”) 1
ILeer de Archivo(n_entrada,n-oculta,n_salidal I v
ICapa Entrada=Crear Neurona(n-entrada)] 4 1
1 Capa Oculta=Crear Neuronah oculta) 1
1 Capa Salida=Crear Neuronah salida)”\
I Generar Sinapsis Neuronas Entrada I + i i
1 Generar Sinapsis Neuronas Oculta 1 1 Generar Sinapsis Neuronas Salida 1
Actualizar Red Neural I
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.
23
Estas hnciones 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.
1 1 Mostrar lnformacion Usuario(1 ,I) 1
Escribir Red Neural A Archivo
e c r i b i r Red Neural A A r c h 3
1
1 Crear Arreglo Neuronas(Tota1 Neuronas) I
Asinar Sinapsis al Arreglo I
I I Escribir A Archivo(Capa Entrada) I
t 1 Escribir A Archivo(Capa Oculta) I + I Escribir A Archivo(Capa Salida) I t + t
1 Escribir A Archivo(Sinapsis Neuronas Entrada) 1 I Escribir A Archivo(Sinapsis Neuronas Ocultas) 1 I Escribir A Archivo(Sinapsis Neuronas Salida) 1
I
24
La funció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 funció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.
fi lnicializar Neuronas Entrada
t lnicializar Neuronas Distancia
I
I lnicializar Neuronas Luz
1 Mostar Actividades Capa Entrada I .c
I Pienso 7 t I Mostar Actividad Capa Oculta I
1 Inicializar Efectores I
I Mostar Actividades Capa Salida
I Actualizar Archivo P l o a
Q Piensa
t Propagar(Capa Entrada)
4 1
Propagar (Capa Oculta)
Propagar(Capa Salida)
4 4 4
Calcular salida(Capa Oculta)
Calcular salida(Capa Salida)
FIN
25
t
t ra Cada Neurona
c Sinapsis.Tipo=2
Sinapsis.Peso+= 0.05*Sinapsis.Hacia.Salida
*(Neurona.Salida-Sinapsis.Peso)
4 Sinapsis.Hacia.Suma+=
Sinapsis.Peso*Neurona.Salida
ular Salida(C
4
4 4 i
1
Para Cada Neurona
Normalizar(Neurona.Suma)
Neurona.Salida=Neurona.Suma
Neurona.Suma=O
26
Las funciones “Inicia Corrida Robot ” y “Termina Corrida 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.
1 lnicializar Archivo Ploteo
1 Mostrar lnformacion Usuario(1 ,I) 1 I Cerrar Archivo Plote/
1
La función de “Reset robot” permite realizar las acciones necesarias para que el robot quede en un estado parecido al de un nuevo robot.
orrar Archivo Ploteo
I Reset+Red Neural 1 4
Mostrar lnformacion Usuario( I ,I ) 1
1 Reset Red Neuronal
7 Inhibir Neuronas
27
El simulador da la opción de tener funciones adicionales a las que é1 ofrece. La manera de implementar estas funciones es a través de la función “Comando de Usuario”. En esta función se tiene un case que evalua los diferentes comandos implementados. Para el caso particular de la 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).
F
+ Mostrar Camino Ploteado = “Comando Desconocido”
Finalmente tenemos la funció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.
28
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 0 robot --> Alpha
robot --> Diameter robot --> State
Datos de sus efectores.
robot -->Motor[i].x robot -->Motor[i].y robot -->Motor[i].Alpha robot -->Motor[i].Value
para i=l,2
Datos de los sensores.
robot -->IRSensor[i].x robot -->IRSensor[i].y robot -->IRSensor[i].Alpha 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 :
0 n input 0 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
0 Tipo de neurona 0 Salida de neurona o 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 + n - hidden + n - output) neuronas.
Datos de las sinapsis
0 Tipo de sinapsis 0 Peso 0 Posición en el arreglo de neurona Dirigida a o 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 hnción sigmoidal ( función out-f)de la siguiente manera:
1
Donde Ui es el nivel de activación de la Unidad o Neurona " i " y
31
sj 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 hnció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 “ 6i ” para las neuronas de la capa de salida se obtiene con la siguiente fórmula( función delta-f-out):
4. = U j ( l - U j ) ( P j - U j )
Donde uj 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):
r 1
6i es la suma de todas las deltas “ sk ‘S ” de las unidades que reciben entrada de neurona ‘3’’ multiplicadas por el peso correspondiente de la unidad “k” a la “j”. A esta suma se le multiplica por la derivada de la funció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):
w..(t Y + 1) = wq(t ) + aSiui + P(wq( t ) - wq(t - 1))
Donde Wij(t+l) es el nuevo peso entre la unidad “i” la unidad “j”, Wíj(t) es el peso actual entre las unidades “i” y ‘3” 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. s j es el grado de error de la unidad “j” . Ui es el nivel de activación de la unidad ‘Y. p 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 (funció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 “j“ el j-ésimo patrón, “y”es el valor del patrón y “u” es el valor de activación de la unidad.
33
V) 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 Kheperu 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
4
5
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
-+ Contacto frontal y su respectiva reacción (Un giro hacia la derecha)
4." Contacto lado izquierdo. (Gira hacia la izquierda)
111, Contacto lado derecho.
34
Contactos Reacciones Descripción
t Contacto del lado derecho e izquierdo.
+ Contacto fi-ontal y por ambos lados.
+ Contacto frontal y lateral izquierdo.
Contacto frontal y lateral derecho.
t" Contacto superior izquierdo.
111, Contacto superior derecho.
Contacto inferior derecho.
- 8 t t No hay contacto, se continúa hacia
adelante.
35
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 1: 1000
Sensor 4: 1 O00 Sensor 5: 0050
Sensor 2: 1023 Sensor 3: 1023
Sensor 6: 0002 Sensor 7 : 0002
Por lo tanto nuestro patrón de entrada queda de la siguiente manera:
{ 0050, 1000, 1023, 1023, 1000,0050, 0002, 0002) 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.
111, 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 O. 1. Por lo tanto el patrón de salida queda de la siguiente manera:
(0.9,O. 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 NUM-HID 5 Número de unidades en la capa oculta #define NUM-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 HIDUID(X) (NUM-IN + X) #define OUT-UID(X) (NUM-IN + NUM-HID + X) #define TARGET-INDEX(X) (X - (NUM-IN + NUM-HID))
#define PATRONES 11 Número de patrones a reconocer #define ERROR-TOLERABLE 0.001 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)*NUM-HID+(NUM-HID+l)*NUM-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 (*unit-out-f)(); Apuntador a la función de activación double delta; Valor delta para cada unidad double (*unit-delta-f)(); Apuntador a la función para calcular delta struct link *inlinks; Para la propagación struct link *outlinks; Para la retropropagación
} *pu[TOTAL+l];
Cada UNIDAD contiene los siguientes datos
LABEL OUTPUT LABEL
OUTPUT *(UNIT-OUT-FO)
DELTA [ *UNIT-DELTA-FO *INLINKS
"OUTLINKS
37
struct link ( 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 *nextpinlink; Apuntadores para el ligado entre las sinapsis struct link *next-outlink;
Cada LIGA contiene los siguientes I
LABEL WEIGHT
DATA FROM-UNIT
*NEXT-INLINK *NEXT-OUTLINK
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-en[PATRONES]; Arreglo para guardar los errores de reconocimiento (delta)
PATRONES DE ENTRADA {Sensor O, Sensor 1, Sensor 2, Sensor 3, Sensor 4, Sensor 5, Sensor 6, Sensor 7)
double inputqat[PATRONES][NUM-IN] = ( (0.0 , 100.0, 850.0, 850.0, 100.0,O.O , 0.0 , 30.0 }, (850.0,200.0, 850.0, 850.0, 100.0,O.O ,O.O , 30.0 }, (0.0 , 100.0, 850.0, 850.0, 200.0, 850.0, 30.0 , 0.0 1, (850.0, 100.0, 10.0 , 10.0 , 100.0, 850.0, 30.0 , 30.0 }, (850.0, 100.0, 10.0 ,O.O , 0.0 , O . O , 850.0,850.0), (0.0 ,O.O , 0.0 , 30.0 ,200.0, 850.0, 850.0, 850.0}, (850.0, 100.0,30.0 ,O.O ,O.O ,O.O , 10.0 , 50.0 }, (0.0 , 0.0 , 0.0 , 10.0 , 100.0, 850.0, 30.0 , 0.0 }, (500.0, 850.0,200.0, 100.0,O.O ,O.O ,O.O ,O.O }, (0.0 , 0.0 , 100.0, 200.0, 850.0, 500.0,O.O , 0.0 } 1;
PATRONES DE SALIDA (Motor izquierdo, Motor derecho}
double targetqat[PATRONES][UM-OUT] = { (0.9,O. 1 }, (0.9,O. 1 }, {0.1,0.9}, {0.9,0.9), (0.9,0.9}, {0.9,0.9}, {0.9,0.9}, (0.1,0.9}, (0.9,0.1}, {0.1,0.9}
1; Declaración de prototipos y variables globales.
38
double out-f(), delta-f-out(), delta-f-hid(), randomso, pattern-error(); long double unidad[TOTAL+2][2],1igas[TOTAL-LIGAS][2];
void main(void) Función principal { char ch; int res; extern struct unit *pu[];
FILE *fp; Apuntador al arreglo que contendrá la red
InicializaArray(unidad,ligas); Valores iniciales para las unidades y las ligas
actpatron(); Se escala el patrón de entrada
do { printf("Qué desea hacer? h"); printf("0->Aprender, 1 ->Reconocer:");
scanf("%d",&res); if(res==O)
fp=fopen("RedNeuronal","w");
else {
fp=fopen("RedNeuronal","r"); LeerRedNeural(unidad,ligas,fp);
I createqrocessing-units(pu,unidad); Se crean las unidades create-in-out-links(pu,ligas); Se crean las ligas if(res==O) { learn(pu); Se aprenden los patrones GuardaRedNeural(pu,fp); fclose(Ep); I
else { fclose(fp); reconocer(pu);
} }while(res!=2); I
El procedimiento createqrocesing-units crea las neuronas de la capa de entrada, oculta y de salida y también crea la neurona bias. Todas la direcciones 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 direcció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) - Pu(1) - Pu(2) - Pu(3) - Pu( 15)"
Pu( 16)-b
createqrocessing-units(pu,unidad)
struct unit *pu[]; double unidad[][2];
{ int id;
struct unit *create-unit();
for (id = IN-UID(0); id < IN-UID(NUM-IN); id++) Se crean la neuronas de entrada
for (id = HID-UID(0); id < HID-UID(NU"H1D); id++)
for (id = OUT-UID(0); id < OUT-UID(NUM-OUT); id++)
pu[BIASUID] = create-unit(BIASUID, "bias",unidad[id][O], NULL, unidad[id][ 13, NULL);
pu[id] = create-unit(id, "input", unidad[id][O], NULL,unidad[id][ 11, NULL);
pu[id] = create-unit(id, "hidden",unidad[id][O], out-f,unidad[id][ 11, delta-f-hid);
pu[id] = create-unit(id, lloutput't, unidad[id][O], out-f, unidad[id][ 11, delta f-out);
Procedimiento 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 outlinks 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
40
Creación de la red neuronal en memoria.
. . . . . .
O
O O O
create-in-out-links(pu,liga) struct unit *pu[]; double liga[][2];
{ int i, j,l; struct link *create-link();
for (i = HIDUID(0); i < HID-UID(NU"H1D); i++) { Ligas de la capa oculta 1=0; Indice para la lectura de los arreglos
pu[BIAS-UD]->outlinks = pu[i]->inlinks = create-link(pu[i]->inlinks, i, pu[BIAS-UIDI->outlinks, BIAS-UID,(char *)NULL,
liga[ll[ol,liga[ll[ll); 1++; for (i = IN-UID(0); j < IN-UID(NUM-IN); j++,l++)
pub]-Boutlinks =
pu[i]->inlinks = create link(pu[i]->inlinks, i, puljl->outlinks, j , (char *)NULL,liga[l][O],liga[l][ 13); 1
-
for (i = OUTUID(0); i < OUT-UID(NUM-OUT); i++) { Ligas de la capa de salida pu[BIAS-UD]->outlinks =
pu[i]->inlinks = create-link(pu[i]->inlinks, i,pu[BIAS-UIDI->outlinks, BIAS-UID,(char *)NULL, liga[ll[ol,liga[ll[ll);
1++; for (i = HID-UID(0); j < HID-UID(NUM HID); j++,l++) pub]->outlinks =
-
pu[i]->inlinks = create-link(pu[i]->inlinks, i, pu~]->outlinks, j,(char *)NULL,liga[l][O],liga[l][ 11 ); 1
I
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
0 O .
0 O .
42
La función randoms calcula un número aleatorio entre O y 1
double randomso {
I return((rand() % 327278) / 327378.0);
La función create-unit crea la unidad solicitando memoria al procesador e inicializa los valores de la unidad. “uid” : 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-f) int uid; char *label; double output, delta; double (*out-f)(), (*delta-f)(); {
struct unit *unitptr;
if (!(unitptr = (struct unit *)calloc(sizeof(struct unit), 1))) { fprintf(stderr, “Error de memoria al crear la unidad h”); exit( 1);
1 unitptr->uid = uid;
unitptr->label = label; unitptr->output = output; unitptr->unit-out-f = 0ut-C unitptr->delta = delta; unitptr->unit-delta-f = delta-C unitptr->inlinks=NULL; unitptr->outlinks=NULL; return (unitptr);
}
La función create-link crea la liga pidiendo memoria al procesador e inicializa los valores de ésta. “start-inlist” : apuntador a la liga de entrada de la primera neurona “to-uid” : identificador de la segunda neurona. “start-outlist” : apuntador a la liga de salida de la segunda neurona “from-uid” : identificador de la primera neurona. “label” : etiqueta de la liga.
“data” : dierencia de pesos entre el actual y el peso anterior. “wt” : peso de la liga.
struct link *create-link(start-inlist, to-uid, start-outlist, from-uid, label, wt, data) struct link *start-inlist, *start-outlist; int to-uid, from-uid; char * label; double wt, data; {
43
struct link *linkptr;
if (!(linkptr = (struct link *)calloc(sizeof(stmct link),l))) { fprintf(stderr, "Error de memoria al crear la liga W'); exit( 1);
I Valores iniciales de las ligas
linkptr->label = label; linkptr->from-unit = from-uid; linkptr->to-unit = to-uid; linkptr->weight = wt; linkptr->data = data; linkptr->next-inlink = start-inlist; linkptr->next-outlink = start-outlist; return(1inkptr);
1 La 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 *pu[];
register i, temp; char tempstr[TAM]; extern int iteraciones; extern double learning-rate, momentum; printf("h4prendiendo "); for (i = O ; i < iteraciones; i++) {
if ((i % NOTIFICAR) == O ) {
{
printf("."); fflush(stdout);
1 bp-leam(pu, (i >= iteraciones-(PATRONES- 1)));
1 printf("\n"); for(i=O;i<PATRONES;i++)
printf(" Hecho\n\n"); printf("error :%If \n",pattern-err[i]);
1
La 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 aprendizaje.
''PU" : arreglo con los apuntadores a las unidades. "save-error" : variable boleana que es verdadero en las últimas PATRONES iteraciones.
bp-learn(pu, save-error) struct unit *pu[]; int save-error; { static int count = O ; static int pattern = O; extern double pattern-err[PATRONES];
44
init-input-unitstpu, pattern); Carga el patrón en las unidades de entrada propagate(pu); Calcula la salida de las neuronas de salida if (save-error)
bp-adjust-weightsbattern, pu); Se reajustan los pesos if (pattern < PATRONES - 1)
else
count++;
patternerr[pattern] = pattern-errorbattern, pu);
pattern++;
pattern = O;
}
El procedimiento 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 función bp-learn.
“PU” : arreglo de apuntadores a las neuronas. “pattern” : número del patrón a cargar.
init-input-units(pu, pattern) struct unit *pu[]; int pattern; { int id;
for (id = IN-UID(0); id < IN-UID(NUMIN); id++) pu[id]->output = inputqat[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(NU”H1D); id++)
for (id = OUT-UID(0); id < OUT-UID(NUM-OUT); id++) (*(pu[id]->unit-out-f))bu[id], pu);
(*(pu[id]->unit-out-f))(pu[id], pu); 1
La hnció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.
‘‘pugrt” apuntador a la neurona que se le calcula el nivel de activación.
double out-f(puqtr, pu) struct unit *puqtr, *pu[]; i
45
double sum = 0.0 , expo; struct link *tmpqtr;
tmpqt r = puqtr->idinks; while (tmpqtr) {
sum += pu[tmpgtr->from-unit]->output * tmpqtr->weight; tmpqt r = tmpgtr->next-inlink;
I puqtr->output = 1 .O/( 1 .O + exp(-sum)); Implantación de la función sigmoidal
La función pattern-error calcula el error cuadrático medio para los patrones de salida como se indicó en el algoritmo.
double pattemerror(pat-num, pu) int pat-num; Número de patrón struct unit *pu[]; { int 1;
double temp, sum = 0.0;
for (i = OUTUID(0); i < OUT-UID(NU"0UT); i++) { temp = targetqat[pat-num][TARGET-INDEX(i)] - pu[i]->output; sum += temp * temp;
1 retum (sud2.0);
I
El procedimiento 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 función que se mostró en el algoritmo.
bp-adjust-weights(pat-num, pu) int pat-num; Número de patrón struct unit *pu[]; { int 1;
double temp 1, temp2, delta, error-sum; struct link *inlinkqtr, *outlinkqtr;
Cálculo de las deltas for (i = OUT-UID(0); i < OUT-UID(NUM-OUT); i++) Para cada unidad de salida
for (i = HID-UID(0); i < HIDUID(NU"H1D); i++) Para cada unidad oculta
Se calculan los pesos for (i = OUT-UID(0); i < OUT-UID(NUM-OUT); i++) { para las unidades de salida
(*(pu[i]->unit-delta-f)(pu, i, pat-num);
(*(pu[i]->unit-delta-f))(pu, i); Cálculo de delta
inlinkqtr = pu[i]->idinks; while (inlinkqtr) { Para cada inlink de la unidad de salida temp 1 = learning-rate * pu[i]->delta *pu[inlinkqtr->from-unit]->output; temp2 = momentum * inlinkqtr->data; inlinkqtr->data = temp1 + temp2; Diferencias de pesos inlinkqtr->weight += inlinkqtr->data; Nuevo peso de la liga
46
inlinkqtr = inlinkqtr->next-inlink; 1
1 for (i = HID-UID(0); i < HID-UID(NU”H1D); i++) { Para cada unidad Oculta
inlinkqtr = pu[i]->idinks; while (inlinkqtr) {
temp1 = learning-rate * pu[i]->delta * pu[inlinkqtr->from-unit]->output;
temp2 = momentum * inlinkqtr->data; inlinkqtr->data = temp 1 + temp2; inli&qtr->weight += inlinkqtr->data;
inlinkqtr = inlinkqtr->next-inlink; 1
I }
La función delta-f-out calcula el delta para cada unidad o neurona de salida, ésta se calcula como se indicó en el algoritmo.
“uid”: identifícador 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) struct unit *pu[]; int uid, pat-num; { double temp1 , temp2, delta;
temp1 = (targetqat[pat-num][TARGET-lNDEX(uid)] - pu[uid]->output); temp2 = (1 .O - pu[uid]->output); delta = temp1 * pu[uid]->output * temp2; 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-hidhu, uid) struct unit *pu[]; int uid; {
“uid”: identificador de el número de unidad de la capa de oculta.
double templ, temp2, delta, error-sum; struct link *inlinkqtr, *outlinkqtr;
outlinkqtr = pu[uid]->outlinks; error-sum = 0.0; while (outlinkqtr) {
error-sum += pu[outlinkqtr->to-unit]->delta * outlinkqtr->weight; outlinkqtr = outlinkqtr->next_outlink;
I delta = pu[uid]->output * (1 .O - pu[uid]->output) * error-sum; pu[uid]->delta = delta;
1 El procedimiento GuardaRedNeural como su nombre lo indica guarda la estructura de la red neuronal en un archivo de tal manera que se pueda cargar desde el archivo con las funciones creategrocessing-units y create-in-out-links
47
"pu": Arreglo de apuntadores para acceder a la red. "fp": apuntador al archivo donde se guardarán el nivel de activación y el delta de cada neurona , y el peso y el data de cada liga.
GuardaRedNeural(pu,fp) struct unit *pu[]; FILE *fp; { int i,j,k; struct link *ligas[TOTAL-LIGAS],*ligtemp;
Se guarda el nivel de activación (output) y delta de cada neurona o unidad for(i=IN-UID(O);i<Ib-UID(NUM-IN);i++) Capa de entrada
for(i=HID~UID(O);i<HlD~UID(NUM~HID);i++) Capa oculta
for(i=OUT-UID(O);i<OUT-UID(NUM-OUT)$++) Capa de salida
fprintf(fp,"%lf,%lf\n",pu[i]-~output,pu[i]-~delta);
fprintf(fp,"%lf,%lf\n",pu[i]->output,pu[i]-~delta);
fprintf(fp,"%lf,%lf\n",pu[i]->output,pu[i]->delta);
fprintf(fp,"%lf,%If\n",pu[i]->output,pu[i]->delta); Se guardan los datos de la neurona BIAS k = N U M N ;
Por la forma en que fue construida la red se guardan los valores de las ligas en un arreglo temporal para 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; while(1igtemp) {
ligas[k-j]=ligtemp; ligtemp=ligtemp->next-inlink; j ++;
1
k=k+(NUM-IN)+ 1 ; 1
k=k+(NUM-HID)-(NUM-IN); for(i=OUT-UID(O);i<OUT-UID(NUM - OUT)$++) {
ligtemp=pu[i]->idinks; j=O; while(1igtemp) {
ligas[k-j]=ligtemp; ligtemp=ligtemp->next-inlink; j++; 1 k=k+NUM-HID+ 1 ;
1
for(i=O;i<TOTALLIGAS;i++) fprintf(fp,"%lf,%lf\n",ligas[i]->weight,ligas[i]->data);
I
El procedimiento actpatron escala el patron en un rango comprendido entre O y 1, porque se uso la función sigmoidal.
48
actpatron() { int i j ; for(i=O;i<8;i++) for(j=O;j<l Id++) inputgat[i]~]=inputqat[i]~]/1023.0;
1
El procedimiento reconocer se encarga de reconocer el patrón indicado reconocer(pu) struct unit *pu[]; { int pt; do { printf("Patron:"); scanf("%d",&pt); init-inputunits(pu,pt); propagate(p4; if(pu[OUT UID(O)]->output> ON-TOLERANCE &&pu[OUT-UID( l)]->output> ON-TOLERANCE )
else if(pu[OUT-UID(O)]->output> ON-TOLERANCE && pu[OUT-UID( l)]-> output <= printf("Ade1anteh");
ON-TOLERANCE) printf("Derecha\n");
else if(pu[OUT-UID(O)]->output<= ON-TOLERANCE && pu[OUT-UID( l)]->output> -TOLERANCE) printf("1zq.h"); printf("%lf,%lf\n",pu[OUT~UID(O)]-~output,pu[OUT~UID( l)]->output); } while(pt!=- 1);
1
El procedimiento LeerRedNeural se encarga de leer los datos de la red neuronal de un archivo donde fueron guardados.
LeerRedNeural(unidad,ligas,fp) FILE *fp; double unidad[][2],ligas[][2]; {int i;
for(i=O;i<=TOTAL;i++) Se leen el "output" y el "delta" de todas las unidades fscanf(fp,"%lf,%lf",&unidad[i][O],&unidad[i][ 11);
for(i=O;i<TOTAL-LIGAS$++) Se leen el "weight" y el "data" de todas las ligas fscanf(fp,"%lf,%lf\n",&ligas[i][O],&ligas[i][ 11);
1
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
InicializaArray(Unidad,Ligas) double Unidad[J[2],Ligas[][2]; { int i j ; FILE *fp; for(i=O;i<TOTAL;i++) Unidad[i][O]=Unidad[i][l]=O.O; Output y delta a cero
49
Unidad[i][O]=l.O; Datos del BIAS Unidad[i][ 11 =O.O;
for(j=O;j<TOTAL-LIGAS;j++) { Ligasu][O]=randoms(); Pesos aleatorios Ligasu][ 1]=0.0; Diferencias de pesos a cero 1
1
50
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); InicializaArray(. . .); LeerRedNeuronal(. . .); createqrocessing units(, , .); create - in-out-links(. . .I; Reconocer(pu,robot);
El procedimiento CargaPatron carga el patrón en el arreglo inputgat en la última casilla de éste.
“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[]; struct Robot *robot;
int i; for(i=O;i<8,i++) inputgat[PATRONES][i]=(double)robot-~Irensor[i].DistanceValue/lO23;
{
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[50]; if(pu[OUT~UID(O)]-~output~0.75&&pu[OUT~UID(l)]-~OUTPUT~O.7~){
robot-~Motor[0].Value=robot-~Motor[ l].Value=5;Movirniento hacia adelante
51
} else if(pu[OUT~UID(O)->output>O.75&&pu[OUT~UID( l)]->output<=O.75) {
robot->Motor[ l].Value=5; Movimiento hacia la derecha robot->Motor[O].Value=-5;
1 else if(pu[OUT~UID(O)->output>O.75&&pu[OUT~UID( l)]->output>=O.75) {
robot->Motor[ l].Value=-5; Movimiento hacia la izquierda robot->Motor[O].Value=5;
I else { Movimiento hacia la derecha para un patrón desconocido
robot->Motor[l].Value=-10; robot->Motor[0].Value=lO;
I I
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 funciones del simulador:
Las funciones InicializaArray, LeerRedNeuronal, createqrocessing 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 funciones 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, AI 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 funciona la red neuronal entrenada.
52
VIII) 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 lo 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 1 O ó 15 grados junto al obstáculo y así 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 bibliografía 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.. .
53
1x)Bibliografía
Bodet, Margaret A., “Filosofia de la inteligencia artzjicial ”, Fondo de Cultura Económica, México, 1994. Graubard, Stephen R., “El nuevo debate sobre la inteligencia artzjicial: Sistemas simbólicos y redes neuronales ”, Editorial Gedisa, Barcelona España, 1993. Hilera, José R., “Redes Neuronales Artzjiciales: Fundamentos, modelos y aplicaciones ”, Addison-Wesley Iberoamericana, Delaware U.S.A., 1995. Jackson Jr., Philip C., “Introduction to artzjicial intelligence” , Dover Publications Inc., N.Y. U.S.A., 1985. McCorduck, Pamela, “Máquinas que piensan: Una incursión personal en la historia y las perspectivas de la inteligencia artzjicial”, Tecnos S.A. de C.V. Madrid España, 199 l. Viana, Laura, “Memoria natural y artiJicial ”, 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 andpolitical forecasting”. John Wiley 8z Sons Inc., N.Y. U.S.A., 1994. White, Halbert, “ArtiJicial Neural Networks: Aproximation 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~l7/Coello2.html.