Universidad De Costa Rica Facultad De Ingeniería Escuela De Ingeniería Eléctrica

Transcript

Universidad de Costa Rica Facultad de Ingeniería Escuela de Ingeniería Eléctrica IE – 0502 Proyecto Eléctrico Desarrollo de una estación experimental para el dimensionamiento de redes neuronales artificiales Por: Mario Segura Strasburger Ciudad Universitaria Rodrigo Facio Junio de 2006 Desarrollo de una estación experimental para el dimensionamiento de redes neuronales artificiales Por: Mario Segura Strasburger Sometido a la Escuela de Ingeniería Eléctrica de la Facultad de Ingeniería de la Universidad de Costa Rica como requisito parcial para optar por el grado de: BACHILLER EN INGENIERÍA ELÉCTRICA Aprobado por el Tribunal: _________________________________ Ing. Roberto Rodríguez Rodríguez Profesor Guía _________________________________ Ing. Federico Ruiz Ugalde Profesor lector _________________________________ Ing. Andrés Díaz Soto Profesor lector DERECHOS DE PROPIEDAD INTELECTUAL • Intel es una marca registrada de Intel Corporation. • Linux es una marca registrada de Linus Torvalds. • GTKMM es un software libre distribuido bajo los términos de la licencia LGPL. • GNUPLOT es un software libre distribuido bajo los términos de la licencia GPL. iii DEDICATORIA A DIOS por acompañarme siempre y regalarme tantas cosas tangibles e intangibles en esta vida. iv RECONOCIMIENTOS A mis papas y a mi hermano por todo el esfuerzo realizado durante tantos años creando las condiciones necesarias para poder realizar mis estudios. v ÍNDICE GENERAL ÍNDICE DE FIGURAS................................................................................ viii ÍNDICE DE CUADROS ..................................................................................x NOMENCLATURA........................................................................................xi RESUMEN......................................................................................................xii CAPÍTULO 1: Introducción .........................................................................13 1.1 Antecedentes .........................................................................................................13 1.2 Justificación ..........................................................................................................14 1.3 Objetivos...............................................................................................................15 1.2.1 Objetivo general....................................................................................15 1.2.2 Objetivos específicos ............................................................................15 1.4 Metodología ..........................................................................................................16 1.5 Herramientas utilizadas.........................................................................................17 1.5.1 Sistema operativo GNU/Linux .............................................................17 1.5.2 Compilador y bibliotecas ......................................................................18 1.5.3 Dependencias ........................................................................................20 CAPÍTULO 2: Desarrollo teórico ................................................................22 2.1 Redes neuronales artificiales ................................................................................22 2.1.1 Descripción de las redes neuronales artificiales ...................................22 2.1.2 Tipos de aprendizaje .............................................................................27 2.1.3 Aprendizaje mediante la propagación de error hacia atrás ...................28 2.1.4 Convergencia y aplicación de pesos aleatorios.....................................32 2.1.5 Regresión lineal ....................................................................................34 CAPÍTULO 3: Implementación de la Estación experimental ...................36 3.1 Implementación de la red neuronal.......................................................................36 3.1.1 Objeto neurona......................................................................................37 3.1.2 Objeto capa ...........................................................................................40 3.1.3 Objeto red .............................................................................................42 3.2 Implementación de la interfaz gráfica ..................................................................48 3.2.1 Creación de la interfaz gráfica ..............................................................48 3.2.2 Programación mediante uso de múltiples hilos de procesamiento .......50 vi CAPÍTULO 4: Utilización de la Estación experimental ............................52 4.1 4.2 4.3 4.4 Topologías utilizadas ............................................................................................52 Introducción de los vectores de prueba.................................................................55 Algoritmo para el control de convergencia...........................................................57 Graficación de las curvas de aprendizaje y de las neuronas .................................65 CAPÍTULO 5: Análisis de resultados ..........................................................67 5.1 Reconocimiento de patrones de texto. ..................................................................67 5.2 Vectores de prueba................................................................................................67 5.3 Análisis de los distintos casos...............................................................................70 5.3.1 Descripción de los distintos casos. .......................................................70 5.3.2 Caso #1. ................................................................................................71 5.3.3 Caso #2. ................................................................................................73 5.3.4 Caso #3. ................................................................................................76 5.3.5 Caso #4. ................................................................................................77 5.3.6 Caso #5. ................................................................................................79 CAPÍTULO 6: Conclusiones y recomendaciones .......................................80 6.1 Conclusiones.........................................................................................................80 6.2 Recomendaciones .................................................................................................82 BIBLIOGRAFÍA............................................................................................85 ANEXOS .........................................................................................................87 Utilización de widgets ........................................................................................87 vii ÍNDICE DE FIGURAS Figura 1. Diagrama de una neurona humana [12] ............................................................22 Figura 2. Modelo eléctrico de una neurona animal. .........................................................24 Figura 3. Curva característica de la función sigmoidal ( =1)...........................................25 Figura 4. Topología típica de un perceptrón multinivel. [20]...........................................27 Figura 5. Diagrama de flujo del algoritmo de propagación del error hacia atrás. ............29 Figura 6. Representación de una función simple de error cuadrático de una red neuronal. [16]....................................................................................................................................32 Figura 7. Representación de un minino local no superable por una red neuronal. [16] ...33 Figura 8. Diagrama de flujo del método aprender. ...........................................................42 Figura 9. Ventana para la introducción de vectores de prueba. ........................................56 Figura 10. Diagrama de flujo del algoritmo para el control de convergencia. .................58 Figura 11. Red neuronal oscilando sobre un mismo mínimo local. .................................59 Figura 12. Red neuronal oscilando mantenidamente sobre un mismo mínimo local. ......60 Figura 13. Diagrama de flujo del algoritmo para evitar que la red oscile. .......................61 Figura 14. Primera derivada del error cuadrático de una red neuronal estabilizándose en una zona. ...........................................................................................................................62 Figura 15. Diagrama de flujo del algoritmo para evitar que la red se estabilice. .............64 Figura 16. Curva de aprendizaje de una red neuronal. .....................................................66 Figura 17. Representación gráfica de los vectores de prueba...........................................69 Figura 18. Patrones de dígitos utilizados para la verificación del aprendizaje de las redes neuronales. ........................................................................................................................69 Figura 19. Curva de aprendizaje de las redes lazo y perceptrón reducido del caso #1.....72 Figura 20. Oscilación sobre un mínimo local del caso #2. ...............................................74 Figura 21. Curva de aprendizaje de todas las redes lazo del caso #2. ..............................75 Figura 22. Curva de aprendizaje de todas las redes lazo del caso #3. ..............................76 viii Figura 23. Objeto Gtk::button. [11] ..................................................................................87 Figura 24. Objeto Gtk::Entry. [11] ...................................................................................89 Figura 25. Objeto Gtk::Checkbutton. [11]........................................................................89 Figura 26. Objeto Gtk::Label. [11] ...................................................................................90 Figura 27. Objeto Gtk::Spinbutton. [11]...........................................................................90 ix ÍNDICE DE CUADROS Cuadro 4.1 Topologías de las redes neuronales tipo perceptrón. .....................................52 Cuadro 4.2 Topologías que utilizan diferentes capas ocultas. ..........................................54 Cuadro 5.1 Vectores de prueba para reconocimiento de dígitos. .....................................68 Cuadro 5.2 Características de cada caso de estudio..........................................................70 Cuadro 5.3 Parámetros del algoritmo de convergencia utilizados en todos los casos......71 Cuadro 5.4 Comparación del desempeño de las redes neuronales del caso #1. ...............73 Cuadro 5.5 Comparación del error final de las redes del caso #1 y del caso #3...............77 Cuadro 5.6 Comparación del desempeño de las redes del caso #1 y del caso #4.............78 Cuadro 5.7 Topologías generadas.....................................................................................79 x NOMENCLATURA GNU: Acrónimo. GNU is Not UNIX. Proyecto que produce aplicaciones para sistemas operativos libres. GTK: Gimp Toolkit. Grupo de bibliotecas para la creación de interfaces gráficas. GTKMM: Implementación oficial de las bibliotecas GTK en lenguaje C++. xi RESUMEN La estación experimental de redes neuronales busca crear una aplicación en donde los usuarios pueden generar y probar diferentes topologías de redes neuronales para obtener una red eficiente que logre resolver su problema. También se plantea que todos los parámetros internos deben ser accesibles y modificables por el usuario. Específicamente se diseño, la estación, para la experimentación con redes neuronales con conexiones hacia adelante y se utiliza el tradicional algoritmo de propagación del error hacia atrás para ajustar los pesos de las conexiones durante la etapa de aprendizaje supervisado. La estación experimental ofrece distintas herramientas para que el usuario pueda estudiar el comportamiento de las redes durante la etapa de aprendizaje. También se implementaron algunos algoritmos para detectar e intentar resolver los principales problemas de aprendizaje de las redes neuronales. El código fuente del sistema se escribió en lenguaje de programación C++ y fue implementado en el sistema operativo Debian GNU/Linux. Esta combinación garantiza un uso estricto y óptimo de los recursos del computador y un sistema totalmente libre y abierto. La estación experimental de redes neuronales artificiales logró cumplir con su objetivo primordial al lograr mostrar al usuario diferentes topologías de redes neuronales, su comportamiento, áreas de optimización y todos sus parámetros internos. xii CAPÍTULO 1: Introducción 1.1 Antecedentes Desde 1943 cuando Warren McCulloch y Walter Pitts presentaron el primer modelo de redes neuronales artificiales se han iniciado cientos de estudios de las conexiones y algoritmos de aprendizaje de estas redes. Día con día estos estudios proponen diferentes métodos y conexiones cada vez más complejas que requieren una asombrosa capacidad de procesamiento por parte de las computadoras. Debido al amplio incremento en el desempeño de las computadoras durante esta última década, muchos de los estudios sobre las redes neuronales artificiales han logrado iniciarse y sus conclusiones han lanzado más preguntas que respuestas. La mayoría de las preguntas se enfocan en entender la jerarquía y las conexiones existentes en los cerebros humanos para lograr modelarlos mediante las redes neuronales artificiales y así poder obtener sistemas inertes capaces de resolver problemas complejos de cualquier naturaleza. Un claro ejemplo de la atención mundial que se le ha brindado al estudio del cerebro humano, sus conexiones y jerarquía es que aproximadamente el diez por ciento de los premios Nóbel de Filosofía y Medicina otorgados durante 1901 y 1991 han sido para científicos que han contribuido a esta área1. Aun, con todos los avances en las estructuras de los procesadores no se ha podido obtener un sistema que imite un cerebro animal con sus múltiples interconexiones y millones de unidades procesadoras de información (neuronas). Por el contrario, la mayoría 14 de las computadoras procesan la información con unos pocos procesadores, comúnmente solo uno, y con estructuras internas que pueden procesar apenas unos pocos procesos en forma paralela. Ninguna supercomputadora, con sus cientos de millones de rápidos transistores, ha logrado superar a nuestro cerebro en la rapidez del cálculo de la posición donde deben apoyarse los pies mientras caminamos manteniendo el equilibrio. 1.2 Justificación La utilización de redes neuronales artificiales ha tenido un gran auge durante los últimos años para resolver problemas complejos que no requieren una respuesta exacta. Es común encontrar en estos sistemas redes neuronales artificiales que contienen una topología rígida y totalmente definida. En la actualidad no existen métodos o sistemas que puedan definir una red neuronal apropiada para la resolución de un problema específico. Es por ello que probablemente muchas de las redes de los sistemas existentes estén siendo subutilizadas o que sea apropiado el uso de una red mayor tamaño o de diferente topología. Los problemas que pueden causar el uso ineficiente de una red neuronal son muy variados. En algunos casos es posible que el número de iteraciones necesarias para que una red aprenda sea muy alto. En otras situaciones es posible que una red este siendo subutilizada y provoque que varias de sus neuronas no influyen sustancialmente en la respuesta total causando un uso ineficiente de los transistores o demás componentes que 1 Fuente: R.Rojas, Neural Networks – A Systematic Introduction. Página #3. 15 formen la red. En algunos pocos casos es posible que se utilicen redes muy pequeñas que no puedan resolver un problema específico. Este proyecto implementa una estación experimental de redes neuronales, en donde el usuario pueda introducir algunos ejemplos de su problema y utilizar múltiples topologías y diferentes tamaños de redes neuronales artificiales para lograr obtener una red apropiada que satisfaga sus necesidades. 1.3 Objetivos 1.2.1 Objetivo general • Desarrollar una aplicación capaz de determinar el tamaño y topología apropiados para la solución de un problema determinado mediante el uso de redes neuronales artificiales. 1.2.2 • Objetivos específicos Construir una red neuronal, con sus parámetros totalmente variables y accesibles al usuario, capaz de resolver cualquier tipo de problema. • Crear una aplicación que dimensione y pruebe varias topologías y tamaños de redes para la solución de un problema particular. • Desarrollar una interfaz gráfica amigable para el usuario que despliegue los parámetros de la red y su curva de aprendizaje. 16 1.4 Metodología • El punto de inicio del proyecto fue la definición del objetivo general y los objetivos específicos, adicionalmente se delimitaron las funciones que la estación debía realizar. • Luego, se escoge el lenguaje de programación y las bibliotecas que se utilizarán para la construcción de la estación experimental y su interfaz gráfica. • Se investigan diferentes algoritmos de aprendizaje y las diferentes conexiones y topologías de las redes neuronales. • Se inicia el desarrollo de la estación, comenzando con la programación de los tres objetos principales que se utilizarán, los cuales son: objeto neurona, objeto capa y objeto red. • Se programa el algoritmo de aprendizaje y se agrega como un método del objeto red. • Una vez que se comprueba el funcionamiento correcto de las redes se inicia con el desarrollo de la interfaz gráfica. • Se investigan y se implementan los métodos para el control de convergencia de las redes neuronales. • Se agregan funciones adicionales a la interfaz grafica tales como: aplicación regresión lineal, graficación de las curvas de aprendizaje y graficación de las neuronas. 17 • Se utilizan hilos de procesamiento paralelo para la ejecutar ciertas funciones de la estación para no afectar el refrescamiento de la interfaz gráfica. • Por último, se realizan varios ejemplos clásicos del uso de redes neuronales para analizar la respuesta de las diferentes topologías haciendo uso de los métodos de convergencia implementados. 1.5 Herramientas utilizadas 1.5.1 Sistema operativo GNU/Linux Debian GNU/Linux fue el sistema operativo que se utilizó para la implementación de la estación experimental de redes neuronales artificiales. Debian es una distribución del sistema operativo libre que utiliza el núcleo 2 Linux y la mayoría de sus aplicaciones proviene del proyecto GNU. Este sistema operativo, Debian GNU/Linux, fue escogido debido a diferentes razones. Principalmente este sistema es muy estable lo que garantiza que el cuantioso uso de recursos y tiempo que se requiere para ejecutar principalmente la etapa de aprendizaje de la aplicación no sea detenido ni removido por otro proceso o por fallas del sistema operativo. Adicionalmente este sistema operativo ofrece y garantiza que todos sus paquetes son y serán libres, al igual que esta aplicación. Esto es muy beneficioso ya que cualquier usuario puede realizar modificaciones al código fuente de la aplicación, compilarlo de 2 Parte esencial del sistema operativo que se encarga de gestionar los recursos del computador. 18 nuevo con distintas optimizaciones y obtener una aplicación personalizada. También Debian GNU/Linux, ofrece más de 15400 paquetes y soporta 11 distintas arquitecturas3, lo que permite que eventualmente la estación experimental pueda difundirse más fácilmente entre todos los usuarios de distintas plataformas. 1.5.2 Compilador y bibliotecas El compilador utilizado fue GCC, que es parte del sistema operativo Debian GNU/Linux y también es parte fundamental del proyecto GNU. Se escogió este compilador ya que contiene múltiples opciones para la optimización del código y por ser un paquete libre garantizando que cualquier usuario puede recompilar el código de la estación acorde a sus necesidades. Adicionalmente GCC es ampliamente reconocido como un compilador de muy alta eficiencia. El código fue escrito en lenguaje C++. Se hizo uso de este lenguaje debido a que es un lenguaje orientado a objetos y permite un uso estricto de la memoria del computador. Debido a la naturaleza de la estación experimental la creación y uso de objetos facilita su desarrollo. El uso estricto de la memoria es fundamental para esta aplicación, debido a que algunos objetos requieren mucha memoria y es por ello que se debe hacer un uso óptimo. Para lograr compilar el código fue necesario el uso de la biblioteca estándar del proyecto GNU llamada libstdc++-v3. Se utilizaron varias opciones del compilador para optimizar la compilación. Específicamente el programa se compiló para procesadores 3 Fuente: Página web oficial de Debian GNU/Linux. http://www.debian.org/intro/about 19 Intel® Pentium ® 4 debido a que los computadores disponibles para el desarrollo y prueba de la estación contienen procesadores de esta familia. Fácilmente cualquier usuario puede modificar esta configuración. También se utilizó una opción muy particular del compilador llamada “pedantic”, que requiere que el código fuente cumpla con estándares ISO C++. La interfaz gráfica se implementó utilizando múltiples objetos de la biblioteca GTKMM. La biblioteca GTKMM es la implementación oficial de GTK+ para el desarrollo de aplicaciones en lenguaje C++. GTK+, que pertenece al proyecto GNU, es un conjunto de herramientas para implementar interfaces gráficas para el usuario. Esta librería cumple con los estándares del proyecto GNOME4 por lo que aseguran estabilidad y compatibilidad de las interfaces gráficas creadas. GTK+ ofrece una amplia gama de botones, herramientas de texto, ventanas y menús. Todos estos elementos son utilizados como objetos de programación en donde sus propiedades, métodos y señales son fácilmente accesibles al programador. Adicionalmente GTKMM contiene una gama de objetos orientados al uso de hilos de programación. Estos objetos son compatibles con los demás elementos gráficos de la aplicación y también cumplen con los requerimientos del sistema operativo Debian GNU/Linux. 4 Fuente: Página web oficial de GTKMM. http://www.gtkmm.org 20 1.5.3 Dependencias Para el correcto funcionamiento de la estación experimental es necesario tener algunos paquetes instalados en el sistema operativo Debian GNU/Linux. Estos paquetes son: • gnuplot Este paquete es necesario para graficar las curvas de aprendizaje y también obtener el diagrama de pesos de las entradas de las diferentes neuronas. • libgtkmm-2.4-dev La interfaz gráfica requiere de las bibliotecas GTKMM. También es recomendable instalar algunos otros paquetes, que no son vitales para el funcionamiento de la aplicación, pero pueden ser de ayuda para el usuario. Estos son: • gnuplot-doc Esta documentación puede orientar al usuario para utilizar correctamente las funciones que ofrece el paquete gnuplot cuando se grafican las curvas de aprendizaje. • libgtkmm-2.4-doc La documentación de GTKMM puede orientar al usuario para el uso correcto de la interfaz gráfica. También es útil, debido a que el código de la estación es totalmente libre, para los usuarios que deseen modificar la interfaz gráfica actual. 21 • atop El uso de este paquete se recomienda para que el usuario observe claramente cuales son los recursos del computador que la estación esta utilizando y puede fácilmente cambiar la prioridad de cualquier hilo que este corriendo. 22 CAPÍTULO 2: Desarrollo teórico 2.1 Redes neuronales artificiales 2.1.1 Descripción de las redes neuronales artificiales Las redes neuronales artificiales son un modelo matemático simplificado que intenta simular la capacidad de procesamiento de los seres vivos. Una neurona de un humano esta básicamente constituida por tres partes elementales. Una etapa inicial, llamada “dendritas”, en donde la neurona recibe la los estímulos mediante señales eléctricas. Esta etapa se conecta al cuerpo de la neurona, “soma”, que es básicamente en donde se procesa la información y por último la respuesta de la neurona se transite a través del “axón”. Figura 1. Diagrama de una neurona humana [12] 23 Durante más de un siglo se ha sabido que la información en el cerebro humano se transmite por utilizando señales eléctricas 5 . También es ampliamente conocido que el conocimiento esta estrictamente ligado a la facilidad de transmisión de señales eléctricas entre las neuronas. Los diferentes químicos que se encuentran en las dendritas regulan la facilidad de paso de los estímulos eléctricos. Estos químicos son producidos y distribuidos a las dendritas por el cuerpo de la neurona, específicamente por la mitocondria. Las respuestas son tomadas en el cuerpo de la neurona basadas en las salidas de las dendritas. Por último el axón se encarga de transmitir la respuesta de la neurona al resto del sistema. Desde el punto de vista de la ingeniería eléctrica es muy sencillo obtener un modelo de una neurona animal. Los estímulos pueden verse como fuentes de voltaje y las dendritas como resistencias variables. Luego el cuerpo de la neurona puede modelarse como un amplificador de corriente, que pasando la corriente del colector-emisor por una resistencia produce un voltaje de salida que es la respuesta de la neurona. El axón puede modelarse como un amplificador de ganancia unitaria, buffer, que debido a su baja impedancia de salida es capaz de mantener constante la respuesta de la neurona independiente de la carga conectada. 5 Fuente: R.Rojas, Neural Networks – A Systematic Introduction. Página #11. 24 Figura 2. Modelo eléctrico de una neurona animal. A partir del modelo eléctrico se obtiene una relación matemática entre las entradas y la salida de la neurona. Y =F ( [W i −1 ⋅ yi ]) (2.1-1) El valor de la resistencia de cada déntrita se llamará “peso” y se representa con el símbolo “W”. El voltaje de salida de cada neurona se representara con el símbolo “Y”. Por último “F” es la función de transferencia del amplificador transistorizado. La función de transferencia del amplificador no se asume que es lineal, como se supone en la mayoría de los casos de problemas electrónicos, puesto que el comportamiento natural de las neuronas no es lineal. Durante muchos años de estudio de 25 las neuronas han surgido diversas propuestas de la función de transferencia de una neurona animal. En algunos estudios iniciales se propone utilizar una función escalón. Sin embargo esta teoría ha decaído durante los últimos años ya que no se ha observado un comportamiento discreto de las neuronas animales sino mas bien su respuesta es continua pero muy sensible a los cambios en las salidas de las dendritas. Es por ello que en la actualidad ha tomado mayor fuerza el uso de la función sigmoidal como la función de transferencia que modela la decisión de la neurona. Desde el punto de vista del modelo electrónico la respuesta del transistor es similar a la función sigmoidal pero con un desplazamiento en el “eje x”. y (γ , x ) = 1 1 + e (γ ⋅ x ) (2.1-2) La ecuación 2.1-2 muestra la función sigmoidal que depende del parámetro “gamma” y su entrada “x”. El parámetro “ ” determina la pendiente de la función. Salida 1 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0 -6 -4 -2 0 2 4 Entrada Figura 3. Curva característica de la función sigmoidal ( =1). 6 26 En nuestros cerebros existen cientos de millones de neuronas complejamente interconectadas entre sí. Lo que si es claro es que existen niveles jerárquicos en esta estructura. Básicamente existen neuronas que reciben los estímulos externos de los sentidos, otras neuronas reciben sólo las respuestas de otras neuronas y el último nivel de neuronas se encarga de ejecutar la respuesta total del sistema6. Es importante recalcar que la conexión entre un bloque y el siguiente bloque en orden jerárquico no es exclusiva. Por ejemplo las neuronas que reciben los estímulos pueden enviar señales directamente a las neuronas que se encargan de ejecutar la respuesta del sistema. Igualmente en estas complejas estructuras existen realimentaciones en donde las respuestas de las neuronas de mayor orden jerárquico son enviadas a bloques inferiores. También se han observado neuronas que una de sus dendritas este conectado al axón de la misma neurona. La estación experimental implementada no contempla conexiones en donde la respuesta es realimentada a la misma neurona o a bloques inferiores. Comúnmente a las estructuras que no consideran conexiones realimentadas ni conexiones entre neuronas de la misma capa son llamadas estructuras con conexiones hacia adelante. La topología con conexiones hacia adelante más comúnmente utilizada es el perceptrón multinivel. Esta red neuronales artificial esta construida de tres capas, una de entrada que recibe los estímulos externos. Una capa intermedia, comúnmente llamada capa oculta, que procesa la información de la capa de entrada. Al final se encuentra una capa de salida, que esta constituida de tantas neuronas como salidas tenga la red. 6 Fuente: R.Rojas, Neural Networks – A Systematic Introduction. Página #10. 27 Figura 4. Topología típica de un perceptrón multinivel. [20] 2.1.2 Tipos de aprendizaje Existen básicamente dos tipos de aprendizaje para las redes neuronales. Uno es el aprendizaje supervisado en donde la red requiere de un proceso de aprendizaje en donde se estimule y se le presente la respuesta esperada. El otro tipo de aprendizaje, llamado no supervisado, no requiere de un periodo de entrenamiento. Las redes neuronales con aprendizaje no supervisado comúnmente necesitan de un amplio estudio de su topología y de sus pesos iniciales para su correcto funcionamiento. También existen otros algoritmos para el aprendizaje no supervisado que varían los pesos de las conexiones dependiendo de la tasa de cambio de las entradas de cada neurona. Comúnmente las redes que utilizan este tipo de algoritmos son llamadas redes de aprendizaje competitivo, puesto que las neuronas u entradas que más cambios presenten se les incrementa el valor de sus pesos y por ende la importancia en la respuesta final. 28 El aprendizaje supervisado, por el contrario, requiere de una etapa en donde la red se vea sometida al cambio de sus pesos mediante la aplicación de un algoritmo determinado. Para esta etapa se requiere que el usuario preparare un conjunto de estímulos y respuestas esperadas, para que la red aprenda el comportamiento que debe seguir. Ordinariamente esta etapa de entrenamiento consume mucho tiempo y millones de cálculos en punto flotante. A la red se le muestra en múltiples ocasiones los mismos vectores de prueba para que las conexiones entre las neuronas de diferentes capas se adapten y se genere la respuesta esperada. 2.1.3 Aprendizaje mediante la propagación de error hacia atrás El algoritmo de propagación del error hacia atrás es el método que más ha sido utilizado en todos los sistemas de redes neuronales y tiene la facilidad de que puede ser implementado en redes con conexiones hacia delante de cualquier tamaño y topología.7 Este algoritmo se basa en la búsqueda del valor mínimo local de la función de error cuadrático de la red neuronal. A cada neurona, basado en una fórmula matemática, se le asocia un índice de error llamado el valor delta. Luego basándose en este valor, el algoritmo varía sistemáticamente el valor de los pesos de las entradas de cada neurona para disminuir el error cuadrático total. Particularmente el delta de las neuronas de la capa de salida debe siempre tender a cero. Esto se debe a que una consideración esencial del algoritmo es que si el valor delta de cada neurona de la capa de salida es muy cercano a 7 Fuente: R.Rojas, Neural Networks – A Systematic Introduction. Página #149. 29 cero, el conjunto de pesos de la toda la red es una solución particular del problema propuesto y por lo tanto un mínimo local de la función del error cuadrático. El algoritmo se compone de cuatro pasos fundamentales repetibles para cada vector de prueba que el usuario desee utilizar. El algoritmo debe repetirse cuantas veces sea necesario hasta obtener un error cuadrático tolerable por el usuario. El estado inicial es la excitación controlada de la red. Figura 5. Diagrama de flujo del algoritmo de propagación del error hacia atrás. 30 Luego de excitar controladamente la red y obtener su respuesta esta debe ser comparada con el vector de prueba esperado. Debido a que cada salida de la red corresponde a la salida de cada neurona de la capa de salida se calcula el delta de cada neurona de salida individualmente y no como un conjunto o sumatoria como proponen algunas variaciones del algoritmo. ∆ i = (Vd i − Voi ) ⋅ Voi ⋅ (1 − Voi ) (2.1-3) El valor Vd corresponde al valor esperado de cada salida y la variable Vo representa el valor obtenido por la red. Esta fórmula nace fundamentalmente de la derivada de la función de error cuadrático y contiene múltiples simplificaciones producto del uso de la función sigmoidal. Debido a que se utiliza una derivada para el cálculo del delta, la función de activación de todas las neuronas debe ser continua y derivable. El siguiente paso consiste en el cálculo del delta de cada neurona perteneciente a las demás capas de la red. En este cálculo reside la propagación del error hacia atrás, puesto que el delta de cada neurona toma en cuenta el delta de la neurona de la siguiente capa. El valor del peso con que se conecta la neurona analizada con las neuronas de la siguiente capa juega un papel fundamental en la proporción del error propagado. Por ejemplo, si una neurona no es relevante para las neuronas de la siguiente capa, debido a que las conexiones son muy débiles, el error aportado por esta neurona es muy bajo. En cambio si una neurona es muy relevante en la decisión final de la red debido a que sus conexiones son muy fuertes con la capa superior el error cometido por esta neurona influye en el error total, por lo que el valor delta será relativamente grande. 31 ∆ c ,i = [(∆ c +1, j ] ⋅ Wc +1,i ) ⋅ Voc ,i ⋅ (1 − Vo )c ,i (2.1-4) En esta nomenclatura se utiliza el símbolo “i” para cada neurona de la capa oculta “c”. Mientras que “j” representa a cada neurona de la capa superior inmediata. El peso entre la neurona “i” y “j” es representado por la letra “W”. Por último “Vo” representa la salida de la neurona a la cual se el esta calculando el delta. El paso final para completar el algoritmo consiste en la modificación proporcional de los pesos que representan las conexiones de toda la red. El cambio experimentado por un peso depende de cuan fuerte es el valor de entrada de esa dentrita y del valor delta de la neurona. Wt +1,i , j = (α ⋅ ∆ i ⋅ Voc −1, j ) ⋅ Wt , j (2.1-5) Un parámetro muy importante que se utiliza para la actualización de pesos es la variable alfa. Con este valor el usuario es capaz de definir la tasa de variación de los pesos, y con ello se logra modificar el comportamiento global de la red. La variación de este parámetro puede causar que rápidamente se encuentre un mínimo local con un error aceptable o también fácilmente se pueden entrar en una zona de oscilación en donde la red no es capaz de aprender el problema dado. Al final del algoritmo es común calcular el valor del error cuadrático. Este es el indicador de aprendizaje de la red, y por excelencia es el valor que el usuario utiliza para definir si requiere que la red continúe en la etapa de entrenamiento. [(∆ ) ] 2 E= i, j 2 (2.1-6) 32 2.1.4 Convergencia y aplicación de pesos aleatorios Al iniciar la etapa inicial de entrenamiento de la red es común inicializar de forma aleatoria el valor de los pesos de toda la red. Esto se realiza debido a que la probabilidad de estar cerca de una zona convergencia es mayor. Si inicialmente todos los pesos se inician en cero todas las salidas de la red serian iguales a 0.5 y es poco probable que el usuario requiera una salida constante de todas las respuestas de la red en este valor. La función de error es por lo general un polinomio extremadamente complejo y contiene tantas variables como conexiones entre las neuronas haya en la red. Es por ello que no es viable hacer análisis de esta función y buscar puntos de bajo error. Figura 6. Representación de una función simple de error cuadrático de una red neuronal. [16] 33 El algoritmo de propagación del error hacia atrás busca los mínimos locales de la función de error. El problema reside en que no siempre el error obtenido en un mínimo local es tolerable por el usuario. Dependiendo de los puntos vecinos pertenecientes al hiperplano de la función de error es común observar oscilaciones de la red sobre un mismo punto sin que salga de esta zona. Esto provoca que la red no aprenda y nunca converja al error máximo aceptable por el usuario. Otro comportamiento que se observa en las redes es que entran a amplias zonas donde el error de todos los puntos pertenecientes a la función de error son muy similares. Esto requiere de un alto número de iteraciones para que la red salga de esta zona y encuentre algún mínimo local. Figura 7. Representación de un minino local no superable por una red neuronal. [16] 34 El algoritmo de propagación del error no propone un método para la detección de estos problemas de convergencia ni tampoco una solución. Aun así, es indiscutible que al aumentar el parámetro alfa es una solución. Al aumentar este parámetro los pesos variaran drásticamente logrando que la red se mueva hacia otras zonas del hiper-plano distintas a la zona problemática en donde esta situada. 2.1.5 Regresión lineal El método de regresión consiste en encontrar una función que relacione un conjunto de entradas de un sistema desconocido con su salida. Particularmente el método de regresión lineal asume que las entradas y las salidas están modeladas por una función lineal 8 . Para lograr aplicar el método se requiere de un conjunto de observaciones del sistema tomando en cuenta sus entradas y sus salidas. Yi = m ⋅ x n (2.1-7) La ecuación anterior es el modelo propuesto por el método de regresión lineal, en donde “X” representa una entrada y “Y” representa una salida del modelo. El parámetro “m” se calcula de modo tal que el error entre el modelo “Y” y las observaciones,”F”, sea mínimo. ei = Fi − Yi 8 Fuente: W.E. Castillo, Algebra Lineal. Página #247. (2.1-8) 35 El parámetro “m” debe calcularse, basados en las observaciones de las entradas y salidas del sistema, de la siguiente forma: m= [Fi ⋅ xi ] [x ] 2 (2.1-9) i Debido a que las neuronas de la capa de entrada reciben una única entrada, pero debido a las conexiones influyen en todas las salidas es posible calcular un modelo lineal entre cada entrada y cada salida. Obteniendo estos modelos es posible variar adecuadamente el parámetro gamma de la función sigmoidal para que la pendiente de esta función de activación sea similar al modelo encontrado. Para obtener la correcta variación de gamma se aplicar la aproximación de Taylor alrededor de un punto dado que depende de las entradas y los pesos de cada neurona de la capa de entrada. 36 CAPÍTULO 3: Implementación de la Estación experimental 3.1 Implementación de la red neuronal La implementación de la red neuronal se basó en el uso de objetos de diferentes jerarquías que mantuvieran la flexibilidad de realizar cambios sin afectar el resto de la red. También se programaron todos objetos de tal modo que los parámetros fueran totalmente accesibles y modificables por los usuarios directamente o por otros objetos. El primer objeto y el mas elemental que se creó fue el objeto neurona que consiste en la implementación de las funciones y propiedades típicas de una neurona artificial. Seguidamente se implementó el objeto capa encargado de crear y organizar varias neuronas en un mismo conjunto. Esto se realizó con el fin de poder realizar funciones simultáneas en conjuntos de neuronas sin tener que acceder directamente cada una de las neuronas. El último objeto, el de mayor jerarquía, que se programó fue el objeto red. Este es capaz de organizar grupos de capas y conectarlas entre sí. Este objeto pretende que el usuario no deba realizar funciones de bajo nivel tales como reservar memoria para cada neurona y conectar capas de modo que se forme una red neuronal con conexiones hacia adelante. El objeto vp fue la última parte de la implementación de la estación experimental. Este objeto se encarga de crear una interfaz gráfica, implementar los métodos de aprendizaje y controlar un arreglo de redes neuronales independientes de diferentes topologías. Este objeto utiliza múltiples objetos contenidos en las bibliotecas GTKMM, tales como cuadros de texto, enunciados, botones, entre otros. 37 3.1.1 Objeto neurona Este objeto es la implementación del modelo matemático de una neurona de un ser vivo. Cada objeto recibe un conjunto de entradas y pesos y esta se encarga de almacenarlos y calcular su salida. Cada una de las entradas de la red se compone de un estímulo y de un peso. Por esta razón y para mayor facilidad del manejo de estos pares de variables se definió un nuevo tipo de variable, monomio, que contiene una estructura en donde se almacenan ambas variables. Cada neurona puede tener un número variable de estímulos dependiendo de la aplicación que el usuario quiera darle. Es por ello que este objeto se programó de tal forma que el número de monomios de cada neurona fuera definido dinámicamente en el tiempo de ejecución del programa y no durante el tiempo de compilación. Esta metodología también implementa intrínsecamente una optimización en el uso de la memoria del computador puesto que se reserva únicamente el número de monomios que la neurona requiere. Esta parte del código no se incluyó como parte del constructor del objeto, puesto que la estación experimental permite redimensionar las redes y para los objetos de mayor jerarquía es más fácil llamar y utilizar método del objeto neurona que el constructor. 38 ! " # $$ $ () () % & " ' " * " * Tal y como lo recomiendan diferentes autores es útil inicializar los pesos de las neuronas con valores pequeños y de manera aleatoria para lograr un error pequeño en unas pocas iteraciones. El objeto neurona fue implementado con un método que pudiera realizar esa propuesta. Para ello se utilizó la función mrand48() perteneciente a la biblioteca math.h y se aplicó la inversa para obtener un número pequeño. El cálculo de la salida de cada neurona es un punto vital para el correcto funcionamiento de la red. El objeto neurona presenta dos maneras distintas para devolver el valor de su salida. El método fundamental consiste en calcular, mediante la función sigmoidal y todas sus variables, la respuesta a los estímulos en conjunto con sus pesos. Este método además de devolver el valor de la salida, también lo almacena en una variable del objeto. El segundo método no calcula el valor de la salida sino que lo obtiene directamente de la variable que es manipulada por el primer método. Esto presenta una optimización de la capacidad de procesamiento del computador que se este utilizando puesto que muchos de 39 los algoritmos de aprendizaje requieren obtener la salida de las neuronas a estímulos que sucedieron en tiempo pasado. + " , " # $ . .$ & ( $$ - / % , / %0 +/1+21/ 31 /104 31/ ,/1* / ,01/53%6310 133 Es importante recalcar que para mayor precisión en los cálculos de la red se decidió utilizar variables del tipo double, aún tomando en cuenta el consumo de memoria de acceso aleatorio. Las variables tipo float pueden almacenar números con una precisión de siete decimales mientras que las variables de tipo double almacenan como mínimo quince decimales9. En muchas ocasiones los pesos de las redes deben variarse muy levemente por lo que justifica su uso. Por último el objeto neurona contiene todos los métodos necesarios para leer y escribir los parámetros de la neurona y de aprendizaje. Estos métodos se encuentran definidos en el encabezado del objeto. 9 Fuente: L. Joyanes Aguilar, Programación en C++. Página #52. 40 "7 " " "7 " 3 " 3 3 . 3.1.2 " 3 Objeto capa Las neuronas que se encuentran en una misma capa de una red con conexiones hacia adelante presentan características comunes entre sí. Este objeto se encarga de crear una capa con todas las neuronas requeridas y de compartir las características comunes, realizándolo de tal modo que sea más fácil para otros objetos controlar estas neuronas. El objeto contiene un método primordial, llamado inicializar, que se encarga de crear en memoria únicamente las neuronas necesarias. Para ello recibe dos parámetros: el número de neuronas de la capa y el número de entradas que cada neurona debe contener. Las neuronas creadas se organizan en un arreglo y mediante el uso de punteros se accede a cada uno de los métodos y propiedades de estas nuevas neuronas. La longitud de arreglo unidimensional también se define dinámicamente durante el tiempo de ejecución de la estación experimental. 41 8 7 * & % 8 & ! " # $$ $ * 8 / () * 8 Las generalizaciones principales que realiza esta clase son las funciones de calcular la salida de cada neurona y generar pesos aleatorios de las entradas de sus neuronas. Estas funciones utilizan un puntero para seleccionar cada neurona y ejecutar sus métodos. 3 " # $ $$ / / () + " $ # () $$ % + 42 3.1.3 Objeto red El objeto red es la implementación final de la red neuronal artificial. Al crear este objeto el usuario es capaz de definir cualquier topología y tamaño de red con conexiones hacia delante. Además dispone de un algoritmo de aprendizaje y múltiples métodos para modificar los parámetros de cualquier neurona. El algoritmo incluido en este objeto fue el de propagación del error hacia atrás. El objeto recibe un vector de prueba y realiza una iteración. Si el usuario no ha especificado los valores de las variables gamma y alfa se utilizan los valores típicos que son definidos en el constructor de cada neurona y del objeto red. El método aprender sigue los siguientes pasos para aplicar el algoritmo: Figura 8. Diagrama de flujo del método aprender. 43 El primer paso requiere que previamente el usuario haya utilizado los métodos vpentrada y vpsalida para introducir al objeto el vector de prueba deseado. De esta forma el primer paso del método aprender ingresa a la entrada de cada neurona de la primera capa cada valor deseado por el usuario, haciendo uso del método pentrada. "! 9 " "7 3 $$ # $ * : 0 7 "7 ; Es importante recalcar que el usuario debe crear los vectores de prueba y enviar únicamente el puntero de este arreglo. De este modo el consumo de memoria de acceso aleatorio se disminuye levemente. El siguiente paso que se sigue el método aprender es calcular la salida total de la red utilizando como estímulos el vector de prueba ingresado en el paso anterior. + , < & & " & # ! () (. & $$ + & $.! 7 $$ + " # & / % & & " ! 9 # & % & & (.! () + $.7 7 7 & & 7 & & : 1 ; $$ 44 Esta función implementa una solución para una pequeña complejidad en el cálculo de las salidas de las salidas de las capas intermedias que normalmente las escasas aplicaciones de redes neuronales artificiales no contemplan. Es en la solución de este problema donde reside la flexibilidad de la estación experimental de implementar cualquier tipo de red de cualquier topología o tamaño. El cálculo de salidas se lleva a cabo de la capa de entrada hacia las capas de intermedias y por último la de salida. Cada capa, excepto la de entrada, recibe tantas entradas como salidas tenga la capa anterior. Es por ello que este objeto requiere que el usuario defina con anterioridad la topología en el arreglo neusporcapa, de este modo se pueden ir propagando las respuestas de las capas inferiores a las capas superiores en el orden correcto. La mayoría de las aplicaciones existentes en el mercado diseñadas para redes neuronales artificiales asumen que todas las capas ocultas tienen tantas entradas como entradas tiene la red. Es por ello que contienen una sola topología, comúnmente llamada perceptrón multinivel, y la aplicación ofrece poca flexibilidad. El tercer paso consiste en el cálculo del valor delta iniciando por la capa de salida e ir propagando este valor hacia las capas de inferiores. También al realizar estos cálculos se incluyó el cálculo del error cuadrático. Tomando en cuenta que la funcionabilidad y distribución de las capas varía, se consideró pertinente realizar el cálculo del valor delta en tres distintas etapas. La primera consiste en calcular el delta de la capa de salida; una función relativamente sencilla. 45 + : (= -=- .(= = " 4 8 (.! " - % # $$ $ (.7 ( - - .( 7 - (.7 $ 0 0 + > , La siguiente etapa consiste en el cálculo del delta de las capas ocultas. Esta función es ligeramente más compleja puesto que debe considerarse que el número de neuronas en estas capas puede variar y no es una constante tal y como sucede con el perceptrón multinivel típico. + :3 & (? 8 & )" & & # ! " & & (( 0 7 9 $$ 0 " 0 & & + & & $$ & " & & $ & &- .(& 7 7 $ - & & & - $.! & $.7 $.7 & + 3 , & & # & & & 7 46 La etapa final consiste en el cálculo del delta de la capa de entrada. Este grupo de instrucciones es similar a la segunda etapa pero ciertas instrucciones se eliminaron debido a ciertas simplificaciones que se pueden deducir de las redes con conexiones hacia delante. Esto provoca que algunas operaciones no tengan que ser realizadas y el número de instrucciones que debe ejecutar el procesador en cada iteración sea menor. Esta pequeña simplificación es importante ya que en el proceso de aprendizaje de la estación experimental este método se utiliza algunos cientos de millones de veces. + "! " & 0 9 # $$ "7 " 0 + .! & & & & $$ & & .7 .7 - $ "7 &- .(& 7 $ - " & & & & & 0 & # & 7 & + 3 , El último paso que sigue el algoritmo de aprendizaje es la actualización de los pesos de las entradas. Este se dividió en dos grupos de instrucciones, uno para actualizar los pesos de la capa de entrada y otro grupo de instrucciones para actualizar los pesos de las demás capas. 47 / 8 "! " "7 "7 "7 0 9 # $$ 0 0 7 " "7 7 " 0 + + $ 7 "7 3 Al igual que en el paso anterior se incluyen algunas simplificaciones para reducir el numero de cálculos que debe realizar el procesador. Es por ello que el siguiente grupo de instrucciones que actualizan los pesos de las capas ocultas y de la de salida es más numeroso que el anterior. / 8 & . & # & $$ & (.! ! & " 0 0 # & $$ 7 & 9 9 0 " & # & 0 & 7 7 & 0 & & 7 $ 7 & (.7 7 & + + 3 $$ 48 3.2 Implementación de la interfaz gráfica 3.2.1 Creación de la interfaz gráfica La idea principal con que se implementó la interfaz gráfica fue crear una ventana principal en donde el usuario fácilmente pueda tener acceso a todos los parámetros de las distintas redes. También se diseño de modo que el usuario intuitivamente pudiera seguir los pasos necesarios para probar y experimentar con las redes deseadas. Debido a los requerimientos de GTKMM se creó una clase principal que es el código fuente que define el aspecto gráfico de la estación experimental. Luego un programa principal crea un objeto de esta clase y de este modo se ejecuta la interfaz gráfica. La estación experimental hace uso de objetos tipo red para la generación y control de las distintas redes neuronales que el usuario utilice. Los múltiples parámetros que el usuario introduce para la experimentación son introducidos como cadenas de caracteres. Por otro lado toda la información sobre las redes son datos numéricos y se despliegan como texto en la interfaz gráfica. Es por ello que la clase grafica contiene múltiples funciones para la conversión de texto a datos numéricos. Para ello se hizo uso de algunas clases y funciones de la ampliamente utilizada librería iostream de C++. La siguiente función recibe un dato tipo double y lo despliega en la ventana principal de mensajes de la estación experimental. 49 & / & ## : () @ @ / & También es bastante complejo modificar correctamente objetos de la interfaz gráfica desde hilos de procesamiento secundarios o desde objetos de menor jerarquía. Es por ello que se decidió que la clase gráfica debía controlar todo el flujo de información de la estación y de los objetos red. Por lo tanto todos los algoritmos automáticos y manuales de aprendizaje que la estación ofrece están implementados en la interfaz gráfica y no en el objeto red. Para la implementación de cualquier método para el control de convergencia, utilizando el algoritmo de propagación del error, es necesario contener un grupo fácilmente accesible de vectores de prueba. Es por ello que la clase gráfica también se encarga de almacenar estos vectores e introducirlos grupalmente a la red. Se implementó la siguiente función que introduce todos los vectores de prueba disponibles en la red que el usuario seleccione, adicionalmente se hace uso del método aprender del objeto red para realizar una iteración de aprendizaje completa. 50 * < A ! 8 : @ & " ! : ! : ! : # $$ ! ! ; ; B Los métodos de convergencia implementados requieren de la aplicación de derivadas a la función de error para el conocer el comportamiento de la red. Es por ello que también se implementó dentro de la clase gráfica el cálculo de estos datos. Esto es muy simple debido a que el error cuadrático se calcula de modo discreto y basta calcular la diferencia entre dos puntos para obtener su pendiente. También los algoritmos de convergencia requieren de múltiples comparaciones de resultados de las redes con parámetros introducidos por el usuario que también se implementaron en la clase gráfica. 3.2.2 Programación mediante uso de múltiples hilos de procesamiento La estación experimental hace uso de hilos de procesamiento en paralelo básicamente para no interrumpir el refrescamiento de la ventana principal. Para la implementación se utilizó una clase perteneciente a GTKMM exclusiva para el manejo de hilos compatible con los otros elementos de la interfaz gráfica. Para lograr ejecutar un hilo secundario basta con definir un objeto de la clase especializada y enviar la información 51 requerida para el constructor de este objeto. De este modo al definirlo se ejecuta el grupo de instrucciones contenidas en el puntero de la función enviada. Por ejemplo la siguiente línea de código define un objeto tipo Glib::Thread que ejecuta la función plotear. > - 6A > 6A # ) @ -A 7 C 7 7 52 CAPÍTULO 4: Utilización de la Estación experimental 4.1 Topologías utilizadas La estación experimental utiliza doce distintas redes con diferentes topologías y también permite que el usuario genere una red con cualquier topología que se desee. Las doce redes predefinidas por la estación experimental se dividen en dos grupos. El primer grupo contiene cinco variaciones del perceptrón multinivel típico de tres capas. Cada una de estas redes contempla una variación clásica del número de neuronas de la capa intermedia. Cuadro 4.1 Topologías de las redes neuronales tipo perceptrón. Índice Nombre Número de neuronas de la capa oculta 0 Perceptrón multinivel Igual que el número de entradas de la red 1 Perceptrón reducido Igual que el número de salidas de la red 2 Diamante mínimo Contiene una neurona más que el número de entradas de la red 3 Diamante doble Contiene el doble de neuronas que el número de entradas de la red 4 Lazo Contiene únicamente una neurona 53 La primera red utiliza la topología perceptrón multinivel típica utilizada en la mayoría de sistemas. En esta topología la capa intermedia contiene igual número de neuronas que la capa de entrada. Ordinariamente las redes neuronales artificiales contienen más estímulos que respuestas y por ello esta topología es muy utilizada puesto que contiene un número neuronas en la capa oculta que introducen más grados de libertad y es posible resolver problemas más complejos. También es posible que el problema que se deba resolver no sea tan complejo y se requieran menos neuronas en la capa oculta que el número de estímulos de la red y por ello se hace uso de la topología perceptrón reducido. Es llamada de este modo puesto que se supone que contendrá menos neuronas que el perceptrón típico, aunque si la red contiene más salidas que entradas el número de neuronas aumentará. Primordialmente estas dos topologías buscan encontrar si existe una relación óptima entre el número de neuronas de la capa oculta y los estímulos o salidas de la red. Las siguientes dos topologías pertenecen a la familia de diamantes. El diamante mínimo agrega una neurona adicional al perceptrón multinivel con el fin de analizar si agregando un número relativamente pequeño de grados de libertad a la función de error la etapa de aprendizaje requiere menos iteraciones que el perceptrón multinivel típico para alcanzar un mínimo local aceptable. El diamante doble agrega un número relativamente alto de neuronas a la capa oculta aumentando drásticamente los grados de libertad de la función de error. En teoría, esta red puede resolver problemas más complejos que los que puede resolver una red utilizando las topologías mencionadas anteriormente. Por último la topología lazo contiene el mínimo neuronas posibles que una red con capas ocultas puede contener. Se incluyó esta topología debido a que si logra resolver el 54 problema propuesto por el usuario, esta seria una solución optima desde el punto de vista de utilización de recursos. El segundo grupo de topologías utilizan un número de capas y neuronas ocultas variado. Estas topologías son ampliaciones del perceptrón multicapa y de topologías tipo diamante. La estación experimental utiliza este segundo grupo de redes de manera opcional. También la estación define dinámicamente el tamaño de estas topologías y depende de cual fue la red, perteneciente al primer grupo de topologías, que obtuvo el menor error cuadrático. Por lo tanto, a la red que obtuvo un error al final de la etapa de entrenamiento, se le aplican las topologías del segundo grupo para analizar el comportamiento de la red cuando se modifica el número y tamaño de las capas ocultas. Se toma como base el número de neuronas de la capa oculta de la red seleccionada. Cuadro 4.2 Topologías que utilizan diferentes capas ocultas. Índice Nombre Número de capas ocultas Topología10 6 Perceptrón multinivel doble 2 E-X-X-S 7 Perceptrón multinivel triple 3 E-X-X-X-S 8 Diamante triple 3 E-X-X+1-X-S 9 Perceptrón cuádruple 4 E-X-X-X-X-S 10 Perceptrón cuádruple ampliado 4 E-X-X+1-X+1-X-S 11 Penta perceptrón 5 E-X-X-X-X-X-S 12 Penta diamante 5 E-X-X+1-X+2-X+1+X-S 10 El símbolo “E” representa el número de entradas, “S” representa el número de salidas y “X” la cantidad de neuronas de la capa oculta de la red que obtuvo menor error en la etapa de aprendizaje. 55 4.2 Introducción de los vectores de prueba La estación experimental contiene dos métodos para ingresar los vectores de prueba que el usuario desee. El primero es un método manual donde el usuario ingresa uno por uno los vectores de prueba a la estación. El segundo es un método más efectivo que permite leer los vectores de prueba de un archivo que el usuario seleccione. En ambos casos el número de entradas y salidas de la red deben haberse introducido previamente a la estación experimental para que el programa logre correctamente ordenar los vectores durante la etapa de aprendizaje. Si se hace uso de un archivo, este debe contener un formato preestablecido para que el programa pueda correctamente separar las entradas y las salidas de los vectores de prueba. Cada vector de prueba debe estar escrito en una única línea y debe contener sus entradas separadas por una coma, luego se debe introducir un espacio para separar las entradas de las salidas. Al igual que las entradas, las salidas deben estar separadas por una coma. El siguiente texto es un ejemplo de un archivo que contiene diez vectores de prueba, conteniendo treinta y cinco entradas y una salida: "7 "7 "7 "7 .7 "7 "7 "7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 . ": . "7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 .7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 "7 .7 .7 .7 . ": ? .7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 .7 .7 .7 .7 . ": D .7 "7 "7 "7 .7 .7 "7 "7 "7 .7 .7 "7 "7 "7 .7 "7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 . ": E .7 .7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 .7 .7 .7 .7 . ": F .7 .7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 .7 .7 .7 .7 .7 "7 "7 "7 .7 .7 "7 "7 "7 .7 .7 .7 .7 .7 . ": G .7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "": H "7 .7 .7 .7 .7 "7 .7 "7 "7 .7 "7 .7 "7 "7 .7 "7 .7 .7 .7 .7 "7 .7 "7 "7 .7 "7 .7 "7 "7 .7 "7 .7 .7 .7 . ": I .7 .7 .7 .7 .7 .7 "7 "7 "7 .7 .7 "7 "7 "7 .7 .7 .7 .7 .7 .7 "7 "7 "7 "7 .7 "7 "7 "7 "7 .7 "7 .7 .7 .7 . ": J .7 .7 .7 .7 .7 .7 "7 "7 "7 .7 .7 "7 "7 "7 .7 .7 "7 "7 "7 .7 .7 "7 "7 "7 .7 .7 "7 "7 "7 .7 .7 .7 .7 .7 . ": " 56 También al utilizar la opción manual para la introducción de vectores estos deben escribirse con una sintaxis muy sencilla. Los elementos del vector de prueba deben estar separados por una coma y no se deben utilizar espacios. Cada vector, ya sea de entrada o salida debe escribirse en el espacio adecuado. Figura 9. Ventana para la introducción de vectores de prueba. 57 4.3 Algoritmo para el control de convergencia La estación experimental cuenta con un algoritmo para controlar la convergencia de las redes neuronales con las que se esta experimentando. Los principales problemas que resuelve es evitar que las redes oscilen continuamente en zonas cercanas a un mínimo local y también evita que la red entre a zonas donde el error cuadrático de todos los puntos vecinos es muy similar. En el primer caso puede causar que el número de iteraciones necesarias para cumplir con un error máximo sea infinito debido a que la red oscila sobre una misma zona. En el segundo caso la red se estabiliza y el error cuadrático no cambia notoriamente con cada iteración. Esto produce que el número de iteraciones necesarias para lograr el error permitido aumente drásticamente. Las primeras dos evaluaciones del algoritmo son muy sencillas y son comparaciones simples. Para estas comparaciones el usuario debe introducir dos parámetros: 1. Error mínimo. Es el error mínimo tolerable por el usuario; la estación tiene como valor predefinido 1 × 10 −9 que en muchas aplicaciones es un error relativamente bajo. El parámetro es de tipo decimal y debe ser mayor a cero. 2. Número máximo de iteraciones. Cada iteración consiste en aplicar el algoritmo de propagación del error hacia atrás para cada vector de prueba que el usuario haya introducido. La estación tiene como valor predefinido un millón iteraciones. El parámetro debe ser de tipo entero y ser mayor a cero. 58 ! " " # Figura 10. Diagrama de flujo del algoritmo para el control de convergencia. 59 El algoritmo que se implementó para detectar si la red osciló sobre un mínimo local utiliza para su funcionamiento la primera derivada del error cuadrático y varios parámetros introducidos por el usuario. La primera derivada se utiliza para determinar si la red se encuentra en un mínimo local en su curva de aprendizaje. Los parámetros que el usuario debe proporcionar son: 1. Porcentaje de diferencia entre mínimos. Este es un valor porcentual. Es utilizado por el algoritmo para comparar dos mínimos locales consecutivos de la curva de aprendizaje y determinar si se debe considerar como el mismo punto. La curva de aprendizaje desplegada a continuación muestra dos mínimos locales consecutivos; considerando que el porcentaje de diferencia entre mínimos en este caso es del 20%, se considera que la red esta oscilando sobre el mismo punto. Curva de aprendizaje 1.8 1.6 1.4 Error 1.2 1 0.8 0.6 0.4 0.2 0 0 2 4 6 8 10 12 Iteraciones (miles) Curva de aprendizaje Figura 11. Red neuronal oscilando sobre un mismo mínimo local. 14 60 2. Porcentaje de golpe al valor alfa. Este valor representa el aumento que el algoritmo aplica al valor alfa de la red neuronal durante una iteración para intentar que la red neuronal salga de la zona de oscilación. 3. Máximo número de oscilaciones consecutivas sobre un mínimo local. Este es un valor entero positivo y representa la máxima cantidad de veces que una red puede oscilar sobre un mismo punto sin ser desechada por el algoritmo. La figura mostrada a continuación muestra una red oscilando sobre un mismo punto; tomando en cuenta que en este caso el máximo número de oscilaciones es igual a 5, el algoritmo desecharía la red. Curva de aprendizaje 3 2.5 Error 2 1.5 1 0.5 0 0 5 10 15 20 25 30 35 40 45 Iteraciones (miles) Curva de aprendizaje Figura 12. Red neuronal oscilando mantenidamente sobre un mismo mínimo local. 61 $ # % ! Figura 13. Diagrama de flujo del algoritmo para evitar que la red oscile. 62 El siguiente algoritmo perteneciente al control de convergencia detecta e intenta evitar que la red neuronal se estabilice en alguna zona donde todos los puntos vecinos contengan un error cuadrático muy similar. La primera derivada se utiliza para determinar si los cambios en el aprendizaje de la red son muy leves. Primera derivada del error cuadrático 1.4 1.2 E' 1 0.8 0.6 0.4 0.2 0 0 2 4 6 8 10 12 14 16 18 Iteraciones Figura 14. Primera derivada del error cuadrático de una red neuronal estabilizándose en una zona. 63 Funcionalmente este algoritmo es muy similar al anterior y por ello los parámetros son semejantes. Los parámetros que el algoritmo requiere son: 1. Porcentaje mínimo de cambio de pendiente. Este valor le indica a la estación experimental cuando debe considerar que los cambios en el error cuadrático entre iteraciones son irrelevantes. 2. Máximo número de iteraciones sin cambio relevante en la pendiente. Este valor, entero positivo, indica el máximo número de pendientes consecutivas sin cambio relevante tolerable por el usuario. Comparando con este valor la estación decide cuando aplicar un golpe al valor alfa durante la etapa de aprendizaje. La figura desplegada en la página anterior muestra la primera derivada de una red neuronal artificial a la cual se le aplicó un golpe al valor alfa en la decimaquinta iteración. Este golpe se aplicó debido a que la red no mostró cambios significativos en el error cuadrático durante las últimas seis iteraciones antes del golpe. 64 # & # Figura 15. Diagrama de flujo del algoritmo para evitar que la red se estabilice. 65 4.4 Graficación de las curvas de aprendizaje y de las neuronas La interfaz gráfica de la estación experimental también hace uso de archivos para generar curvas de aprendizaje y graficar neuronas. Para la graficación de las curvas de aprendizaje la estación escribe archivos con información relevante para el usuario. Para ello se agrega en el ciclo de aprendizaje principal un grupo de instrucciones que evalúa si existe algún punto en donde haya un cambio de signo en la pendiente de la curva de aprendizaje. Al encontrar este punto se escribe en el archivo el par ordenado: número de iteración y error. El siguiente texto muestra un archivo de salida mostrando el aprendizaje de una red. Con esto se logra graficar los puntos importantes en la curva de aprendizaje y los archivos de salida contienen pocas líneas ahorrando recursos del sistema. . ..GF ..GH ?JEJ D?G. F??D FFGI FFH" FJDH FJDJ ??DD? ": ""HHJ?G. ": ""GDDDIH ": ""GE?DFF ": ""GE?IGF ": ""GDF"DH ": ""GEDHFI ": ""GDGEHI ": ""GEDIHD ": ""GDGGD. ": ""GEDJGD H: .DH"I ("I Luego este archivo, a solicitud del usuario presionando un botón, es graficado utilizando GNUPLOT. El tipo de gráfico y las propiedades del mismo se definen en un archivo de configuración encontrada en el fólder graficos y de extensión .conf. 66 Figura 16. Curva de aprendizaje de una red neuronal. De manera similar la estación experimental grafica las neuronas a petición del usuario. Cuando se solicita el gráfico de una neurona, la estación lee todos los valores de los pesos correspondientes a cada entrada de la neurona y los divide hasta en diez distintos grupos. El criterio para la división en grupos de los pesos radica en su valor numérico, y para cada grupo corresponde un grosor de línea específico en la grafica de la neurona. Por último, se escribe un archivo de configuración, que contiene la información de la neurona, para que GNUPLOT realice correctamente la gráfica. 67 CAPÍTULO 5: Análisis de resultados 5.1 Reconocimiento de patrones de texto. En muchas aplicaciones de uso cotidiano las redes neuronales artificiales son utilizadas para la solución de problemas de reconocimiento de patrones de texto o de audio. Probablemente este sea el problema que mas comúnmente resuelven las redes neuronales artificiales. En este apartado se analizará la capacidad de distintas redes neuronales de resolver el problema de reconocimiento de dígitos. Se variarán distintos parámetros de las redes para estudiar el comportamiento de la etapa de aprendizaje en cada caso. Todas las redes neuronales contarán con treinta y cinco entradas y una única salida. Las treinta y cinco entradas corresponden a las celdas de una matriz de cinco columnas y siete filas. Comúnmente la dimensión de esta matriz es utilizada para desplegar dígitos en pantallas de radios, microondas o sistemas similares. 5.2 Vectores de prueba. Para la etapa de aprendizaje se utilizarán diez vectores de prueba. Estos corresponden a los diez dígitos del sistema decimal. Las entradas de estos vectores de prueba contendrán únicamente dos valores posibles: cero o uno. El cero corresponde a una casilla totalmente blanca mientras que el uno corresponde a una casilla totalmente negra. Estos vectores contienen entradas que son redundantes debido a que su valor se mantiene constante en la mayoría de los diez vectores. 68 Valor de la entrada Cuadro 5.1 Vectores de prueba para reconocimiento de dígitos. #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 #13 #14 #15 #16 #17 #18 #19 #20 #21 #22 #23 #24 #25 #26 #27 #28 #29 #30 #31 #32 #33 #34 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 2 0 1 1 1 1 0 0 0 0 1 0 0 0 0 1 0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 1 1 1 1 3 1 1 1 1 1 0 0 0 0 1 0 0 0 0 1 0 1 1 1 1 0 0 0 0 1 0 0 0 0 1 1 1 1 1 1 4 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 0 1 1 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 Dígito 5 6 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 7 1 1 1 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 8 0 1 1 1 1 0 1 0 0 1 0 1 0 0 1 0 1 1 1 1 0 1 0 0 1 0 1 0 0 1 0 1 1 1 1 9 1 1 1 1 1 1 0 0 0 1 1 0 0 0 1 1 1 1 1 1 0 0 0 0 1 0 0 0 0 1 0 1 1 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 1 1 1 1 69 Figura 17. Representación gráfica de los vectores de prueba. Luego de la etapa de aprendizaje se evaluará el desempeño de las distintas redes a estímulos controlados. En este caso los valores no serán únicamente cero y uno sino que pueden tomar cualquier valor entre este intervalo. Cada valor estará asociado a un tono de gris tal y como lo hace una imagen en escala de grises en nuestro computador. Figura 18. Patrones de dígitos utilizados para la verificación del aprendizaje de las redes neuronales. 70 5.3 Análisis de los distintos casos. 5.3.1 Descripción de los distintos casos. En cada caso de estudio se modifica algún un parámetro o característica de la red neuronal para observar el cambio que produce en el comportamiento de la etapa de aprendizaje. Luego de la etapa de aprendizaje se evalúa el segundo conjunto de vectores y se observa la respuesta de la red. Debido a la naturaleza de este problema la salida de la red esta limitada a diez posibles respuestas, por lo que las salidas que se obtengan de la red se redondearán al valor de la respuesta posible más próxima. Opciones Cuadro 5.2 Características de cada caso de estudio. #1 #2 Casos #3 Aplicación de los algoritmos de convergencia Si Si Si No Si Aplicación de pesos aleatorios Si Si No Si Si Aplicación de aproximación por regresión lineal No Si No No No No No No No Si 100k 100k 10k 100k 100k Generación de redes variando el número de capas ocultas Número de iteraciones #4 #5 71 En todos los casos se mantuvieron constantes los parámetros de los algoritmos de convergencia, excepto por el número de iteraciones. Cuadro 5.3 Parámetros del algoritmo de convergencia utilizados en todos los casos. 5.3.2 Parámetro Valor Error mínimo 1x10 −8 Porcentaje de cambio de pendiente mínimo 0.001% Número máximo de pendientes dentro del rango 10 Porcentaje golpe alfa 1000% Porcentaje de diferencia entre mínimos consecutivos 0.5% Número máximo oscilaciones sobre un mínimo local 500 Caso #1. Este primer caso es el punto de partida para el análisis de las distintas redes su respuesta a la variación de los algoritmos aplicados. Este es caso donde se aplican todos los parámetros recomendados por la estación experimental. Luego de la etapa de aprendizaje y de la aplicación de los vectores de comprobación se observó que las topologías perceptrón multinivel reducido y lazo no lograron resolver el problema propuesto. En ambos casos las redes llegaron al número máximo de oscilaciones sin alcanzar el error esperado. Estas dos redes son de la misma topología debido al número 72 de salidas de la red. La única variación que existe es el valor inicial de los pesos de todas las conexiones. Esto provoca que exista una diferencia al inicio de la etapa de aprendizaje, sin embargo luego de la completar mas de cincuenta mil iteraciones ambas redes muestran un comportamiento similar. Iteraciones 0 20000 40000 60000 80000 100000 120000 0.1 0.01 Error 0.001 0.0001 0.00001 0.000001 0.0000001 0.00000001 Perceptron Reducido Lazo Figura 19. Curva de aprendizaje de las redes lazo y perceptrón reducido del caso #1. Las restantes tres redes neuronales lograron converger antes de alcanzar el número máximo de oscilaciones. Estas tres topologías contienen alrededor del doble de neuronas que las topologías que no lograron converger. Se observa que el comportamiento de las redes durante la etapa de aprendizaje es muy similar y las tres convergen aproximadamente en el mismo número de iteraciones. 73 Cuadro 5.4 Comparación del desempeño de las redes neuronales del caso #1. Número de Error Número de neuronas alcanzado iteraciones Diamante doble 106 9.9 x10 8 66641 Diamante mínimo 72 1x10 −8 62579 Perceptrón multinivel 71 9.9 x10 8 65451 Topología Es notorio que la red diamante doble no es eficiente puesto que conteniendo alrededor de un 30% más de neuronas que sus competidoras no converge mas rápidamente que las demás. También este gran número de neuronas aumenta el tiempo de procesamiento y ligeramente el uso de la memoria del sistema. En este caso particular se considera que la red diamante mínimo es la más eficiente. Al estudiar los pesos de las cinco distintas redes es claro que los estímulos redundantes no son tomados en cuenta en la decisión final de la red. Los valores de los pesos correspondientes a estas entradas fueron igual a cero en todos los casos. 5.3.3 Caso #2. En este segundo caso se evalúa, previo a la etapa de aprendizaje, la linealidad de cada entrada con cada salida. Al igual que en caso anterior las redes con topología lazo y perceptrón reducido no lograron resolver el problema y además mostraron problemas de oscilación sobre mínimos locales en las primeras quince mil iteraciones. 74 Iteraciones 0 5000 10000 15000 0.0065 0.00648 0.00646 0.00644 Error 0.00642 0.0064 0.00638 0.00636 0.00634 0.00632 0.0063 Lazo Perceptron reducido Figura 20. Oscilación sobre un mínimo local del caso #2. Claramente se observa en la gráfica la oscilación de estas redes sobre un mínimo local. En este caso el algoritmo de detección de oscilación evitó que la red continuara oscilando. Luego de salir de la zona de oscilación, estas redes disminuyeron considerablemente su error hasta llegar al límite máximo de iteraciones. 75 Iteraciones 0 20000 40000 60000 80000 100000 0.01 Error 0.001 0.0001 0.00001 0.000001 Diamante doble Diamante mínimo Perceptron multinivel Perceptron reducido Lazo Figura 21. Curva de aprendizaje de todas las redes lazo del caso #2. Las restantes tres redes muestran comportamientos muy similares entre sí. En estas tres redes es posible observar pequeñas oscilaciones sobre mínimos locales. Finalmente la única ventaja que se observa al aplicar el algoritmo de regresión lineal es que el error cuadrático en todas las redes durante las primeras cien iteraciones es menor que cuando no se aplica el algoritmo como en el caso #1. También es claro que las redes alcanzan mínimos locales más rápidamente que en el primer caso. Esto es útil en aplicaciones en donde antes de calcular el error cometido por la red, su salida sea forzada a 76 los únicos valores del conjunto de salidas. De este modo es posible que algún punto cercano a los mínimos locales rápidamente alcanzados sea suficiente para resolver el problema. 5.3.4 Caso #3. Este es un caso muy simple y lo que busca es evidenciar la necesidad de aplicar valores aleatorios a todos los pesos de las neuronas antes de iniciar la etapa de aprendizaje. Iteraciones 0 2000 4000 6000 8000 10000 12000 0.0095 0.009 0.0085 Error 0.008 0.0075 0.007 0.0065 0.006 0.0055 Diamante doble Diamante mínimo Lazo Perceptron multinivel Figura 22. Curva de aprendizaje de todas las redes lazo del caso #3. 77 El desempeño de las distintas redes neuronales en este caso es menor que en el caso #1 en donde si se aplicaron valores aleatorios a los pesos de todas las neuronas antes de iniciar el proceso de aprendizaje. El siguiente cuadro muestra el error obtenido por todas las redes finalizar diez mil iteraciones tanto en el caso #1 como en el caso actual. Cuadro 5.5 Comparación del error final de las redes del caso #1 y del caso #3. Lazo Error final Caso #3 0.006061 Error final Caso #1 0.003612 Diferencia porcentual 40.4% Diamante doble 0.006457 0.000104 98.4% Diamante mínimo 0.006251 0.004590 26.6% Perceptrón multinivel 0.006244 0.000191 96.9% Perceptrón reducido 0.006061 0.004603 24.1% Topología 5.3.5 Caso #4. Este caso evalúa la capacidad de los algoritmos de convergencia para el mejoramiento del desempeño de las distintas redes neuronales. A todas las redes se les aplican valores aleatorios a todos sus pesos y no se aplica el algoritmo de regresión lineal. Estas condiciones son idénticas al caso #1 salvo que durante la etapa de aprendizaje no se aplican los algoritmos de convergencia implementados. 78 Cuadro 5.6 Comparación del desempeño de las redes del caso #1 y del caso #4. Aplicación de algoritmos de Sin aplicación de algoritmos de convergencia convergencia Error obtenido Iteración Error obtenido Iteración Lazo 2.2 x10 −8 100000 1.38 x10 −7 100000 Perceptrón reducido 1.1x10 −8 100000 1.1x10 −7 100000 Diamante doble 9.9 x10−8 66641 1.04 x10 −4 100000 Diamante mínimo 1x10 −8 62579 2.03 x10 −5 100000 Perceptrón multinivel 9.9 x10−8 65451 1.93 x10 −5 100000 Queda claro que los algoritmos de convergencia son esencialmente útiles en este problema particular para lograr mejores resultados, durante la etapa de aprendizaje, de todas las redes neuronales artificiales utilizadas. En general durante el análisis del aprendizaje, de las redes sin aplicación de los algoritmos de convergencia, se observó que hay ciertas zonas donde el error disminuye muy levemente y las redes consumen algunos miles de iteraciones para salir de esa zona. También se observó que el perceptrón multinivel y la red con topología lazo oscilaron sobre un mínimo local hasta llegar al número máximo de oscilaciones permitido. En el resto de las redes hubo pequeñas oscilaciones que fueron superadas pero consumieron alrededor de mil iteraciones. 79 5.3.6 Caso #5. En este caso se utilizan las diferentes redes adicionales que varían el número de capas ocultas. Se utilizan los mismos parámetros del primer caso y se utiliza la topología diamante mínimo como base para la generación de las redes extra. Se escoge esta topología como base puesto que fue la que obtuvo el menor error de las redes clásicas del caso #1. Cuadro 5.7 Topologías generadas. Nombre Topología Perceptrón multinivel doble 35-36-36-1 Perceptrón multinivel triple 35-36-36-36-1 Diamante triple 35-36-37-36-1 Perceptrón cuádruple 35-36-36-36-36-1 Perceptrón cuádruple ampliado 35-36-37-37-36-1 Penta perceptrón 35-36-36-36-36-36-1 Penta diamante 35-36-37-38-37+36-1 Ninguna de estas redes logró resolver el problema propuesto. Todas mostraron comportamientos con tendencia a converger. En general ninguna red osciló ni entró a zonas de estabilización. Sin embargo esta tendencia a disminuir el error fue muy lenta y alcanzaron el número máximo de iteraciones sin cumplir el error tolerable. Este comportamiento se puede deber al gran número de capas que contienen estas redes debido a que el error se va propagando lentamente por todas las neuronas. 80 CAPÍTULO 6: Conclusiones y recomendaciones 6.1 • Conclusiones Los algoritmos programados para el control de la convergencia demostraron, en el caso del reconocimiento de patrones de texto, disminuir considerablemente el tiempo requerido para lograr el aprendizaje de las redes neuronales artificiales. • Es evidente que el aplicar valores aleatorios a los pesos de todas las redes antes de iniciar su etapa de aprendizaje reduce el número de iteraciones necesarias para resolver un problema y también logra que las redes se ubiquen en algún mínimo local más rápidamente que si todos los valores iniciaran en cero. • La aproximación de la función de sigmoidal a la recta de mejor ajuste, obtenida mediante la aplicación de una regresión lineal, logra que las redes obtengan un error levemente más pequeño durante las primeras iteraciones. También es notable que al utilizar el método las redes convergen a un mínimo local en un número menor de iteraciones. Sin embargo al aumentar el número de iteraciones a órdenes superiores a las diez mil iteraciones el error cuadrático final no muestra un cambio significativo con la utilización del método. • Se logró comprobar que existen diferencias sustanciales en el aprendizaje de las redes de diferentes topologías. En el caso estudiado las redes de topología lazo y perceptrón multinivel reducido no logran resolver el problema propuesto. Estas redes contienen relativamente pocas neuronas lo que influye en su capacidad de aprendizaje. 81 • La familia de las topologías diamante, de una única capa oculta, muestran una mayor capacidad de resolver el problema propuesto. En la mayoría de los casos expuestos lograron resolver el problema y superar a las restantes topologías de una capa oculta. • El conjunto de redes que utilizan varias capas ocultas muestran un aprendizaje lento pero con una tendencia clara a disminuir el error en cada iteración. Analizando las curvas de aprendizaje no se observan oscilaciones sobre mínimos locales ni zonas de estabilización. Esto indica que estas topologías son capaces de resolver problemas mucho más complejos que el problema propuesto. • El consumo de tiempo de procesamiento durante la etapa de aprendizaje en el caso de las redes con varias capas ocultas es mucho mayor al consumo que se dio con las redes que solo contenían una sola capa oculta. Esto es una consecuencia directa del gran número de neuronas que contienen estas redes. • Todas las redes neuronales del ejemplo propuesto eliminaron la influencia de las entradas redundantes del problema dado. Es lógico que estas entradas estén asociados a una conexión con peso igual a cero puesto que el contenido de información medio es nulo. • Es muy útil detectar esta irrelevancia puesto que se puede variar levemente una topología eliminando las neuronas que no aportan información a la decisión final de la red. Al eliminar estas neuronas se esta liberando recursos de memoria y se disminuye el número de operaciones necesarias por cada iteración de la etapa de aprendizaje. 82 • También se logró comprobar que las conexiones que contienen los pesos de mayor valor absoluto están ligadas a las entradas que contienen un mayor contenido de información medio. • La estación experimental de redes neuronales logra cumplir con su objetivo fundamental que es crear una aplicación en donde el usuario pueda probar diferentes topologías y basado en su comportamiento y desempeño logre escoger la que más convenga en cada caso específico. • Las herramientas de la estación experimental para graficar la curva de aprendizaje de cada red y la herramienta que muestra la información detallada de cada neurona son útiles para estudiar el desempeño de la red durante la etapa de aprendizaje y también son útiles para identificar neuronas y entradas redundantes que pueden ser eliminadas. 6.2 • Recomendaciones Se recomienda implementar un algoritmo que detecte y elimine las neuronas que no aportan información relevante a la respuesta final de la red. Tal y como se observó en el problema propuesto la salida de algunas neuronas es una constante y por lo tanto pueden ser eliminadas. Esto liberará recursos de memoria y evitará realizar múltiples operaciones en punto flotante relacionadas con la ejecución del algoritmo de propagación del error hacia atrás en estas neuronas. 83 • Al igual que lo realizan muchos dispositivos electrónicos en la actualidad, se recomienda implementar un método que reduzca las salidas de las redes neuronales a un conjunto limitado de valores posibles determinado por el usuario. Un ejemplo de esta reducción del conjunto de salida son las aplicaciones diseñadas para el reconocimiento de voz en donde solo existe un conjunto limitado de respuestas posibles determinadas por el usuario. • La estación experimental actual no varía continuamente el parámetro alfa durante la etapa de aprendizaje de las redes. Es recomendable diseñar un algoritmo que tomando en cuenta la primera derivada del error cuadrático determine si es apropiado aumentar o disminuir este parámetro. Esto es muy útil cuando se utilizan redes con varias capas ocultas, puesto que su aprendizaje como se observó tiene una fuerte tendencia a converger pero lo hace de manera lenta. Aplicando una variación controlada y supervisada por el mismo algoritmo, puede ser posible que las redes converjan en un número menor de iteraciones. • Debido al amplio uso de recursos de procesamiento de la estación experimental, se recomienda implementar una función que estime el tiempo requerido para la etapa de aprendizaje de cada red. • También es recomendable incluir como variable opcional el tiempo máximo tolerable por el usuario para que una red logre un error dado. • La estación experimental hace uso de un hilo de procesamiento en paralelo para ejecutar ciertas funciones. Sin embargo es recomendable que se diseñe una función que 84 permita al usuario definir el número de hilos de procesamiento que se ejecutarán durante la etapa de aprendizaje de las redes. De este modo, fácilmente se podrán aprovechar al máximo los computadores que contienen múltiples procesadores. BIBLIOGRAFÍA 1. Arce, C. Castillo, W.E. Gonzalez, J. “Algebra lineal”, Universidad de Costa Rica, Costa Rica, 1998. 2. “Debian – The Universe Operating System”, http://www.debian.org/, Mayo, 2006. 3. Edwards, Jr. Penney, D.E. “Cálculo y geometría analítica”, segunda edición, Prentice Hall, México, 1987. 4. Freeman, J.A. Skapura, D.M. “Redes neuronales : algoritmos, aplicaciones y técnicas de programación”, Addison Wesley, Argentina, 1993. 5. Graubard, S.R. “El nuevo debate sobre la inteligencia artificial: sistemas simbólicos y redes neuronales”, segunda edición, Gedisa, Espana, 1999. 6. “GNU Project – Free Software Foundation (FSF)”, http://www.gnu.org/gnu/thegnuproject.html, Mayo, 2006. 7. Hilera Gonzalez, V.J. Martinez Hernando, V.J. “Redes neuronales artificiales: fundamentos, modelos y aplicaciones”, Alfaomega, Mexico, 2000. 8. Joyanes Aguilar, L. “Programación en C++, Algoritmos, estructuras de datos y objetos”, primera edición, McGraw Hill, España, 2000. 9. Kernighan, B. y Ritchie, D. “The C Programming Language”, segunda edición. Prentice Hall, Estados Unidos de América, 1988. 10. McCorduck, P. “Maquinas que piensan. Una incursión personal en la historia y las perspectivas de la inteligencia artificial”, Tecnos S.A, España, 1991. 86 11. Murray, C. “Programming with gtkmm”, http://www.gtkmm.org/docs/gtkmm-2.4/docs/tutorial/html/index.html, Marzo, 2006. 12. Pérez Fernández, I. “Cajal y la Neurona”, http://www.cienciateca.com/cajalylaneurona.html, Junio, 2006. 13. “Redes neuronales supervisadas y no supervisadas”, http://www.gc.ssr.upm.es/inves/neural/ann2/concepts/suunsupm.htm, Mayo, 2006. 14. Rojas, R. “Neural Networks – A Systematic Introduction”, Springer, Alemania, 1996. 15. Schilling, D. Belove, C. “Circuitos electronicos: Discretos y integrados”, Tercera edicion, McGraw Hill, España, 1993. 16. “Texas Instruments Graphing Calculators”, http://education.ti.com/educationportal/sites/US/productCategory/us_graphing.html, Mayo, 2006. 17. “The Linux Kernel Archives”, http://www.kernel.org, Mayo, 2006. 18. Wikipedia. “Kernel (Computer Science)”, http://en.wikipedia.org/wiki/Kernel_%28computer_science%29/, Junio, 2006. 19. Wikipedia. “Linux”, http://es.wikipedia.org/wiki/Linux, Mayo, 2006. 20. Wikipedia. “Red neuronal Artificial”, http://es.wikipedia.org/wiki/Red_neuronal_artificial, Mayo, 2006. ANEXOS Utilización de widgets Para la implementación de la interfaz gráfica se hizo un uso extensivo de las clases definidas en la librería GTKMM. Estas clases, orientadas exclusivamente a la creación de interfaces gráficas, se les llaman widgets. Los widgets más utilizados en la estación experimental fueron: • Gtk::Button Probablemente es el widget más ampliamente utilizado en todas las aplicaciones gráficas. Mediante su uso el usuario es capaz de ejecutar las diferentes funciones que contiene la estación experimental. Figura 23. Objeto Gtk::button. [11] El uso de este tipo de objetos implica indudablemente el uso de señales y conectores para ejecutar grupos de instrucciones cuando el usuario presiona el botón. Por lo general la definición de estas señales se realiza en el constructor de la ventana gráfica cuando también se modifican las propiedades del objeto. El código mostrado en la siguiente página muestra la definición en el encabezado de los objetos 88 Gtk::Button utilizados en la aplicación y luego muestra la modificación típica de parámetros y conectores del objeto realizados en el constructor de la ventana. 3%+/'3K/ 0 +>2* : B ' >L >L >L >L >L ' ' ' ' ' 7 8 7< 7 A7 7 7 A A M M M M M 4 < +0%,642+604 +>2* : +;; ' : @ : @ < < : @ : @ N + L N + L N : # ) @ - A 7C @ L 7N N N : # ) @ - A 7C @ L 7N < : @ : @ N > L : # ) @ - A 7C @ L 7N A : @ A : @ N > L : N # ) @ - A 7C @ L 7N N 4 N N A N El método “set_label” modifica el texto que despliega el widget y el método “signal_clicked” ejecuta a la función “on_click” y le envía una cadena de caracteres cada vez que el botón es presionado. • Gtk::Entry Este es un widget diseñado para que el usuario pueda introducir, mediante cadenas de caracteres, información al programa. Los métodos y propiedades de este objeto comúnmente no son utilizados ni modificados, únicamente se extrae el texto. 89 Figura 24. Objeto Gtk::Entry. [11] • Gtk::Checkbutton Al igual que el widget anterior está diseñado para que el usuario pueda introducir información al programa, sólo que en este caso se introduce información binaria definiendo algún estado de la aplicación. Figura 25. Objeto Gtk::Checkbutton. [11] Adicional al método para definir el texto, por lo general sólo se utilizan los métodos para leer y definir inicialmente el valor de la casilla. > L +A L' O : @ : @ • N ; N 6& Gtk::Label Probablemente es este el widget simple que se utiliza en la implementación de cualquier interfaz gráfica. Básicamente es un rótulo que muestra un texto definido 90 por el programador. La estación experimental no utiliza ningún método de este widget, salvo el de modificar el texto desplegado. Figura 26. Objeto Gtk::Label. [11] • Gtk::SpinButton. Este tipo de widgets esta diseñado para permitirle al usuario escoger un rango de datos, definidos por la aplicación. La estación experimental hace uso de estos widgets para mostrar información de las neuronas y entradas existentes, es por ello que es un grupo de datos limitado. Comúnmente son utilizados los métodos para definir el rango y el paso del widget. Figura 27. Objeto Gtk::Spinbutton. [11]