Diseño de una red neuronal oscilatoria digital con capacidad de aprendizaje on-line sobre FPGA

Trabajo Fin de Máster “Máster Universitario en Microelectrónica: Diseño y Aplicaciones de Sistemas Micro/Nanométricos” Diseño de una red neuronal oscilatoria digital con capacidad de aprendizaje on-line sobre FPGA Design of an oscillatory neural network with on-line Learning on an FPGA Autor / Author: Daniel Vázquez Díaz Tutor / Advisor: María José Avedillo de Juan Manuel Jiménez Través Juan Núñez Martínez Fecha / Date: Julio 2023 2 3 Agradecimientos Mis agradecimientos a María José Avedillo de Juan, Manuel Jiménez Través y Juan Núñez Martínez por la ayuda guía y apoyo brindado durante la realización de este trabajo fin de Máster. También agradecer a mi mujer y mis hijos por su paciencia y ánimos durante todo este tiempo para terminar este trabajo Fin de Master. 4 5 Resumen La inteligencia artificial es un concepto que cada vez está más integrado en nuestras vidas. Aunque no nos demos cuenta, esta nos rodea en nuestro día a día. Ejemplos de esto son los algoritmos que utilizan los buscadores de internet, los cuales permiten ofrecer una publicidad que se adaptada en función de la información recopilada durante las búsquedas o los algoritmos de reconocimiento de señales de tráfico que se están implementando en los vehículos actuales. En general, estos algoritmos de inteligencia artificial están implementados sobre plataformas basadas en CPU y/o GPU, que tienen la desventaja de su gran consumo de potencia, que los hace inviables en aplicaciones de bajo consumo. Una alternativa es la implementación en hardware de estas redes neuronales, con frecuencia usando dispositivos y paradigmas de computación no convencionales. Entre estas últimas, se están estudiando redes neuronales oscilatorias (ONNs) con potencial para una computación eficiente energéticamente. En este trabajo fin de master se ha desarrollado el estudio e implementación hardware de un algoritmo de aprendizaje iterativo supervisado para ONNs. Este trata de mejorar las prestaciones de los algoritmos de aprendizaje simples, como la regla de Hebb. El punto de partida para el desarrollo de este trabajo ha sido una descripción Verilog a nivel RTL, sintetizable y parametrizable de una ONN digital. Las principales tareas llevadas a cabo han sido: • Análisis del funcionamiento de la ONN digital mediante simulación del código proporcionado. • Desarrollo y validación del nuevo algoritmo utilizando lenguajes de alto nivel (MATLAB). • Diseño a nivel RTL y validación de una implementación hardware del algoritmo. Se ha generado una descripción Verilog sintetizable y parametrizable para este hardware. En el diseño se ha utilizado el entorno Vivado. • Desarrollo de un sistema para su demostración experimental. Este usa una placa de desarrollo Zybo-7. La ONN y los módulos hardware que realizan el aprendizaje online se implementan en la lógica programable del APSoC Zynq del que dispone dicha placa. En su procesador corre una aplicación que permite conectar su puerto serie con el diseño hardware. Una aplicación MATLAB envía ordenes de aprendizaje o de inferencia a la ONN desde un PC. El algoritmo desarrollado mejora las prestaciones de los algoritmos de aprendizaje simples, como la regla de Hebb y se ha demostrado la operación correcta del sistema experimental. Palabras clave: FPGA, Zynq, Vivado, Vitis, MATLAB, AXI, ONN, Aprendizaje supervisado. 6 7 Índice de Contenidos I. Índice de Figuras ................................................................................................................... 9 II. Índice de Tablas .................................................................................................................. 11 III. Glosario ............................................................................................................................... 13 1. Introducción ........................................................................................................................ 15 1.1. Objetivos y Metodología ............................................................................................. 15 1.2. Herramientas y recursos materiales ............................................................................. 16 1.3. Estructura de la Memoria ............................................................................................ 17 2. Fundamentos ....................................................................................................................... 19 2.1. Redes neuronales oscilatorias ...................................................................................... 19 2.2. Redes de Hopfield ....................................................................................................... 21 2.3. Métodos de aprendizaje ............................................................................................... 23 2.3.1. Algoritmo de aprendizaje Hebbian...................................................................... 23 2.3.2. Algoritmo de aprendizaje iterativo ...................................................................... 25 3. Análisis de la ONN digital .................................................................................................. 27 3.1. Descripción general ..................................................................................................... 27 3.1.1. Módulo “Neurons” .............................................................................................. 28 3.1.2. Módulo “Synapses” ............................................................................................. 31 3.1.3. Módulo de control ............................................................................................... 32 4. Diseño del Sistema .............................................................................................................. 35 4.1. Diseño del algoritmo de aprendizaje iterativo ............................................................. 35 4.1.1. Módulo TestMatrix ............................................................................................. 35 4.1.2. Módulo hebb_unsupervised ................................................................................ 35 4.1.3. Módulo LearnHebb ............................................................................................. 38 4.1.4. Módulo Aprendizaje Iterativo LearnIterative ...................................................... 39 4.2. Implementación en HW .............................................................................................. 42 4.2.1. Módulo mod_update_matrix ............................................................................... 42 4.2.2. Módulo mod_learn_hebb_iterative ..................................................................... 45 4.3. Integración del sistema ................................................................................................ 50 5. Implementación física ......................................................................................................... 55 5.1. Setup experimental ...................................................................................................... 55 5.2. Aplicación de test en MATLAB ................................................................................. 59 5.3. Pruebas con la versión 5x3 .......................................................................................... 60 5.3.1. Test 5x3 con 2 patrones ....................................................................................... 61 5.3.2. Test 5x3 con 3 patrones ....................................................................................... 64 5.4. Pruebas con versión 7x5 .............................................................................................. 69 5.4.1. Test 7x5 con 4 patrones ....................................................................................... 69 8 5.4.2. Test 7x5 con 5 patrones ....................................................................................... 78 5.4.3. Test 7x5 capacidad .............................................................................................. 79 5.5. Recursos ...................................................................................................................... 80 6. Conclusiones ....................................................................................................................... 83 7. Referencias .......................................................................................................................... 85 8. Anexos ................................................................................................................................. 87 8.1. Anexo I. Código MATLAB “hebb_unsupervised” ..................................................... 88 8.2. Anexo II. Código MATLAB “hebb_unsupervised_test1” .......................................... 89 8.3. Anexo III. Código MATLAB “LearnHebb” ............................................................... 92 8.4. Anexo IV. Código MATLAB “matrix_fig” ................................................................ 93 8.5. Anexo V. Código MATLAB “TestMatrix” ................................................................ 95 8.6. Anexo VI. Código MATLAB “LearnIterative” .......................................................... 97 9 I. Índice de Figuras Figura 1: Funcionamiento oscilador VO2 [14]. ............................................................................ 20 Figura 2: Modelo de Red Neuronal HNN (Hopfield Neural Network)....................................... 21 Figura 3: Red Neuronal de tres neuronas .................................................................................... 21 Figura 4: Red Neuronal de tres neuronas simplificada ............................................................... 22 Figura 5: Redes de Hopfield. Punto de mínima energía .............................................................. 23 Figura 6: Diagrama de bloques de la ONN Digital ..................................................................... 27 Figura 7: Conexión pesos sinápticos, aritmética y neuronas ....................................................... 28 Figura 8: Comportamiento de “neuron” con full_tick = 0 y full_tick = 1. .................................. 29 Figura 9: Operación de "neuron" con full_tick = 0 ..................................................................... 30 Figura 10: Alineamiento de Ninput con Noutput. ....................................................................... 30 Figura 11: Simulación Synapses ................................................................................................. 31 Figura 12: Bloques de control ONN Digital ............................................................................... 32 Figura 13: Simulación "serial2states" 1 ...................................................................................... 33 Figura 14: Simulación "serial2states" 2 ...................................................................................... 33 Figura 15: Representación número 0 sobre matriz de 5x3 píxeles. ............................................. 36 Figura 16: Representación número 2 sobre matriz de 5x3 .......................................................... 36 Figura 17: Diagrama Flujo aprendizaje iterativo ........................................................................ 40 Figura 18: Resultado aprendizaje iterativo .................................................................................. 41 Figura 19: Formato patrones de entrada ...................................................................................... 43 Figura 20: Testbench mod_update_matrix 1. .............................................................................. 43 Figura 21: Testbench mod_update_matrix 3 ............................................................................... 44 Figura 22: Fichero "output.txt" (NbitsWeights=5) ...................................................................... 44 Figura 23: Matriz de pesos obtenida en MATLAB. .................................................................... 45 Figura 24: Fichero "output.txt" (NbitsWeights=6) ...................................................................... 45 Figura 25: Setup test "mod_learn_hebb_iterative" ..................................................................... 47 Figura 26: Test "mod_learn_hebb_iterative" 1 ........................................................................... 47 Figura 27: Test "mod_learn_hebb_iterative" 2 ........................................................................... 47 Figura 28: Test "mod_learn_hebb_iterative" 3 ........................................................................... 48 Figura 29: Test "mod_learn_hebb_iterative" 4 ........................................................................... 48 Figura 30: Test "mod_learn_hebb_iterative" 5 ........................................................................... 49 Figura 31: Diagrama de bloques del sistema completo. .............................................................. 50 Figura 32: Codificación patrones de entrada en el testbench del sistema completo ................... 50 Figura 33: Diagrama flujo del testbench ..................................................................................... 51 Figura 34: Patrones de entrada en el testbench del sistema completo ......................................... 52 Figura 35: Simulación sistema completo 1 ................................................................................. 52 Figura 36: Simulación sistema completo 2 ................................................................................. 53 Figura 37: Simulación sistema completo 3 ................................................................................. 53 Figura 38: Recursos implementación ONN con capacidad de aprendizaje on-line con 15 neuronas. ..................................................................................................................................... 53 Figura 39: Tarjeta Zybo Z20 de Xilinx ....................................................................................... 55 Figura 40: Diagrama de bloques del setup experimental. ........................................................... 55 Figura 41: Diagrama de bloques de la plataforma hardware que se implementa en el FPGA. .. 56 Figura 42: Diagrama de bloques TOP_ONN .............................................................................. 57 Figura 43: Interconexión del Módulo Interface_ONN. ............................................................... 57 Figura 44: Aplicación Vitis de Xilinx ......................................................................................... 58 Figura 45: Patrones de entrenamiento 5x3 .................................................................................. 60 Figura 46: Resultado aprendizaje red ONN 5x3 ......................................................................... 60 Figura 47: Test 5x3 con 2 patrones ............................................................................................. 61 Figura 48: Resultado test 5x3 con 2 patrones.............................................................................. 61 16 1.2. Herramientas y recursos materiales MATLAB MATLAB [1] es un software de cómputo numérico con un entorno gráfico y un lenguaje propio (lenguaje M). MATLAB permite implementar de manera sencilla y rápida algoritmos y poder validarlos. También proporciona herramientas que permiten visualizar gráficamente los resultados obtenidos. En este proyecto se ha utilizado MATLAB para la evaluación del modelo de aprendizaje, antes de implementarlo en HW y en la demostración experimental. Vivado Vivado [2] es el entorno de desarrollo del fabricante de FPGAs Xilinx. Este permite la síntesis, simulación, implementación y análisis de sistemas digitales. En este trabajo se ha utilizado Vivado en el análisis de la ONN digital y en el diseño, simulación y síntesis de la implementación hardware del algoritmo de aprendizaje. Vitis Vitis [3] es el entorno de desarrollo software de Xilinx que se utiliza para la implementación de aplicaciones que corren en los procesadores disponibles en los dispositivos como FPGAs y APSoC de Xilinx. En este proyecto se ha utilizado Vitis para la implementación de un software que permite leer e interpretar los comandos recibidos a través del puerto serie de la plataforma Hardware utilizada durante la demostración. Tarjeta Zybo. La placa de desarrollo Zybo Z7 [4] [5]es una tarjeta que dispone de una FPGA Zynq-7020 de Xilinx. Las características principales de esta tarjeta son: • Dispone de un dispositivo ZynqXC7Z020-1CLG400C • 1 GB de DDR3L. • Puertos USBs, Ethernet, video y audio. • Conectores PMOD para usar módulos externos dedicados, leds y switches. El dispositivo Zynq es un System On Chip (SoC) que está formado por un procesador Cortex A9 dual core embebido (PS) y una sección lógica programable (PL). Esta arquitectura permite explotar las ventajas de tener en un mismo dispositivo un procesador y la flexibilidad de la lógica programable. La intercomunicación entre ambas partes, PS y PL, a través del bus específico como el AXI (Advanced eXtensible Interface) hacen de la Zynq un dispositivo idóneo para este tipo de implementaciones. 17 1.3. Estructura de la Memoria La memoria se estructura de la siguiente manera: • En el capítulo 2 se introducen los fundamentos en los que se basa el concepto de las redes neuronales oscilatorias como son los osciladores y las redes de Hopfield. • En el capítulo 3 se explica el funcionamiento de la ONN digital a la que se dota de capacidad de aprendizaje on-line. También se exponen los algoritmos de aprendizaje Hebbian y Hebbian iterativo. • En el capítulo 4 se describe el proceso de implementación del algoritmo de aprendizaje supervisado completo, desde su desarrollo previo en MATLAB, hasta la simulación de su descripción Verilog. • En el capítulo 5 se dedica a la validación experimental de la ONN con capacidad de aprendizaje on-line. Se describe el sistema desarrollado sobre la plataforma hardware Zybo Z7 basada en la FPGA Zynq-7020 de Xilinx y la aplicación MATLAB con la que se controla y se ilustra su operación. • En el capítulo 6 se exponen las conclusiones obtenidas durante la elaboración de este TFM. • La memoria finaliza con la sección de bibliografía y los anexos donde se incluyen los códigos y scripts que han sido desarrollados. 18 19 2. Fundamentos Las ONN (Oscillatory Neural Network o Redes Neuronales Oscilatorias) son redes neuronales analógicas formadas por elementos oscilatorios acoplados entre sí [6], [7], [8], [9]. El acoplamiento entre los osciladores se realiza mediante elementos resistivos o capacitivos y el conjunto de los valores de estos elementos acopladores son lo que proporcionan la capacidad a la red neuronal de almacenar patrones [10]. En esta sección se introduce brevemente los osciladores y las redes de Hopfield, que son los conceptos en los que se basa el funcionamiento de las ONN. Finalmente, se explican los algoritmos de aprendizaje de Hebbian y el método de aprendizaje iterativo. 2.1. Redes neuronales oscilatorias El elemento básico de las redes neuronales ONN son los osciladores. Estos elementos permiten generar señales repetitivas periódicas. Existen diversas formas de implementar un oscilador, entre las que se encuentran las siguientes: • Microelectromecánicos (MEMS). • Spin-Torque Oscillators (STO). • Osciladores basados en PLL (Phased Locked Loops). • Osciladores de anillo (RO). • Empleando Materiales de Transición de Fase (Phase Transition Materials, PTM). En NeurONN se utiliza el dióxido de vanadio (VO2), un material que exhibe transiciones de fase, para implementar un oscilador muy compacto. Oscilador basado en VO2 La topología más básica de este tipo de oscilador se muestra en la Figura 1(b) [11], [12], [13]. Está formado por un elemento principal, que es el dióxido de vanadio (VO2), una resistencia y un condensador. El VO2 es un material de cambio de fase que posee dos zonas o fases de trabajo, una fase aislante o de alta resistencia y una fase metálica o de baja resistencia. La Figura 1(a) muestra su característica I-V. En estado de reposo, en ausencia de estímulo externo, permanece en fase aislante. Al someterse el VO2 a una diferencia de tensión, la corriente que circula a través de este aumenta, haciendo que se produzca la transición de aislante a metal (IMT por sus siglas en inglés). En el estado metálico, al reducir la tensión del VO2, se disminuye la corriente. Cuando cae por debajo de 𝐽𝐶−𝑀𝐼𝑇 se produce una transición del estado metálico al estado aislante (MIT). El funcionamiento de los osciladores basados en VO2 consiste en utilizar este cambio de fase para generar una señal oscilatoria. En la Figura 1(c) se ilustra su operación. Con el VO2 en metálico, la capacidad de salida se carga (punto B en la forma de onda del oscilador). Esto reduce la tensión que cae en el VO2 hasta que alcanza VMIT y se produce la transición al estado aislante. En este estado, la capacidad se descarga por la resistencia (punto A), incrementando la tensión en el VO2. Cuando esta alcanza VIMT se produce la transición a metálico y el proceso se repite. 20 Figura 1: Funcionamiento oscilador VO2 [14]. Funcionamiento de las ONN Las ONN son redes neuronales oscilatorias, formadas por osciladores acoplados entre sí mediante resistencias y/o condensadores que representan los pesos sinápticos de las redes neuronales. Cuando dos osciladores de frecuencias similares se acoplan capacitivamente, se sincronizan y se bloquean en anti-fase. Si se acoplan resistivamente, se sincronizan en fase. En una ONN, una vez que se produce la sincronización, se tiene una determinada relación de fases entre los distintos osciladores que la componen que constituye el estado de la ONN. Esto es, en una ONN la información se codifica en la fase de señales oscilatorias. La relación de fase inicial, que se corresponde con el patrón de entrada de la red, se controla retrasando adecuadamente el encendido (activación de la polarización) de unos osciladores respecto a otros. Si se utiliza el ejemplo más simple, que consiste en una entrada binaria, el 0 estaría representado con una inicialización del oscilador en el instante T0 y el 1 estaría representado por una señal aplicada en el instante T0 + T_OSC/2, siendo T_OSC el periodo de oscilación. Los acoplamientos se eligen de forma que se mapea la solución del problema que se quiere resolver con la red a la función de energía de dicho sistema dinámico. En consecuencia, a medida que el sistema evoluciona para minimizar su energía, naturalmente calculará la solución del problema. La manifestación y eficacia de este enfoque es evidente en el mundo físico; El procesamiento de la información en tiempo real se observa en los sistemas dinámicos naturales, como los patrones de activación de los circuitos neuronales o los mecanismos de señalización celular. Así, el sistema físico “computa” con su propia dinámica de forma paralela colectiva y, por tanto, con tiempos de cómputo competitivos, lo que también se traduce en un menor consumo de energía. 21 2.2. Redes de Hopfield Las redes neuronales de Hopfield o HNN por sus siglas en inglés (Hopfield Neural Networks) son un tipo de redes neuronales recurrente en las que cada neurona están conectadas entre sí mediante unos pesos 𝑊𝑖𝑗. Estos pesos indican la fuerza de conexión que hay entre las diferentes neuronas y los subíndices indican entre que dos neuronas se aplica tal peso, es decir, entre la neurona 𝑖 y la 𝑗. Este tipo de redes se han utilizado como memorias asociativas (AM) y para tareas de reconocimiento de patrones. La Figura 2 representa una red neuronal de Hopfield [15]. Cada neurona es representada por 𝑛𝑖 y los pesos entre ellas se representan por 𝑊𝑖𝑗. Con frecuencia se utilizan matrices de pesos simétricas (𝑊𝑖𝑗= 𝑊𝑗𝑖) y con diagonal nula (𝑊𝑖𝑗=0 ⩝𝑖=𝑗). La Figura 3 representa una HNN de tres neuronas con estas restricciones de forma que se enfatiza su naturaleza recurrente. Figura 2: Modelo de Red Neuronal HNN (Hopfield Neural Network) Figura 3: Red Neuronal de tres neuronas 22 Una representación simplificada y más próxima a las ONNs en las que las interacciones son bidireccionales se muestra en la Figura 4. Figura 4: Red Neuronal de tres neuronas simplificada En una red de Hopfield discreta, el estado de cada neurona se representa mediante 𝑆𝑖 y este toma valores bipolares {-1, +1}. La actualización del valor 𝑆𝑖 correspondiente a cada neurona se realiza de acuerdo con: 𝑆i=+1 Si ∑𝑊𝑖𝑗𝑆𝑗 𝑗≠𝑖 >𝑈𝑖 Si=−1 Si ∑𝑊𝑖𝑗𝑆𝑗 𝑗≠𝑖 <𝑈𝑖 Donde 𝑈𝑖 es un valor umbral para cada una de las neuronas. En el caso más simple, este umbral es el mismo para todas las neuronas y se establece en 0. Por tanto, se puede resumir que la ecuación para actualizar el estado de cada neurona es: 𝑆𝑖=𝑆𝑖𝑔𝑛 (∑𝑊𝑖𝑗𝑆𝑗 𝑗) Los pesos determinan cuáles son los estados estables de la red (puntos fijos de la expresión anterior de cada una de las neuronas). Los estados estables se corresponden con estados de mínima energía [15]: 𝐸= −12∑∑𝑊𝑖𝑗𝑆𝑖𝑆𝑗 𝑗𝑖 La HNN se comporta como una memoria asociativa si los pesos se fijan de forma que los patrones que se quieren guardar o almacenar se correspondan con estados estables de la misma. Se denomina aprendizaje o entrenamiento a la determinación de dichos pesos. Cuando se aplica un patrón a la entrada de la red neuronal, esta converge al estado almacenado más cercano, ya que tiende a estabilizarse en un punto de mínima energía. Si imaginamos una superficie curva con diferentes puntos de mínima energía, representados por 𝑋1, 𝑋2 y 𝑋3 en la Figura 5, estos puntos representan los patrones almacenados por la red neuronal. El patrón de entrada está representado por la bola verde y esta tendería al punto de mínima energía más próximo, en este caso 𝑋1 23 Figura 5: Redes de Hopfield. Punto de mínima energía La AM puede aplicarse al reconocimiento de patrones almacenando los patrones que se quieren reconocer en la AM. Al aplicar una versión distorsionada de estos se recupera el más parecido. 2.3. Métodos de aprendizaje 2.3.1. Algoritmo de aprendizaje Hebbian La regla de aprendizaje de Hebbian es uno de los algoritmos más conocidos para el cálculo de los pesos sinápticos en redes neuronales bipolares. Este fue propuesto por el neuropsicólogo Donald O. Hebb, quien postuló la forma en la que aprenden las neuronas [16]: Cuando el axón de una célula A esta lo suficientemente cerca como para excitar a otra célula B y repetida o persistentemente toma parte en su activación, se produce un proceso o cambio metabólico en una o ambas células de tal manera que tanto eficiencia de A, como la de las células que activan a la célula B, se incrementan. Esto quiere decir que, los pesos sinápticos o la conexión entre las neuronas se ven fortalecidas como respuesta a la experiencia, mientras que, en el caso contrario, los pesos sinápticos o la conexión se ve debilitada. Esta regla permite entrenar una red HNN para guardar un determinado conjunto de patrones. Estos patrones se denominan patrones de entrenamiento. En este caso su significado es que, si las neuronas se activan juntas, la fuerza de su acoplamiento mutuo aumentará, mientras que de lo contrario la conexión será más débil. Este tipo de algoritmo de aprendizaje es sin supervisión, lo que quiere decir que solo depende de los patrones de entrenamiento. Una de las limitaciones de este algoritmo es que es inestable, debido a que los pesos tienden a crecer sin límite, lo que da lleva a la saturación y por tanto da lugar la pérdida de su utilidad Así, para un conjunto de P patrones de longitud N, 𝜉𝐾 𝜖{−1,+1}𝑁 que se desea almacenar en una HNN, la fuerza de acoplamiento entre las neuronas (peso) se determina mediante la siguiente ecuación: 𝑊𝑖𝑗= ∑𝜉𝑖𝐾𝜉𝑗𝐾 𝑃 𝐾=1 Donde: • 𝑊𝑖𝑗 = 0 ⩝ i = j • N es el número de neuronas de la red neuronal • 𝜉𝑖𝐾 representa el estado de la neurona 𝑖 en el patrón 𝐾. La capacidad que ofrece este tipo de algoritmo viene determinada por la siguiente ecuación [17]: 𝐶𝑎𝑏𝑠=𝑁 2ln(𝑁)′ 24 La regla de Hebb admite una formulación incremental: 𝑊𝑖𝑗(𝑛+1)=𝑊𝑖𝑗(𝑛)+𝛥𝑊𝑖𝑗 Donde el incremento viene definido por la siguiente ecuación: 𝛥𝑊𝑖𝑗= 𝛼𝑥𝑖∗𝑥𝑗 Donde 𝑥𝑖 , 𝑥𝑗 corresponde a los valores de las posiciones i y j del nuevo patrón. 𝛼 es un escalar que indica la ratio de aprendizaje, que se considera 1. Por tanto, la ecuación de actualización de la matriz de pesos sinápticos según el algoritmo de Hebbian queda la siguiente manera: 𝑊(𝑛+1)= 𝑊(𝑛)+ 𝑥𝑇∗𝑥 El algoritmo de Hebbian se pude resumir en los siguientes pasos: 1. Se inicializan todos los pesos de la matriz de pesos a 0. 𝑊𝑖𝑗= 0 2. Repetir el paso 3 para cada nuevo patrón de entrada que se desea aprender. 3. Actualizar los pesos conforme a la ecuación 𝑊(𝑛+1)= 𝑊(𝑛)+𝑥𝑇∗𝑥 4. Se ponen a cero los elementos de la diagonal de la matriz W. Se ha utilizado un ejemplo sencillo para explicar el algoritmo de Hebbian. Por ejemplo, para un caso concreto de una red neuronal formada por 5 neuronas, el vector de entrada será de tamaño 5 y por tanto los patrones de aprendizaje utilizados serán vectores de 5 bits. El vector de salida también será de 5 bits. En un caso concreto, si se desea aprender el siguiente patrón: (+1, -1, +1, +1, -1) El cálculo quedaría de la siguiente manera: [ 𝑊11 𝑊12 𝑊13 𝑊14 𝑊15 𝑊21 𝑊22 𝑊23 𝑊24 𝑊25 𝑊31 𝑊41 𝑊51 𝑊32 𝑊42 𝑊52 𝑊33 𝑊34 𝑊35 𝑊34 𝑊44 𝑊45 𝑊35 𝑊54 𝑊55 ] = [ 0 0 0 0 0 0 0 0 0 0 0000000 0 0 0 0 0 0 0 0 ] + [ +1 −1 +1 +1 −1 ] ∗[+1 −1 +1 +1 −1] La matriz quedaría, por tanto: 𝑊= [ 0 −1 +1 +1 −1 −1 0 −1 −1 +1 +1 +1 −1 −1 −1 +1 0 +1 −1 +1 0 −1 −1 −1 0 ] Puede comprobarse que el patrón se ha almacenado, evaluando la salida de la red para dicho patrón de entrada: 𝑦𝑖 = 𝑆𝑖𝑔𝑛(∑𝑊𝑖𝑗𝑥𝑗 𝑗) Que es lo mismo que multiplicar el patrón de entrada por la matriz de pesos: 𝑌 = 𝑆𝑖𝑔𝑛(H)=𝑆𝑖𝑔𝑛(𝑋 ∗𝑊) 25 𝐻 = [+1 −1 +1 +1 −1] ∗ [ 0 −1 +1 +1 −1 −1 0 −1 −1 +1 +1 +1 −1 −1 −1 +1 0 +1 −1 +1 0 −1 −1 −1 0 ] =[+4 −4 +4 +4 −4] Utilizando la función signo, se obtiene que el estado (salida) de la HNN es el propio patrón de entrada [+1 −1 +1 +1 −1]. 2.3.2. Algoritmo de aprendizaje iterativo La regla de aprendizaje Hebbian es un algoritmo de aprendizaje no supervisado. Los pesos solo dependen de los patrones de entrenamiento, sin utilizar la respuesta de la HNN en su cálculo. A este tipo de aprendizaje se denomina sin supervisión. Una variación de este tipo de aprendizaje consiste en introducir en el proceso la información de salida de la red neuronal. Este tipo de algoritmo de aprendizaje se denomina supervisado. Partiendo del algoritmo de aprendizaje de Hebb, se propuso una versión supervisada [18], [19] que denominamos regla de Hebb iterativa. Las diferencias fundamentales son que antes de actualizar los pesos para un nuevo patrón de entrada, se evalúa si este es ya un punto fijo (está aprendido) con los pesos actuales y sólo se modifican los pesos asociados a las neuronas que no satisfacen esta condición. Además, el proceso se repite hasta que el conjunto de patrones de entrenamiento se almacena en la HNN. El proceso de aprendizaje iterativo se resume en los siguientes pasos: 1. Se inicializa la matriz de pesos con todos sus elementos a 0. 2. Se establece un conjunto de patrones de entrenamiento. 3. La matriz de pesos se actualiza aplicando la regla de Hebb al primer patrón del conjunto. 4. Para cada uno de los patrones se evalúa la respuesta de la red neuronal. Si coincide con el propio patrón, este se ha aprendido y, por tanto, se vuelve al paso 4 para procesar otro patrón. En caso contrario, se aplica la regla de Hebb para dicho patrón antes de procesar el siguiente. 5. El procedimiento se repite hasta que todos los patrones se hayan aprendido. 32 3.1.3. Módulo de control El control que se encarga de generar señales necesarias para el correcto funcionamiento de la red neuronal. Este está formado por los bloques “serial2states”, “freq_divider” y “system_status” como se muestra en la Figura 12. El módulo de control se encarga de generar la señal de “slowclk” y “full_tick” que se utiliza en el bloque de las neuronas, registra la imagen de entrada y se la proporciona a la red de neuronas y, por último, también genera las señales “steady_check” e “inconsistent_check” que se utilizan para determinar cuando la salida de la red neuronal es estable y cuando el resultado de esta es inconsistente. Figura 12: Bloques de control ONN Digital A continuación, se explica en detalle el funcionamiento del bloque más complejo “serial2states”. “serial2states” Este módulo realiza las siguientes funciones: • Inicia el proceso de aplicar un patrón de entrada a la ONN. Esto es, cargar un determinado estado “data_input” al recibir un pulso en la señal “load”. El proceso consiste en propagar la señal de entrada “data_input” a “ser_state_output” cuando se ordena la aplicación de un patrón a la ONN y generar las correspondientes señales de control para la ONN. En la señal “data_input” se proporciona desde el exterior la imagen o estado de cada una de las neuronas. • Genera la señal “full_tick” para indicar que se carga una nueva imagen en la red neuronal. Los puertos del módulo “serial2states” son los siguientes: • clk: Señal de entrada de reloj maestro del módulo. • reset: Señal de entrada de reset asíncrono. • load: Señal de entrada que inicializa el proceso de serialización. • data_input: Dato de entrada en serie de la imagen a procesar por la red neuronal. Este dato se propaga a la salida “ser_state_output” al iniciarse la máquina de estado a partir de un pulso en la señal de entrada “load” • full_tick: Señal de salida que permanece a 0 durante la serialización del dato de entrada y que se pone a 1 una vez terminada la serialización. Esto permite iniciar la operación de inferencia en la ONN. • ser_state_output: Señal de salida serializada. Esta señal se conecta a la entrada de la primera neurona y permite cargar el estado inicial de cada neurona. 33 Simulaciones: La Figura 13 muestra una secuencia completa de serialización de una imagen de entrada. Figura 13: Simulación "serial2states" 1 La Figura 14 muestra la propagación de la señal “data_input”. El módulo asigna a la salida “ser_state_output” el estado de la señal “data_input” a partir del flanco de subida del reloj “clk”. Figura 14: Simulación "serial2states" 2 34 35 4. Diseño del Sistema En este capítulo se explica cómo se ha desarrollado el proceso de dotar a la ONN digital anteriormente analizada de capacidad de aprendizaje on-line. Esta capacidad se ha logrado implementando en hardware una modificación del algoritmo de aprendizaje iterativo supervisado descrito en el Capítulo 2. Se ha comenzado modelando el algoritmo en MATLAB para validarlo conceptualmente y utilizarlo como punto de referencia para la posterior implementación en hardware. El siguiente paso ha sido su implementación hardware mediante el diseño de diferentes módulos funcionales desarrollados a nivel RTL en Verilog y validados mediante simulaciones. Una vez chequeado su funcionamiento correcto, se ha procedido a validar la operación de la ONN con capacidad de aprendizaje on-line integrando los distintos bloques desarrollados junto con la ONN digital. Finalmente, el sistema se ha sintetizado e implementado para comprobar la viabilidad de su realización física en la plataforma Zybo en cuanto a recursos necesarios. El proceso de diseño se ha llevado a cabo en el entorno Vivado de Xilinx. Los módulos desarrollados en Verilog son completamente parametrizables para permitir escalar el diseño de una manera rápida y sencilla. 4.1. Diseño del algoritmo de aprendizaje iterativo En este punto se explica el proceso de modelado del algoritmo de aprendizaje iterativo en MATLAB. Se parte desde el modelado más simple de aprendizaje de Hebb sin supervisión, luego continúa explicando las diferentes funciones que se han utilizado durante todo el proceso, y finalmente se termina con la explicación de cómo se ha implementado el algoritmo de aprendizaje iterativo. 4.1.1. Módulo TestMatrix La función TestMatrix modela la red neuronal. Calcula su salida para un patrón de entrada. Esta función tiene los siguientes argumentos como entrada: • M: Matriz que contiene el patrón a testear. • W: Matriz de pesos. Contiene la matriz de pesos con la que se testea el patrón de entrada. • N_iter: Numero de iteraciones en el proceso de test. Y proporciona las siguientes salidas: • Mout_HL: Matriz de salida resultado de multiplicar la matriz de entrada M, que contiene el patrón a testear, por la matriz de pesos W. Mout_HL proporciona la salida equivalente a la red neuronal. • UpdateMatrix: Matriz de salida del mismo tamaño que “Mout_HL”. Esta matriz indica que posiciones de la matriz de salida Mout_HL son diferentes a la matriz de entrada M. No es necesario para calcular la respuesta de la red neuronal, pero se utiliza en la función de aprendizaje iterativo como se explicará posteriormente. 4.1.2. Módulo hebb_unsupervised Este módulo implementa la regla de aprendizaje de Hebb sin supervisión. Como ya se ha indicado, este tipo de aprendizaje solo depende de los vectores de entrada y no tiene en cuenta el resultado de la red neuronal. Se ha implementado en MATLAB un script dedicado a testear el aprendizaje de Hebb. Este lee desde un fichero externo los patrones a entrenar, determina el número total de patrones y su 36 longitud para enviarlos a la función “function W = update(W,pattern)” que se encarga de actualizar la matriz de pesos conforme a la ecuación: 𝑊(𝑛+1)= 𝑊(𝑛)+ 𝑥𝑇∗𝑥 Para probar el funcionamiento, se ha implementado un ejemplo con 15 neuronas en el que se ha utilizado un conjunto de tres patrones de entrada que están almacenados en un fichero de texto, con el siguiente contenido: 1,1,1,1,0,1,1,0,1,1,0,1,1,1,1 0,0,1,0,0,1,0,0,1,0,0,1,0,0,1 1,1,1,0,0,1,1,1,1,1,0,0,1,1,1 Estos valores representan cada uno de los pixeles de una imagen de 5x3, donde cada elemento indica si el color de píxel es negro, con un “1”, o blanco, con un “0”. Por ejemplo, el vector (1,1,1,1,0,1,1,0,1,1,0,1,1,1,1) representa el numero 0 sobre una matriz de 5x3. Ver Figura 15. Figura 15: Representación número 0 sobre matriz de 5x3 píxeles. Otro ejemplo es el vector (1,1,1,0,0,1,1,1,1,1,0,0,1,1,1) que representa el número 2 en una matriz de 5x3. Ver Figura 16. Figura 16: Representación número 2 sobre matriz de 5x3 Durante el aprendizaje, la matriz de pesos se va adaptando a medida que se introducen nuevos patrones para almacenar, hasta llegar un momento en el que pierde la capacidad de recuperar los patrones ya aprendidos. 37 A continuación, se ilustra este comportamiento. Se va a realizar un test para comprobar la capacidad de almacenamiento de nuevos patrones. Para ello, se va a partir de una matriz inicializada con todos sus valores a 0, se aprende un patrón, se calcula la respuesta de la red con la matriz de peso tras el aprendizaje para dicho patrón (se testea el patrón) y se va a comprobar la evolución a medida que se introducen nuevos patrones a aprender. Resumiendo, el procedimiento que se va a realizar es el siguiente: • Se aprende el patrón 0. • Se testea el patrón 0. • Se aprende el patrón 1. • Se testea el patrón 0. • Se aprende el patrón 2. • Se testea el patrón 0. El resultado obtenido del test es el mostrado en la Tabla 1. Tabla 1: Resultado test aprendizaje sin supervisión para el patrón 0 Observando la evolución de los resultados, se ve que, después de aprender el patrón 0, los resultados obtenidos del test son satisfactorios, pues se consigue recuperar el patrón de entrada. En el segundo resultado, después de aprender el patrón “1”, se ve que se continúa recuperando el patrón “0”. En el tercer test, después de introducir el patrón 2 en la matriz, se observa que el resultado para uno de los valores pasa a ser 0 (marcado en rojo). Esto implica que, la matriz de pesos empieza a perder la capacidad de recuperar los patrones aprendidos. También es interesante analizar la evolución del resto de patrones. Para el caso del patrón de entrada 1 se muestra en la Tabla 2. Se observa que en la primera fase de aprendizaje el resultado no es correcto, ya que, el patrón 1 no se ha aprendido aún y en este caso, se obtiene como resultado el patrón 0. Tras aprender el patrón 1, se puede ver que el resultado es correcto, por lo que se comprueba que el algoritmo funciona para al menos dos patrones. Finalmente, después de añadir el patrón 2, el resultado indica que el sistema ha dejado de recuperar el patrón “1”, ya que vuelve a introducir errores en la detección. Tabla 2: Resultado test aprendizaje sin supervisión para el patrón 1 Patrón entrada "1" 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 Resultado Test después de aprender patrón "0" 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1 Resultado Test después de aprender patrón "1" 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 Resultado Test después de aprender patrón "2" 1 1 1 0 0 1 1 0 1 1 0 1 1 1 1 Patrón entrada "0" 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1 Resultado Test después de aprender patrón "0" 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1 Resultado Test después de aprender patrón "1" 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1 Resultado Test después de aprender patrón "2" 1 1 1 1 0 1 1 0 1 1 0 0 1 1 1 38 Por último, en la Tabla 3 se analiza el patrón 2. En esta se observa que el sistema no es capaz de recuperar el patrón “2” al añadirlo a la matriz de pesos. Tabla 3: Resultado test aprendizaje sin supervisión para el patrón 2 Patrón entrada "2" 1 1 1 0 0 1 1 1 1 1 0 0 1 1 1 Resultado Test después de aprender patrón "0" 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1 Resultado Test después de aprender patrón "1" 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1 Resultado Test después de aprender patrón "2" 1 1 1 1 0 1 1 1 1 1 0 0 1 1 1 El resultado obtenido en este test indica que solo se ha conseguido aprender 2 patrones de entrada, lo cual es coherente con el límite de 0.15*n indicado en el Capítulo de Fundamentos. 4.1.3. Módulo LearnHebb Para evolucionar el módulo de aprendizaje de Hebb hacia el algoritmo de aprendizaje iterativo supervisado, se ha implementado la función LearnHebb. El objetivo de esta es implementar una función que pueda bloquear las posiciones de la matriz de pesos que no se desean actualizar. Función “function [WeightMatrixOut] = LearnHebb(InputTrainingMatrix,WeightMatrix,UpdateMatrix, NumError)” Esta función tiene los siguientes argumentos de entrada: • InputTrainingMatrix: Matriz de entrada de tamaño Nrow*Ncol que contiene el patrón que se desea aprender. • WeightMatrix: Es la matriz de pesos sinápticos de tamaño n*n, siendo n = Nrow*Ncol, que se desea actualizar según el patrón de entrada InputTrainingMatrix. • UpdateMatrix: Es una matriz de tamaño Nrow*Ncol que indica que los pesos asociados a la neurona indicada en UpdateMatrix se puede actualizar o no. La función proporciona como salida la matriz de pesos actualizada de tamaño n*n. La función LearnHebb acepta en la entrada InputTrainingMatrix los patrones en formato de matriz con valores de -1 y 1. Ejemplo: InputTrainingMatrix = [ 1 1 1; 1 -1 1; 1 -1 1; 1 -1 1; 1 1 1] 1 1 1 1 -1 1 1 -1 1 1 -1 1 1 1 1 En el ejemplo anterior, la matriz está representando el número 0 en una matriz de 5*3. 39 En la entrada UpdateMatrix recibe una matriz del mismo tamaño que InputTrainingMatrix. Esta matriz contiene 0 y 1 para indicar qué posiciones de la matriz InputTrainingMatrix se puede actualizar y cuáles no. Esto permite bloquear las posiciones que no se desean modificar. • Si UpdateMatrix(i,j) = 0 la posición (i,j) de la matriz no se puede actualizar. • Si UpdateMatrix(i,j) = 1 la posición (i,j) de la matriz se puede actualizar. Ejemplo: UpdateMatrix = [ 0 0 0; 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 0 Esto indica que los pesos correspondientes a las neuronas de las posiciones marcadas con “1” son las que se pueden modificar, mientras que los pesos de las neuronas marcadas con “0” quedan bloqueadas y, por tanto, no se pueden modificar. En la entrada WeightMatrix se proporciona la matriz de pesos que se desea actualizar con tamaño n*n. La función devuelve una matriz de pesos actualizada aplicando la regla de aprendizaje de Hebb a partir de la matriz de entrada a entrenar InputTrainingMatrix y de la matriz de pesos WeightMatrix, pero solo actualizando los pesos correspondientes a posiciones que no están bloqueadas, es decir, los marcados con “1” según la matriz de entrada UpdateMatrix. 4.1.4. Módulo Aprendizaje Iterativo LearnIterative La función LearnIterative implementa el proceso de aprendizaje iterativo supervisado que hemos desarrollado. Esta función usa las funciones anteriormente descritas. El proceso de aprendizaje iterativo se muestra en el diagrama de flujo de la Figura 17. El proceso comienza con la inicialización de algunas variables necesarias para el funcionamiento del algoritmo. Los patrones para aprender se leen desde una variable y estos se envían para que se aprendan. Los patrones que se van aprendiendo se van almacenando en “Pattern_List”. El tratamiento para el primer patrón es ligeramente diferente que para el caso de los siguientes patrones. El primer patrón se envía directamente al aprendizaje mediante la función LearnHebb, mientras que los siguientes, primero se testean y luego, en función de los errores detectados, se aprenden. Cuando el algoritmo intenta aprender un nuevo patrón, se produce una actualización de la matriz de pesos y esto puede dar lugar a que patrones que ya estaban aprendidos dejen de estarlo y, por tanto, requieran de nuevas correcciones en la matriz de pesos. Por esto, después de cada uno de los procesos de aprendizaje, se vuelve a testear desde la primera posición de la lista “Pattern_List”. 40 Figura 17: Diagrama Flujo aprendizaje iterativo 41 El proceso de test consiste en aplicar el patrón de entrada en la red neuronal. Esta comprobación devuelve si existen errores o no, y en función de esto se continúa con el siguiente patrón o se envía el patrón al aprendizaje. Este proceso continúa hasta que se corrigen los errores o de lo contrario hasta que se llega a un número máximo de intentos. Cuando se llega a un límite de intentos con un patrón determinado, el algoritmo finaliza el aprendizaje de dicho patrón y vuelve al inicio para continuar con el siguiente patrón disponible. Finalmente, para comprobar visualmente el resultado del proceso de aprendizaje, se muestran gráficamente los patrones aprendidos. En la Figura 18 se muestra en la izquierda el conjunto de patrones que se han enviado al algoritmo de aprendizaje y en la imagen de la derecha se muestra los patrones que han sido aprendidos (“pattern_list”). Figura 18: Resultado aprendizaje iterativo De los resultados, se obtiene que se han aprendido un total de 7 patrones, lo que da lugar a una ratio de 0.46*n, frente al 0.15*n que se tiene con un proceso de aprendizaje no supervisado. Esto proporciona una mejora sustancial respecto al algoritmo de Hebb simple. 48 Justo después de actualizar la matriz de pesos, el módulo de aprendizaje iterativo envía una imagen de test mediante las señales “img_load_o” y “serial_out_o”. Estas señales se conectan al módulo de serialización “serial2states” que inicializa el estado de las redes neuronales oscilatorias (Figura 28). Figura 28: Test "mod_learn_hebb_iterative" 3 Desde el momento en el que la señal “full_tick” se pone a nivel 1, comienza el proceso de alineación de la red neuronal hasta que se genera la señal de “steady_i” que indica cuando la señal de salida “ninput_i” es estable. Es en este momento en el que el módulo de aprendizaje iterativo captura la salida de la red neuronal para comprobar si el patrón ha sido aprendido (Figura 29). Figura 29: Test "mod_learn_hebb_iterative" 4 El test continúa hasta que se termina enviando los 10 patrones almacenados en el fichero de texto. Al terminar el proceso se puede ver que el número de patrones que ha sido capaz de aprender el sistema es de 7 patrones (guardados en las posiciones 0 a 6 de “pattern_list”). Se ve también el comportamiento de la señal “pattern_nok_status_o”. Esta se activa en tres ocasiones indicando que los tres patrones correspondientes no se han podido aprender. Esto coincide con el número de patrones enviados y aprendidos. (Figura 30). 49 Figura 30: Test "mod_learn_hebb_iterative" 5 50 4.3. Integración del sistema En este apartado se explica cómo se ha realizado la integración de todo el sistema formado con los módulos desarrollados y la ONN. Para ello, se ha elaborado un código que interconecta entre sí los módulos. Además, para permitir tanto la funcionalidad de aprendizaje como la operación normal de la ONN, ha sido necesario añadir algunos otros elementos. Así, se ha utilizado multiplexores que seleccionan si los patrones de entrada de la ONN provienen desde el exterior o bien desde el módulo de aprendizaje iterativo. Para proporcionar la salida de la ONN al exterior, se ha desarrollado el módulo “mod_data_capture” que se encarga de realizar la captura del dato de salida de las neuronas a partir de la señal “steady_check” y lo presenta en la salida. La Figura 31 muestra el sistema completo. Figura 31: Diagrama de bloques del sistema completo. Para testear el módulo se ha generado un testbench que permite enviar patrones de aprendizaje y patrones de test para comprobar el funcionamiento. En este caso se ha utilizado un testbench que es capaz de leer los patrones de test y de aprendizaje a partir de un fichero de texto. Estos se introducen en el fichero de texto con valores de 0’s y 1’s, donde el primer valor indica que tipo de operación se va a realizar y los siguientes contienen el patrón. La operación se clasifica de la siguiente manera: • 1 = Operación de aprendizaje. • 0 = Operación de test. Figura 32: Codificación patrones de entrada en el testbench del sistema completo 51 Por ejemplo, el siguiente comando: 1111101101101111 indica que se va a aprender el patrón “111101101101111”. En la Figura 33 se muestra el diagrama de flujo del testbench para el sistema completo. Este testbench lo primero que hace es leer los datos del fichero externo y almacenarlo en el array de vectores “read_training”. Este array contiene la operación y el vector que se utilizará para aprenderlo o testearlo. También se determina el número de vectores que hay en el fichero y se almacena en la variable “n_training”. La máquina de estados maneja las señales correspondientes en función de si la operación es de aprendizaje o de test. El proceso termina en el estado de reposo “Idle” cuando se han procesado todos los vectores. Figura 33: Diagrama flujo del testbench 52 Para comprobar el funcionamiento del módulo se ha preparado el fichero mostrado en la Figura 34. Este fichero de texto realiza las siguientes operaciones: • Aprender el patrón correspondiente al número 0. • Testear el patrón correspondiente al 0. • Testear el patrón correspondiente al 1. Se espera que no se reconozca. • Aprender el patrón correspondiente al número 1. • Testear el patrón correspondiente al 1. • Aprender los patrones correspondientes desde el numero 2 al 9. • Testear los patrones correspondientes desde el numero 2 al 9. Figura 34: Patrones de entrada en el testbench del sistema completo En la Figura 35 se muestran los cuatro primeros comandos enviados al módulo. Se aprende el patrón correspondiente al 0 (“7bff”), se testea y se observa que el resultado obtenido (“noutput_o”) es el correspondiente al patrón 0. Luego se testea el patrón 1 y se ve que el resultado obtenido vuelve a ser el correspondiente al 0. A continuación, se envía el comando para aprender el patrón 1 y se testea. En este caso, se puede ver que el resultado obtenido es correcto (Figura 36). Figura 35: Simulación sistema completo 1 53 Figura 36: Simulación sistema completo 2 En la Figura 37 se muestra el proceso completo de todos los patrones del fichero de texto. Se observa que durante el aprendizaje se han producido 3 fallos de patrones (activación de la señal pattern_nok_status_o), los correspondientes al “79ef”, “7bef” y “7bc9”. La señal “learn_i” se activa por cada nuevo patrón que se desea aprender y se puede ver también que la distancia entre cada vez que se activa “learn_i” se va distanciando, esto es debido a que la ONN cada vez le cuesta más aprender un nuevo patrón. Al final de todo el proceso de aprendizaje se realiza el proceso de test, durante este lo que se hace es enviar las imágenes correspondientes a los patrones y se captura el resultado. Figura 37: Simulación sistema completo 3 Por último, se ha sintetizado y se ha realizado una implementación del sistema para comprobar el nivel de ocupación en el dispositivo que se ha elegido y el resultado obtenido se muestra en la Figura 38. Figura 38: Recursos implementación ONN con capacidad de aprendizaje on-line con 15 neuronas. 54 55 5. Implementación física En este apartado se explica cómo se ha implementado el setup para verificar el funcionamiento de la ONN con aprendizaje on-line. Para ello, se ha utilizado una placa de desarrollo de Digilent. 5.1. Setup experimental El setup para la verificación del sistema consiste en una tarjeta Zybo Z7 7020 conectada a un PC a través del puerto USB. La tarjeta Zybo Z7 7020 tiene una FPGA de la serie ZYNQ de Xilinx en la que se ha cargado el bitstream correspondiente a la plataforma hardware diseñada para la prueba de nuestro sistema y la aplicación que corre en el procesador ARM incluido en la FPGA ZYNQ de la tarjeta. Figura 39: Tarjeta Zybo Z20 de Xilinx Para acceder a las entradas y salidas de la ONN, se ha utilizado el ARM. La comunicación con el PC se ha realizado mediante un puerto serie, gestionado por el ARM. El diagrama de bloques de este setup se muestra en la Figura 40. Figura 40: Diagrama de bloques del setup experimental. 56 Además del módulo TOP_ONN, que contiene la ONN con aprendizaje on-line, se ha implementado un bloque, AXI Interface ONN, para la comunicación entre el ARM y la ONN. Este bloque permite acceder a los puertos de la ONN desde el procesador ARM del ZYNQ de una manera sencilla. El resto son módulos que se encuentran en el catálogo de Xilinx y que se han instanciados y configurados para esta aplicación. En la Figura 41 se muestra el diagrama de bloques del setup de prueba en la herramienta de Xilinx Vivado. Figura 41: Diagrama de bloques de la plataforma hardware que se implementa en el FPGA. El procesador ARM de la ZYNQ se comunica con el exterior mediante un puerto UART. Desde el PC se accede a este desde una herramienta desarrollada en MATLAB que permite el envío de patrones (imágenes en nuestra aplicación), así como recibir la respuesta de la ONN para poder analizarlos y compararlos con lo que se espera. • Módulo TOP_ONN. El módulo TOP_ONN es el que contiene el diseño del algoritmo de aprendizaje iterativo y la red neuronal ONN. Para proporcionar las imágenes de entrenamiento al módulo de aprendizaje iterativo, se ha propuesto enviar estas imágenes de forma paralelo a través del puerto “parallel_input_i”. Una imagen de test está formada por tantos bits como neuronas tenga la ONN, multiplicada por el número de bits utilizados para definir el estado de cada neurona. Por ejemplo, para el caso de 15 neuronas y 4 bis de ancho para la definición del estado de cada neurona, da un total de 60 bits necesarios para definir una imagen. Por tanto, lo que se ha hecho es definir un bus paralelo de hasta 384 bits para poder transmitir las imágenes de test al módulo de aprendizaje iterativo. Esta imagen en paralelo que le llega al módulo de aprendizaje iterativo necesita ser serializada para poderla introducir en la red de neuronas. Por este motivo, se ha modificado el módulo de captura “mod_data_capture” para que, al recibir la imagen en paralelo, la serialice y la envíe a la red neuronal. La Figura 42 muestra un diagrama detallado de cómo está compuesto este módulo. Este diagrama es similar al mostrado en la Figura 31 pero con la modificación para capturar los datos de la imagen en paralelo. 57 Figura 42: Diagrama de bloques TOP_ONN A partir de este diseño, se realiza la síntesis e implementación que genera el fichero bitstream, el cual se utiliza para cargarse en el dispositivo. • Módulo AXI Interface_ONN. Este módulo permite acceder a los puertos de entrada / salida del módulo TOP_ONN mediante un bus AXI (Advanced eXtensible Interface) conectado al procesador. El Bus AXI es un protocolo desarrollado por ARM que permite interconectar de una manera estandarizada un procesador con módulos o periféricos. El módulo Interface_ONN consiste en un banco de 32 registros de 32 bits cada uno de ellos, a los cuales se pueden acceder en modo lectura o escritura desde el procesador. Estos registros se han mapeado a puertos de entrada/salida del módulo y de esta manera se puede controlar el acceso a los puertos del módulo Top_ONN. En la Figura 43 Se muestra el detalle de la interconexión de este módulo. Se puede observar cómo se conecta su bus AXI S00_AXI al procesador mediante un módulo de interconexión. Se observa también los puertos de entrada y salida del bus Interface_ONN que se conectan principalmente al módulo TOP_ONN. Figura 43: Interconexión del Módulo Interface_ONN. 64 5.3.2. Test 5x3 con 3 patrones En este caso el test se realiza con los patrones correspondientes al “0”, “1” y al “2”. Ver Figura 47. Figura 49: Test 5x3 con 3 patrones Se testea la ONN con todos los patrones y los resultados son los mostrados en la Figura 50 Test 5x2 con 3 patrones Patrones de test Resultado test Figura 50: Resultado test 5x3 con 3 patrones. 65 5.3.2.1. Test 5x2 con 3 patrones: Test ruido con 2 pixeles Resultados patrón “0”: Test 5x2 con 3 patrones: Patrón “0” con ruido 2 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 8 de 10 80 % Test 5x2 con 3 patrones: Patrón “0” con ruido 3 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 4 de 10 40 % 66 Resultados patrón “1”: Test 5x2 con 3 patrones: Patrón “1” con ruido 2 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 7 de 10 70 % Test 5x2 con 3 patrones: Patrón “1” con ruido 3 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 5 de 10 50 % 67 Resultados patrón “2”: Test 5x2 con 3 patrones: Patrón “2” con ruido 2 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 9 de 10 90 % Test 5x2 con 3 patrones: Patrón “2” con ruido 3 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 9 de 10 90 % 68 Resumen resultados: Tabla 5: Resumen resultados test ONN 5x3 con 3 patrones. Patrón testeado Número de errores introducidos en los patrones 2 píxeles 3 píxeles Recuperados Porcentaje Recuperados Porcentaje Patrón "0" 8 de 10 80% 4 de 10 40% Patrón "1" 7 de 10 70% 5 de 10 50% Patrón "2" 9 de 10 90% 9 de 10 90% Todos los test se han realizado con 10 patrones diferentes generados de manera aleatoria Comparativa entre test con 2 y 3 patrones: En la Tabla 6 se muestra un resumen comparativo entre los test realizados con 2 y 3 patrones. En este se muestra una media de los resultados obtenidos en ambos casos. Como se puede observar, el resultado con 2 patrones es del 90% de recuperación, tanto con la introducción de 2 pixeles como 3 pixeles de errores. En el caso de 3 patrones aprendidos, se obtiene un resultado de 80% y 60% respectivamente para 2 y 3 pixeles de errores. Estos resultados son coherentes, ya que, a mayor número de patrones aprendidos, se espera un empeoramiento de la capacidad de recuperación. Tabla 6: Comparativa test 2 y 3 patrones. Comparativa entre test con 2 y 3 patrones Test Setup Número de errores introducidos en los patrones 2 píxeles 3 píxeles Porcentaje recuperación Porcentaje recuperación Test con 2 patrones 90% 90% Test con 3 patrones 80% 60% 69 5.4. Pruebas con versión 7x5 En esta sección se exponen los resultados obtenidos con la versión de ONN de 7x5 neuronas. Los test presentados en este punto van enfocados a conocer la capacidad de recuperación que tiene la ONN frente a patrones con ruido y por otro lado se expone un test con objeto de determinar el máximo número de patrones que es capaz de almacenar la ONN. Para estos test se van a utilizar patrones correspondientes a las letras del abecedario que se muestran en la Figura 51. Figura 51: Patrones test ONN 7x5. 5.4.1. Test 7x5 con 4 patrones El test consiste en aprender el patrón correspondiente a las letras “A”, “B”, “C” y “D”. Estos patrones se envían a la ONN y, posteriormente, se testea con 10 patrones correspondientes desde la “A” a la “J” para comprobar el comportamiento frente a estos. En la Figura 52 se puede observar en la figura de la derecha que los patrones “A”, “B”, “C” y “D” se han aprendido correctamente, para el resto de los patrones la ONN ha proporcionado el resultado que más se aproxima. Por ejemplo, en el caso de la “G” y “E” que se obtiene la “C” o en el caso de la “H” que se obtiene una “A”. Test 7x5 con 4 patrones Patrones de test de entrada Resultado del test Figura 52: Test 7x5 con 4 patrones. 70 5.4.1.1. Test 7x5 con 4 patrones: Test ruido En este punto se comprueba la capacidad de recuperación de la ONN frente a patrones con ruido. Para cada uno de los patrones aprendidos, se generan patrones con cuatro niveles diferente de ruido, desde 3 pixeles hasta 6 pixeles. Los patrones con ruido son generados mediante una función que genera valores pseudoaleatorios. Resultados patrón “A”: Test 7x5 con 4 patrones: Patrón “A” con ruido 3 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 10 de 10 100 % Test 7x5 con 4 patrones: Patrón “A” con ruido 4 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 10 de 10 100 % 71 Test 7x5 con 4 patrones: Patrón “A” con ruido 5 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 10 de 10 100 % Test 7x5 con 4 patrones: Patrón “A” con ruido 6 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 10 de 10 100 % 72 Resultados patrón “B”: Test 7x5 con 4 patrones: Patrón “B” con ruido 3 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 1 de 10 10 % Test 7x5 con 4 patrones: Patrón “B” con ruido 4 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 5 de 10 50 % 73 Test 7x5 con 4 patrones: Patrón “B” con ruido 5 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 3 de 10 30 % Test 7x5 con 4 patrones: Patrón “B” con ruido 6 pixeles Patrones de test Resultado test Numero de imágenes Recuperadas Porcentaje recuperación 1 de 10 10 % 80 5.5. Recursos En este punto se analizan los recursos utilizados para la implementación de los dos sistemas cuyos resultados se han reportado, es decir, las versiones de 5x3 y 7x5 neuronas. Recursos sistema experimental completo para ONN 5x3 En la Figura 54 se muestran los recursos utilizados y en la Figura 55 se muestra el layout de la FPGA. Figura 54: Recursos lógica para sistema 5x3 Figura 55: Ocupación FPGA para sistema experimental 5x3 81 La herramienta de Vivado también tiene la capacidad de indicar como se reparten los recursos en función de cada módulo. Esto permite saber cuál de estos es el que más recursos consume. En la Figura 56 se ve que el módulo “mod_updatematrix” es el que más recursos en LUT se lleva, seguido del módulo “mod_lear_hebb_iterative”. Figura 56: Reparto recursos sistema 5x3 Recursos sistema experimental completo para ONN 7x5 La Figura 57 muestra los recursos utilizados para el caso de la red neuronal de 7x5. Figura 57: Recursos lógica para sistema 7x5 82 En la Tabla 9 se muestra una comparativa de los recursos utilizado en los diferentes modelos de redes neuronales. Tabla 9: Comparativa recursos Modelo Incrementos en recursos Neuronas LUT LUTRAM FF BUFG 5x3 15 7443 60 5282 2 7x5 35 Δ 130 % 38147 Δ 410 % 60 Δ 0 % 19626 Δ 270 % 3 Δ 50 % Se observa que en cuanto a LUT (Look Up Table) se produce un incremento de más del 410 % al pasar de 15 neuronas a 35 neuronas, que supone un incremento de 130% en cuanto al número de neuronas. Se ve que el consumo de LUT se dispara al incrementar el número de neuronas, esto hace pensar que este recurso es el que más va a limitar a la hora de escalar el número de neuronas. Además, como se puede ver en el caso de la red neuronal de 7x5 los recursos en cuanto a LUT de la Zynq se van a 71% del total. 83 6. Conclusiones Se ha diseñado, implementado y verificado experimentalmente una ONN digital con capacidad de aprendizaje supervisado con mejores prestaciones que la regla de Hebb. Durante el desarrollo de este trabajo se han abordado las siguientes tareas: • Familiarización con determinados conceptos relativos a las redes neuronales y su aprendizaje. En particular con el modelo de red de Hopfield y reglas de aprendizaje Hebbian. • Familiarización con el funcionamiento de los elementos básicos que forman las redes neuronales oscilatorias. • Comprensión del funcionamiento de la ONN digital desarrollada en el proyecto europeo NeurONN. • Se ha desarrollado un algoritmo de aprendizaje supervisado y se ha comparado su comportamiento con la regla de aprendizaje simple de Hebb. Los resultados que se han obtenido han sido positivos, ya que, se ha observado una mejora de entorno a tres veces más capacidad con respecto al algoritmo simple. • Se ha diseñado un bloque hardware que implementa dicho algoritmo de aprendizaje. Se ha validado su comportamiento comparando los resultados de simulación con los obtenidos en MATLAB. • Se ha desarrollado un sistema hardware-software en un dispositivo Zynq para verificar experimentalmente la ONN digital con capacidad de aprendizaje on-line. Se ha hecho uso del procesador embebido del que dispone el dispositivo ZYNQ, como pasarela de comunicación entre el diseño del algoritmo de aprendizaje iterativo con la ONN implementado en la lógica y el exterior. • Se han desarrollado una serie de funciones en MATLAB para controlar la ONN y el bloque de aprendizaje implementado en el Zynq. • Se han realizado pruebas con ONNs de 5x3 y 7x5 para una aplicación de reconocimiento de dígitos. El entorno proporciona los medios para poder automatizar estos test y poder comprobar de forma visual los resultados. • Durante el desarrollo de este TFM se ha detectado algunas posibles líneas de estudio y/o mejoras que se podrían plantear en futuras investigaciones: o Adaptación del sistema y setup de test desarrollados en este TFM para reemplazar la versión digital de la ONN por la ONN analógica desarrollada en NeurONN. Esta línea permitiría dotar a la ONN analógica de la capacidad de aprendizaje online, además de proporcionar un entorno para la implementación de test y la verificación de su funcionamiento. o Aunque el principal objetivo de este TFM no era el estudio en profundidad del algoritmo de aprendizaje iterativo implementado, sería interesante estudiarlo con más detalle y comparar su comportamiento con respecto a otro tipo de algoritmos de aprendizaje con supervisión reportados en la literatura. o Implementación de una aplicación real mediante el uso del sistema desarrollado en este TFM. Una posible aplicación sería utilizar el entono en el que la alimentación de datos de entrada al algoritmo sea proporcionada desde un sensor real, como podría ser imágenes provenientes de una cámara. 84 85 7. Referencias [1] MathWorks, «https://es.mathworks.com/products/matlab.html,» [En línea]. [2] Vivado. [En línea]. Available: https://www.xilinx.com/products/design-tools/vivado.html. [3] XILINX, «Vitis,» [En línea]. Available: https://www.xilinx.com/products/designtools/vitis/vitis-platform.html. [4] DIGILENT. [En línea]. Available: https://digilent.com/reference/programmablelogic/zybo-z7/start. [5] Digilent. [En línea]. Available: https://digilent.com/reference/_media/reference/programmable-logic/zybo-z7/zyboz7_rm.pdf. [6] Hoppensteadt, F.C. y E. M. Izhikevich, «Oscillatory neurocomputers with dynamic connectivity,» Phys. Rev. Lett., vol. 82, nº (14), 2983 doi:doi.org/10.1103/PhysRevLett.82.2983, 1999. [7] A. e. a. Raychowdhury, «Computing with Networks of Oscillatory Dynamical Systems,» Proc. of the IEEE, vol. 107, nº 1, pp. 73-89, 2019. [8] Hoppensteadt, F.C. y E. Izhikevich, «Pattern recognition via synchronization in phaselocked loop neural networks,» IEEE Transactions on Neural Networks, vol. 11, nº 3, pp. 734-738. doi: 10.1109/72.846744, 2000. [9] G. Csaba, «Computing with Coupled Oscillators: Theory, Devices, and Applications,» IEEE International Symposium on Circuits and Systems (ISCAS), Florence, Italy, pp. 1-5, 2018. [10] Nikonov, D.E. y e. al., «Coupled-Oscillator Associative Memory Array Operation for Pattern Recognition,» IEEE Journal on Exploratory Solid-State Computational Devices and Circuits, vol. 1, pp. 85-93. doi: 10.1109/JXCDC.2015.2504049, 2015. [11] P. Maffezzoni, L. Daniel, N. Shukla, S. Datta y A. Raychowdhury, «Modeling and Simulation of Vanadium Dioxide Relaxation Oscillators,» IEEE Transactions On Circuits-I, vol. 62, pp. 2207-2215. doi: 10.1109/TCSI.2015.2452332, 2015. [12] A. Parihar, N. Shukla, S. Datta y A. Raychowdhury, «Synchronization of pairwise-coupled, identical, relaxation oscillators based on metal-insulator phase transition devices: a model study,» J. Appl. Phys., vol. 117, nº 5, 2015. [13] H.-T. Kim, «Electrical oscillations induced by the metal-insulator transition in VO2,» 2010. [14] J. Núñez, J. M. Quintana, M. J. Avedillo, M. Jiménez, A. Todri-Sanial, E. Corti, S. Karg y B. Linares-Barranco, «Insights Into the Dynamics of Coupled VO2 Oscillators for ONNs,» IEEE Trans. Circuits Syst. II: Express Briefs, vol. 68, nº 10, pp. 3356-3360, 2021. [15] J. Hopfield, «Neural networks and physical systems with emergent collective computational capabilities,» Proceedings of the national academy of sciences, vol. 79, nº 8, pp. 2554-2558, 1982. [16] D. Hebb, The Organization of Behavior, DOI: 10.1016/S0361-9230(99)00182-3, 1949. [17] R. McEliece, E. Posner, E. Rodemich y S. Venkatesh, «The Capacity of the Hopfield Associative Memory,» IEEE Transactions on Information Theory, vol. 33, nº 4, pp. 461482, July 1987. 86 [18] S. Diederich y M. Opper, de “Learning of correlated patterns in spin-glass networks by local learning rules,” Phys. Rev. Lett., vol. 58, no. 9, Mar. 1987, p. pp. 949–952. [19] G. Tanaka, «Spatially Arranged Sparse Recurrent Neural Networks for Energy Efficient Associative Memory,» IEEE Trans. Neural Netw. Learning Syst., vol. 31, nº 1, pp. 24-38, Jan. 2020. [20] M. Abernot, T. Gil, M. Jiménez, J. Núñez, M. J. Avellido, B. Linares-Barranco, T. Gonos, T. Hardelin y A. Todri-Sanial, «Digital Implementation of Oscillatory Neural Network for Image Recognition Applications,» Frontiers in Neuroscience, vol. 15, nº 713054, 2021. 87 8. Anexos 88 8.1. Anexo I. Código MATLAB “hebb_unsupervised” clear all; %import patterns from external file "training_data.txt" pattern = importdata("training_data.txt"); %extract pattern's lenght and the number of patterns pattern_length= length(pattern(1,:)); n_pattern = length(pattern(:,1)); n_pattern = 2 %initialize the Weigth matrix to zero W = zeros(pattern_length,pattern_length); %process of update the Weigth matrix with the patterns for i=1:n_pattern W=update(W,pattern(i,:)); end %test the weitgh matrix with pattern for i=1:n_pattern test(i,:) = pattern(i,:)*W; for j=1:pattern_length if test(i,j) > 0 result(i,j) = 1; else result(i,j) = 0; end end end %compare result with origianl pattern for i=1:n_pattern if pattern(i,:) == result(i,:) compare(i) = 1; else compare(i) = 0; end end %function in charge of updating the weight function W = update(W,pattern) for j = 1: length(pattern) % j used to sweep the rows for i = 1: length(pattern) % i used to sweep the colums if i == j W(j,i) = 0; else if pattern(j) == pattern(i) % if input equals target, increase the weight W(j,i) = W(j,i) + 1; else % if input differs from target, decrease the weight W(j,i) = W(j,i) - 1; end end end end end 89 8.2. Anexo II. Código MATLAB “hebb_unsupervised_test1” clear all; %import pattern from external file pattern = importdata("training_data.txt"); %extract pattern lenght and number of pattern pattern_length= length(pattern(1,:)); n_pattern = length(pattern(:,1)); %initialize the Weigth matrix to zero W = zeros(pattern_length,pattern_length); %Learn the pattern 0 W=update(W,pattern(1,:)); %Test the pattern 0 test0(1,:) = pattern(1,:); test0(2,:) = pattern(1,:)*W; for i = 1:pattern_length if test0(2,i) > 0 test0(2,i) = 1; else test0(2,i) = 0; end end %Test the pattern 1 test1(1,:) = pattern(2,:); test1(2,:) = pattern(2,:)*W; for i = 1:pattern_length if test1(2,i) > 0 test1(2,i) = 1; else test1(2,i) = 0; end end %Test the pattern 2 test2(1,:) = pattern(3,:); test2(2,:) = pattern(3,:)*W; for i = 1:pattern_length if test2(2,i) > 0 test2(2,i) = 1; else test2(2,i) = 0; end end %Learn the pattern 1 W=update(W,pattern(2,:)); %Test the pattern 0 test0(3,:) = pattern(1,:)*W; for i = 1:pattern_length if test0(3,i) > 0 96 % matrix_fig(Mout_HL,sprintf('Iteration %s',num2str(k))); aux2; % Uncomment to display value while running toc display('TestMatrix Evaluation Finished') end 97 8.6. Anexo VI. Código MATLAB “LearnIterative” clear all; load('Train_5x3.mat'); % MTrain = Mtrain; PatternFirst = 1; %indica el primer patron que se va a aprender PatternEnd = 10; %indica el ultimo patron que se va a aprender IterationByStep = 1; %indica si el proceso iterativo es por pasos o no %Se obtiene los parametros de tamaño y numero de matrices de entrada MatrixSize=size(MTrain(:,:,:)); MatrixNumber = MatrixSize(3); MatrixSize = MatrixSize(1)*MatrixSize(2); %se genera la matriz de pesos nueva y se inicia a 0 NewWeightMatrix = zeros(MatrixSize); %Se crea la matriz de unos para el primer proceso de aprendizaje UpdateMatrix = ones(size(MTrain(:,:,1))); %Se crean matrices para la salida y los errores MOut(:,:,MatrixNumber) = zeros(size(MTrain(:,:,1))); MatrixError(:,:,MatrixNumber) = zeros(size(MTrain(:,:,1))); %se inicializa la primera matriz todo a 1, para el primer aprendizaje MatrixError(:,:,1) = ones(size(MTrain(:,:,1))); NRow = length(MTrain(:,1,1)); NColumn = length(MTrain(1,:,1)); NMatrix = length(MTrain(1,1,:)); Pattern_List = zeros(NRow,NColumn,NMatrix); pointer = 1; i = 1; state = 1; FirstPattern = 1; while (pointer < NMatrix) switch state case 1 %Idle %Nuevo patron Pattern_Input = MTrain(:,:,pointer); Pattern_List(:,:,i) = Pattern_Input; pointer = pointer + 1; New_Pattern = i; if FirstPattern == 1 %se inicializa la primera matriz todo a 1, para el primer aprendizaje 98 MatrixError(:,:,1) = ones(size(MTrain(:,:,1))); FirstPattern = 0; state = 2; else j = New_Pattern; Iteration = 1; state = 3; end case 2 %Learn %se aprende el patron i NewWeightMatrix=LearnHebb(Pattern_List(:,:,i),NewWeightMatrix,MatrixError(:,:,i),MatrixSi ze); j = 1; state = 3; case 3 %Test 1 %se testea el patron j [MOut(:,:,j), steadyOut, MatrixError(:,:,j)]=TestMatrix(Pattern_List(:,:,j), NewWeightMatrix, 1); a = MatrixError(:,:,j); Error = numel(a(a==1)); if Error == 0 %no errores if j >= New_Pattern i = New_Pattern + 1; state = 1; else j = j +1; state = 3; end else %hay errores Iteration = Iteration + 1; if Iteration >= 50 i = New_Pattern; state = 1; else %j = j + 1; i = j; state = 2; end end 99 otherwise state = 1; end end %Se pinta el resultado matrix_fig(MTrain(:,:,PatternFirst:PatternEnd),"entrada", "entrada") matrix_fig(MOut(:,:,PatternFirst:PatternEnd))