Implementacion de Una Red Neuronal en Un Fpga Con Lenguaje Descriptor de Hardware PDF

INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA

MECÁNICA Y ELÉCTRICA
IMPLEMENTACIÓN DE UNA RED NEURONAL EN UN

FPGA CON LENGUAJE DESCRIPTOR DE HARDWARE
QUE PARA OBTENER EL TÍTULO DE:

INGENIERO EN COMUNICACIONES Y ELECTRÓNICA.
PRESENTAN:
PEÑA SERRATO ERNESTO ANTONIO

DÁVILA LÓPEZ JUAN FERNANDO
ASESORES:
DR. LÓPEZ CÁRDENAS RODRIGO

M. EN C. SALINAS SALINAS MARISOL
M. EN C. NOVOA COLÍN JUAN FRANCISCO
México, D.F. Febrero, 2014

Dedicatoria
Ernesto Antonio Pena Serrato
A mi familia por apoyarme durante estos años a alcanzar este objetivo, gracias. Este logro es de
todos porque no ha sido fácil llegar hasta aquí y siempre les estaré agradecido por su tiempo,
ayuda y comprensión.
A mis asesores por su tiempo y consejos durante el desarrollo de este trabajo, en especial al Dr.
Rodrigo quien fue de gran ayuda para poder concluir este proyecto, gracias.
Juan Fernando Davila Lopez

En agradecimiento a mis padres porque gracias a su apoyo y consejo he llegado a realizar la más
grande de mis metas mi formación profesional, la cual constituye la herencia más valiosa que
pueda recibir.
i
ii
Índice
Dedicatoria ........................................................................................................................................... i
Índice ...................................................................................................................................................iii
Índice de figuras ................................................................................................................................. vii
Introducción ........................................................................................................................................ix
Objetivo general ..............................................................................................................................ix
Objetivos específicos .......................................................................................................................ix
Justificación .....................................................................................................................................ix
Planteamiento del problema ..........................................................................................................xi
Estructura del proyecto terminal ....................................................................................................xi
Capítulo 1 Marco Teórico. ................................................................................................................. 1
1.1. Redes Neuronales Artificiales................................................................................................... 2
1.1.1. Principios básicos de las Redes Neuronales ...................................................................... 2
1.1.2. Aplicaciones de las redes neuronales ............................................................................... 3
1.1.3 Arquitecturas típicas de las redes neuronales ................................................................... 5
1.1.4. Mecanismos de Aprendizaje ............................................................................................. 8
1.1.5. Entrenamiento de las redes neuronales artificiales ........................................................ 11
1.1.6. El Perceptrón ................................................................................................................... 12
1.1.7. Implementación y tecnologías emergentes .................................................................... 12
1.2. Implementación en dispositivos programables ..................................................................... 13
1.2.1. Dispositivo lógico programable FPGA ............................................................................. 13
1.2.2. Arquitectura genérica ..................................................................................................... 14
1.2.3. Descripción de la arquitectura ........................................................................................ 14
1.2.4. Lenguaje de descripción de hardware VHDL .................................................................. 16
Capítulo 2 Algoritmos de entrenamiento Perceptrón y de Retropropagación (Backpropagation) .. 19
2.1 Introducción ............................................................................................................................ 20
2.1. Las Redes ADALINE y MADALINE ........................................................................................... 20
2.2. Perceptrón.............................................................................................................................. 24
2.3. Algoritmo de entrenamiento Perceptrón .............................................................................. 25
2.4. Red de Retroprogación (Backpropagation) ............................................................................ 26
2.4.1 Regla Delta generalizada .................................................................................................. 27
iii
2.4.3 Estructura y Aprendizaje de la Red Backpropagation ...................................................... 28
2.4.2 Pasos para aplicar el Algoritmo de Entrenamiento.......................................................... 28
2.4.3 Dimensiones de la red. Número de capas ocultas ........................................................... 31
Capítulo 3 Implementación de Algoritmos de entrenamiento en VHDL (unidad de control y
máquinas de estado finito) ............................................................................................................... 33
3.1. Introducción ........................................................................................................................... 34
3.2. Operación única del RT .......................................................................................................... 34
3.2. Decisión de caja de registro ASMD ........................................................................................ 35
3.3. Máquina de Estados Finitos ................................................................................................... 37
3.3.1 Representación FSM......................................................................................................... 37
3.4.1 Descripción ASM .............................................................................................................. 37
3.5 Modelado de Hardware en VHDL ........................................................................................... 38
3.3.1 ¿Qué es Síntesis? .............................................................................................................. 39
3.3.2 Síntesis en un proceso de diseño ..................................................................................... 39
3.3.3 Los valores para Modelar Hardware ............................................................................... 39
3.3.4 FSM, Código de desarrollo en VHDL................................................................................. 40
Capítulo 4 Diseño y descripción de la implementación de una unidad de control en hardware para
ejecutar el algoritmo de entrenamiento y comparación con su equivalente en software .............. 41
4.1. Introducción ........................................................................................................................... 42
4.2. Descripción del diseño de la unidad de control .................................................................... 42
4.2.1. Puertos ............................................................................................................................ 42
4.2.2. Sistema de reloj ............................................................................................................... 42
4.2.3. Variables y registros ........................................................................................................ 44
4.2.4. Función de activación para la red neuronal .................................................................... 45
4.2.5. Máquina de estados ........................................................................................................ 45
4.2.6. Sintetizabilidad ................................................................................................................ 52
4.3. Comparación con la implementación en software. ............................................................... 52
Capítulo 5 Simulación y resultados ................................................................................................... 55
5.1. Herramientas de simulación .................................................................................................. 56
5.2 Revisión de sintaxis y sintetización. ........................................................................................ 56
5.3 Simulación con ISE Simulator .................................................................................................. 58
5.3.1 Entrenamiento del perceptrón ........................................................................................ 58
iv
5.3.1.1 Simulación de diferentes patrones de entrenamiento ................................................. 63
5.3.2. Entrenamiento de la red de retropropagación ............................................................... 68
Capítulo 6 Conclusiones y futuras posibilidades de desarrollo ......................................................... 73
6.1. Conclusiones........................................................................................................................... 74
6.2. Futuras posibilidades de desarrollo ....................................................................................... 75
Bibliografía ........................................................................................................................................ 77
Anexos ............................................................................................................................................... 79
Especificaciones generales de la familia de FPGA Spartan-3E ...................................................... 79
Código en VHDL para la red neuronal de retropropagación ......................................................... 81
Código en VHDL para el perceptrón.............................................................................................. 91
Código en C++ para la red neuronal de retropropagación ........................................................... 97
Código en C++ para el perceptrón .............................................................................................. 101
v
vi
Índice de figuras
FIGURA 1.1 UNA NEURONA ARTIFICIAL SIMPLE .............................................................................................................. 2
FIGURA 1.2 NEURONA BIOLÓGICA .............................................................................................................................. 3
FIGURA 1.3 RED DE UNA CAPA ................................................................................................................................... 6
FIGURA 1.4 RED MULTICAPA ..................................................................................................................................... 7
FIGURA 1.5 ARQUITECTURA DE LA FAMILIA SPARTAN-3E .............................................................................................. 15
FIGURA 1.6 DIAGRAMA DE INTERCONEXIÓN EN EL FPGA .............................................................................................. 16
FIGURA 2.1 RED DE UNA CAPA ADALINE ................................................................................................................. 21
FIGURA 2.2RED MULTICAPA MADALINE .................................................................................................................. 22
FIGURA 2.3 EL PERCEPTRÓN ................................................................................................................................... 24
FIGURA 2.4 ALGORITMO DE ENTRENAMIENTO RETROPROGACIÓN .................................................................................. 27
FIGURA 3.1DIAGRAMA DE BLOQUES ......................................................................................................................... 35
FIGURA 3.2DIAGRAMA DE TIEMPO ........................................................................................................................... 35
FIGURA 3.3DIAGRAMA ASM .................................................................................................................................. 36
FIGURA 3.4DIAGRAMA A BLOQUES ........................................................................................................................... 36
FIGURA 3.5 MÁQUINA DE ESTADOS FINITOS Y SU EQUIVALENTE EN DIAGRAMA ASM .......................................................... 38
FIGURA 3.6 COMPONENTES DE UNA ARQUITECTURA .................................................................................................... 38
FIGURA 4.1 OSCILADOR DE LA TARJETA DEL FPGA ....................................................................................................... 43
FIGURA 4.2 FLANCO DE SUBIDA DEL CICLO DE RELOJ ..................................................................................................... 43
FIGURA 4.3 SISTEMA DE RELOJ EN VHDL ................................................................................................................... 44
FIGURA 4.4 REGISTRO DE VARIABLE EN ESTADOS FUTURO Y PRESENTE.............................................................................. 45
FIGURA 4.5 DIAGRAMA DEL PERCEPTRÓN. ................................................................................................................. 46
FIGURA 4.6 MÁQUINA DE ESTADOS PARA EL PERCEPTRÓN ............................................................................................. 46
FIGURA 4.7 DIAGRAMA DE BLOQUES DE HARDWARE CAPAZ DE REALIZAR EL ENTRENAMIENTO DE UN PERCEPTRÓN. .................. 47
FIGURA 4.8 DIAGRAMA DE LA RED DE RETROPROPAGACIÓN ........................................................................................... 48
FIGURA 4.9 MÁQUINA DE ESTADOS PARA RETROPROPAGACIÓN...................................................................................... 49
FIGURA 4.10 COMPARACIÓN DE LAS CARACTERÍSTICAS DEL CÓDIGO PARA UNA MISMA FUNCIÓN .......................................... 54
FIGURA 5.1 SINTETIZACIÓN CORRECTA ...................................................................................................................... 56
FIGURA 5.2 IMPLEMENTACIÓN CORRECTA .................................................................................................................. 57
FIGURA 5.3 RESUMEN DE RECURSOS CONSUMIDOS Y NOTIFICACIONES ............................................................................. 57
FIGURA 5.4 SIMULACIÓN ........................................................................................................................................ 59
FIGURA 5.5 TRANSICIONES...................................................................................................................................... 60
FIGURA 5.6 ENTRENAMIENTO CONCLUIDO ................................................................................................................. 61
FIGURA 5.7 RESULTADOS DE ENTRENAMIENTO EN C++................................................................................................. 62
FIGURA 5.8 SIMULACIÓN DEL ENTRENAMIENTO COMO COMPUERTA NOR........................................................................ 63
FIGURA 5.9 ENTRENAMIENTO COMO COMPUERTA NOR EN C++.................................................................................... 64
FIGURA 5.10 ENTRENAMIENTO COMO COMPUERTA AND EN C++.................................................................................. 64
FIGURA 5.11SIMULACIÓN DEL ENTRENAMIENTO COMO COMPUERTA AND ...................................................................... 65
FIGURA 5.12 SIMULACIÓN DEL ENTRENAMIENTO COMO COMPUERTA NAND ................................................................... 66
FIGURA 5.13 ENTRENAMIENTO COMO COMPUERTA NAND EN C++ ............................................................................... 67
FIGURA 5.14 SIMULACIÓN DEL ENTRENAMIENTO DE LA RED DE RETROPROPAGACIÓN COMO COMPUERTA XOR ....................... 69
FIGURA 5.15 ENTRENAMIENTO DE LA RED DE RETROPROPAGACIÓN COMO COMPUERTA XOR EN C++ CON 5,000 ÉPOCAS ........ 70
FIGURA 5.16 ENTRENAMIENTO DE LA RED DE RETROPROPAGACIÓN COMO COMPUERTA XOR EN C++ CON 20,000 ÉPOCAS...... 70
vii
viii
Introducción
Objetivo general
Corroborar que es posible implementar en hardware el entrenamiento de una red neural

empleando lenguajes descriptores de hardware para su síntesis en un FPGA.
Objetivos específicos
 Implementar el algoritmo de entrenamiento del perceptrón

 Implementar el algoritmo de retropropagación de errores
 Programar los algoritmos en un FPGA Xilinx con el lenguaje descriptor de hardware VHDL
 Demostrar las ventajas y el alto rendimiento de la implementación en hardware.
Justificación
Las redes neuronales tienden a un procesamiento de información perteneciente a la
inteligencia artificial que busca emular el comportamiento del sistema nervioso. Se basa en las
múltiples interconexiones que se generan entre sus elementos básicos, denominados neuronas.
De esta forma, según esta interacción pueden formar diferentes tipos de arreglos para cumplir una
tarea específica.
El hecho de contar con dispositivos lógicos programables de gran tamaño y la

incorporación en ellos de poderosos bloques funcionales para el procesamiento digital, como es el
caso de las nuevas familias de FPGA, han dado lugar a nuevos diseños lógicos, destacando el
procesamiento hardware reconfigurable. Los FPGA han dejado de ser únicamente dispositivos
para el diseño de Circuitos Integrados de Aplicación Especifica (ASICs) y, han pasado a ser
verdaderas plataformas de procesamiento digital de señales.
El desarrollo tecnológico que se ha observado en los dispositivos lógicos programables,

particularmente de FPGA y su potencialidad, nos ofrecen redes neuronales artificiales con una
mayor comprensión; la manera cómo funcionan las biológicas y la generación de modelos,
arquitecturas y algoritmos con el propósito de emularlas.
ix
Las Líneas de trabajo en diferentes campos como son:
– Neurociencia Computacional y Cognición Computacional: Comunicación Neuronal; Aprendizaje y

Memoria. Procesos y Estructuras Cognitivas/Perceptivas.
– Aplicación de la Computación Neuronal en Dominios Biomédicos, Clínicos y Medioambientales
La implementación hardware es un aspecto determinante objeto de este trabajo. Esto por

dos razones, la primera reside en el hecho de que las redes neuronales de tamaño considerable en
general, y de forma particular las competitivas, necesitan tiempos prolongados para su
entrenamiento.
IMPLEMENTACIONES
SOTFWARE HARDWARE
Flexibles Eficientes
Programas con licencia FPGA (acelera las fases de ejecución)
Economicos Chips (VLSI Digital)
Biochips
VLSI analógico
Opto-Electrónicos
Portabilidad
No dependen de una computadora
Ahorro de energia
Las redes neuronales de manera inherente tienen un procesamiento masivamente

paralelo, característica que no es posible explotar en una implementación software, que es
secuencial por naturaleza. Así que acelerar el proceso de aprendizaje y aprovechar el paralelismo
inherente de las redes neuronales es una doble motivación para sus implementaciones hardware,
además de explorar la factibilidad para utilizar las redes neuronales en las diferentes etapas con
posibilidades de competir con otras técnicas, evaluar las redes en su implementación hardware, y
el entrenamiento de redes neuronales utilizando técnicas de diseño hardware-software.
x
Planteamiento del problema
Si bien la mayoría de redes neuronales artificiales están diseñadas en software y dependen
para ello de un ordenador para su entrenamiento y adaptación, en este trabajo se tiene como
objetivo demostrar el mayor aprovechamiento de la implementación en hardware del algoritmo
de entrenamiento de retropropagación (Backpropagation), por esto la importancia y la vigencia de
las implementaciones en hardware que planteamos radica en aprovechar las ventajas propias de
las redes neuronales artificiales en específico del entrenamiento de retropropagación, para las
aplicaciones que requieren un alto desempeño de ejecución, velocidad y factibilidad que nos
ofrece programarla en un FPGA con Lenguaje Descriptor de Hardware, sin depender de un
ordenador para sus etapas de entrenamiento y ejecución.
Los FPGA son dispositivos programables con una alta capacidad de integración. Estos
dispositivos están diseñados para implementaciones en hardware, en comparación con un sistema
basado en microprocesador, todo el procesamiento realizado por la red neuronal será en paralelo
y no secuencial.
Las redes neuronales se implementan tanto en hardware como en software. Ambos tipos
de desarrollo presentan un campo de acción definido, el cual depende de los requerimientos
específicos de la aplicación; por lo cual, debe ser analizada para realizar una correcta elección
Estructura del proyecto terminal

En este trabajo se analiza la implementación de redes neuronales con lenguajes
descriptores de hardware las cuales puedan realizar su entrenamiento dentro de un FPGA para
observar las ventajas que ofrece la implementación de redes neuronales en hardware sobre la
implementación en software.
En el capítulo 1 se mencionan las bases teóricas del área que comprende el estudio de las
redes neuronales artificiales, sus principios de operación, sus analogías, arquitecturas básicas y
tipos de entrenamiento.
En el capítulo 2 se profundiza de manera más concreta a las bases de los algoritmos de
entrenamiento y reglas de aprendizaje de algunos tipos básicos de redes neuronales, en especial a
2, el perceptrón y la red de retropropagación del error.
En el capítulo 3 se mencionan algunas de las características del lenguaje descriptor de
hardware VHDL, así como la forma en la que sus características se acoplan a la implementación de
los algoritmos de entrenamiento de redes neuronales.
En el capítulo 4 se explica la manera en la que se logró la implementación de los
algoritmos de entrenamiento por medio del diseño de una unidad de control descrita en VHDL, así
como su comparación con su equivalente implementación en software con C++.
En el capítulo 5 se muestran los resultados de las simulaciones obtenidas de los algoritmos
de entrenamiento implementados en VHDL y se comparan los resultados con su equivalente
programa de entrenamiento en software con C++.
En el capítulo 6 se mencionan las conclusiones y las futuras posibilidades de desarrollo
para la implementación de redes neuronales en hardware.
xi
xii
Marco Teórico. 1
Capítulo 1 Marco Teórico.
1
Marco Teórico. 2
1.1. Redes Neuronales Artificiales
1.1.1. Principios básicos de las Redes Neuronales
Una red neuronal artificial es un sistema que procesa información cuenta con ciertas
características de desempeño con las redes neuronales biológicas en común. Las redes neuronales
artificiales han sido desarrolladas como modelos matemáticos de la cognición humana, en común
basado en los siguientes supuestos:
 El procesamiento de información se lleva a cabo en muchos elementos simplemente llamados

neuronas.
 Las señales son enviadas a las neuronas a través de conexiones.
 Cada conexión tiene un peso asociado, el cual, en una red neural típica, multiplica la señal
transmitida.
 Cada neurona aplica una función de activación (usualmente no lineal) a la entrada de su red
para determinar su señal de salida,
Una red neural está caracterizada por el patrón de conexión entre las neuronas (llamado
arquitectura), el método para determinar el peso de las conexiones (llamado entrenamiento,
aprendizaje o algoritmo) y la función de activación.
Una red neuronal consiste en un gran número de elementos simples de procesamiento

llamados neuronas, unidades, células o nodos. Cada neurona está conectada a otras neuronas por
medios directos de comunicación, enlaces a los cuales se les asocia un peso. El peso representa la
información que la red utiliza para resolver un problema. Las redes neurales pueden ser aplicadas
a la resolución de varios problemas tales como reconocer datos o patrones, agrupando patrones
similares, realizando mapeos generales desde los patrones de entrada a los de salida, agrupando
patrones similares o encontrando soluciones a problemas delimitados de optimización.
Cada neurona cuenta con un estado interno, llamado nivel de activación, el cual es
recibido en la entrada por una función. Usualmente, una neurona envía su nivel de activación
como una señal a una o varias neuronas, por ejemplo, consideremos la neurona Y de la Figura 1.1
que recibe las entradas X1, X2 y X3 en la neurona Y y sus pesos respectivos en las conexiones son
W1, W2 y W3. [1]
Figura 1.1 Una neurona artificial simple
2
Marco Teórico. 3
Hay una analogía cercana entre las estructuras de las redes neurales artificiales y las
biológicas. Una neurona biológica tiene tres tipos de componentes: Dendritas, axón y núcleo. Las
diferentes dendritas reciben señales de otras neuronas. Las señales son impulsos eléctricos que
son transmitidos a lo largo de la brecha sináptica por medio de procesos químicos. La acción de los
químicos modifica la señal en una manera similar a la que el peso de la conexión de una red neural
artificial lo hace. [1]
El núcleo de la neurona suma las señales entrantes. Cuando se reciben suficientes señales
la neurona se dispara, eso significa que transmite una señal sobre el axón a las otras neuronas.
Se puede resumir que las características las neuronas biológicas fueron sugeridas para las redes
neurales artificiales a partir de:
 El elemento procesador recibe varias señales

 Las señales son modificadas por una ganancia de la conexión
 El elemento procesador suma las entradas modificadas por sus respectivas ganancias
 Bajo circunstancias apropiadas la neurona transmite una sola salida
 La salida de una neurona puede ir hacia varias otras neuronas
En la Figura 1.2 se puede observar un ejemplo de una neurona biológica.
Figura 1.2 Neurona biológica
1.1.2. Aplicaciones de las redes neuronales
Las características especiales de los sistemas de computación neuronal modernos

permiten que sea utilizada esta nueva técnica de cálculo en una extensa variedad de aplicaciones.
[10]
La computación neuronal provee un acercamiento mayor al reconocimiento y percepción

humana que los métodos tradicionales de cálculo. Las redes neuronales artificiales presentan
resultados razonables en aplicaciones donde las entradas presentan ruido o las entradas están
incompletas. Algunas de las áreas de aplicación de las ANN son las siguientes:
3
Marco Teórico. 4
 Análisis y Proceso de señales

 Reconocimiento de Imágenes
 Control de Procesos
 Filtrado de ruido
 Robótica
 Procesado del Lenguaje
 Diagnósticos médicos
 Otros
Conversión Texto a Voz: uno de los principales promotores de la computación neuronal en

esta área es Terrence Sejnowski. La conversión texto-voz consiste en cambiar los símbolos gráficos
de un texto en lenguaje hablado. El sistema de computación neuronal presentado por Sejnowski y
Rosemberg, el sistema llamado NetTalk, convierte texto en fonemas y con la ayuda de un
sintetizador de voz (Dectalk) genera voz a partir de un texto escrito.
La ventaja que ofrece la computación neuronal frente a las tecnologías tradicionales en la

conversión texto-voz es la propiedad de eliminar la necesidad de programar un complejo conjunto
de reglas de pronunciación en el ordenador. A pesar de que el sistema NetTalk ofrece un buen
comportamiento, la computación neuronal para este tipo de aplicación abre posibilidades de
investigación y expectativas de desarrollo comercial.
Procesado Natural del Lenguaje: incluye el estudio de cómo se construyen las reglas del
lenguaje. Los científicos del conocimiento Rumelhart y McClelland han integrado una red neuronal
de proceso natural del lenguaje. El sistema realizado ha aprendido el tiempo verbal pass tense de
los verbos en Inglés. Las características propias de la computación neuronal como la capacidad de
generalizar a partir de datos incompletos y la capacidad de abstraer, permiten al sistema generar
buenos pronósticos para verbos nuevos o verbos desconocidos.
Compresión de Imágenes: la compresión de imágenes es la transformación de los datos de

una imagen a una representación diferente que requiera menos memoria o que se pueda
reconstruir una imagen imperceptible. Cottrel, Munro y Zisper de la Universidad de San Diego y
Pisttburgh han diseñado un sistema de compresión de imágenes utilizando una red neuronal con
un factor de compresión de 8:1.
Reconocimiento de Caracteres: es el proceso de interpretación visual y de clasificación de

símbolos. Los investigadores de Nestor, Inc. han desarrollado un sistema de computación neuronal
que tras el entrenamiento con un conjunto de tipos de caracteres de letras, es capaz de
interpretar un tipo de carácter o letra que no haya visto con anterioridad.
Reconocimiento de Patrones en Imágenes: una aplicación típica es la clasificación de

objetivos detectados por un sonar. Existen varias ANN basadas en Retropropagación cuyo
comportamiento es comparable con el de los operadores humanos. Otra aplicación normal es la
inspección industrial.
Problemas Combinatorios: en este tipo de problemas con solución mediante cálculo

tradicional requiere un tiempo de proceso (CPU) que es exponencial con el número de entradas.
4
Marco Teórico. 5
Este tipo de problema ha sido abordado con éxito por Hopfield y el resultado de su trabajo ha sido
el desarrollo de una ANN que ofrece buenos resultados para problemas combinatorios.
Procesado de la Señal: en este tipo de aplicación existen tres clases diferentes de

procesado de la señal que han sido objeto de las ANN como son la predicción, el modelado de un
sistema y el filtrado de ruido.
Predicción: en el mundo real existen muchos fenómenos de los que conocemos su

comportamiento a través de una serie temporal de datos o valores
Modelado de Sistemas: los sistemas lineales son caracterizados por la función de

transferencia que no es más que una expresión analítica entre la variable de salida y una variable
independiente y sus derivadas. Las ANN también son capaces de aprender una función de
transferencia y comportarse correctamente como el sistema lineal que está modelando.
Filtro de Ruido: las ANN también pueden ser utilizadas para eliminar el ruido de una señal.
Estas redes son capaces de mantener en un alto grado las estructuras y valores de los filtros
tradicionales.
Modelos Económicos y Financieros: una de las aplicaciones más importantes del modelado
y pronóstico es la creación de pronósticos económicos como por ejemplo los precios de
existencias, la producción de las cosechas, el interés de las cuentas, el volumen de las ventas etc.
Las redes neuronales están ofreciendo mejores resultados en los pronósticos financieros que los
métodos convencionales.
Servo Control: un problema difícil en el control de un complejo sistema de

servomecanismo es encontrar un método de cálculo computacional aceptable para compensar las
variaciones físicas que se producen en el sistema. Entre los inconvenientes destaca la
imposibilidad en algunos casos de medir con exactitud las variaciones producidas y el excesivo
tiempo de cálculo requerido para la obtención de la solución matemática. Existen diferentes redes
neuronales que han sido entrenadas para reproducir o predecir el error que se produce en la
posición final de un robot. Este error se combina con la posición deseada para proveer una
posición adaptativa de corrección y mejorar la exactitud de la posición final. [10]
1.1.3 Arquitecturas típicas de las redes neuronales
Usualmente es conveniente mirar a las neuronas organizadas en capas. Típicamente las

neuronas ubicadas en las misma capa se comportan de manera similar por lo que usualmente
tienen la misma función de activación y el mismo patrón de conexión hacia las otras neuronas,
también pueden haber interconexiones de neuronas que pertenezcan a diferentes capas.[1]
5
Marco Teórico. 6
1.1.3.1. Redes de una capa
Una red de una capa tiene una capa de pesos, una de conexiones y una de salidas.
Usualmente, las unidades pueden ser distinguidas como unidades de entrada, las cuales reciben
señales del mundo exterior y como unidades de salida, de las cuales, la respuesta de la red puede
ser leída. En la típica red de una capa, las unidades de entrada están totalmente conectadas a las
unidades de salida pero no están conectadas a otras unidades de entrada, tampoco las unidades
de salida están conectadas a otras unidades de salida como se muestra en la Figura 1.3.[1]
Figura 1.3 Red de una capa
1.1.3.2 Redes multicapa
Es una red con más de una capa y nodos entre las unidades de entrada y salida. Las redes
multicapa pueden resolver problemas más complejos que las redes de una capa pero el
entrenamiento de estás es más difícil. Sin embargo ocasionalmente el entrenamiento de una red
multicapa puede ser más exitoso para resolver un problema complejo ya que es posible que una
red monocapa no podría ser entrenada correctamente. [1]
Las redes multicapa son aquellas que disponen de conjuntos de neuronas agrupadas en
varios niveles o capas. Normalmente, todas las neuronas de una capa reciben señales de entrada
de otra capa anterior, más cercana a la entrada de la red. A estas conexiones se les denomina
conexiones hacia adelante o feedforrward.
Sin embargo, en un gran número de estas redes también existe la posibilidad de conectar
las salidas de las neuronas de capas posteriores a las entradas de las capas anteriores, a estas
conexiones se les denomina conexiones hacia atrás o feedback.
6
Marco Teórico. 7
Figura 1.4 Red multicapa
7
Marco Teórico. 8
Tabla 1-1 Redes neuronales multicapa más conocidas
N. DE CAPAS TIPOS DE CONEXIONES MODELO DE RED
ADALINE/MADALINE
PERCEPTRON
LINEAR/ASSOC REWART PENALITY
CONEXIONES HACIA LINEAR/ASSOCOIATIVE MEMORY
DELANTE FEEDFORWARD OPTIMAL LINEAR ASSOC MEM.
DRIVE-REINFORCEMENT (DR)
CONEXIONES LATERALES LEARNIG VECTOR QUANTIZER
2 CAPAS
IMPLICITAS Y AUTORREC. TOPOLOGY PRESERVING MAR (TPM)
BIDIRECTIONAL ASSOC MEM. (BAM)
ADAPTIVE BAM
CONEXIÓN ADELANTE- SIN CONEXIONES LATERALES
TEMPORAL ASSOC MEMORY (TAM)
ATRÁS
FUZZY ASSOCIATIVE MEMORY (FAM)
FEEDFORWARD/FEEDBACK
CON CONEXIONES COMPETTITIVE ADAPTIVE BAM
LATERALES Y AUTOCORREC. ADAPTIVE RESSONANCE THEORY (ART)
ADAPTIVE HEURISTIC CRITIC (AHC)
CONEXIONES HACIA SIN CONEXIONES LATERALES
BOLTZMANN/CAUCHY MACHINE
ADELANTE
CON CONEXIONES COUNTERPROPAGATION
3 (FEEDFORWARD)
LATERALES BOLTZMANN/CAUCHY MACHINE
CONEXIONES ADELANTE Y LATERALES BOLTZMANN/CAUCHY MACHINE
CONEXIONES HACIA ADELANTE BACK-PROPAGATION (BPN)
FEEDFORWARD-FEEDBACK JERARQUIA DE NIVELES DE
N COGNITRON/NEOCOGNITRON
CAPAS BIDEMENCIONALES
1.1.4. Mecanismos de Aprendizaje
El aprendizaje es el proceso por el cual una red neuronal modifica sus pesos en respuesta a
la información de entrada. Los cambios que se producen durante el proceso de aprendizaje se
reducen a la destrucción, modificación y creación de conexiones entre neuronas. En los sistemas
biológicos existe una continua creación y destrucción de conexiones. En los modelos de redes
neuronales artificiales, la creación de una nueva conexión implica que el peso de la misma pasa a
tener un valor distinto de cero. De la misma forma, una conexión se destruye cuando un peso pasa
a ser cero.
Durante el proceso de aprendizaje, los pesos de las conexiones en la red sufren

modificaciones, por lo tanto se puede afirmar que este proceso ha terminado (la red ha
aprendido) y cuando los valores de los pesos permanecen estables (dwij /dt=0).
8
Marco Teórico. 9
Un aspecto importante respecto al aprendizaje en redes neuronales es conocer cómo se

modifican los valores en los pesos; es decir, cuales son los criterios que se rigen para cambiar el
valor asignado a las conexiones cuando se pretende que la red aprenda nueva información.
Estos criterios determinan lo que se conoce como la regla de aprendizaje de la red. De

forma general, suelen generar dos tipos de reglas: habitualmente se le conoce como aprendizaje
supervisado y aprendizaje no supervisado.
Es por ello que una de las clasificaciones por las que se realizan las redes neuronales
obedece al tipo de aprendizaje utilizado por dichas redes. Así se pueden distinguir:
 Redes Neuronales con aprendizaje supervisado.

 Redes Neuronales con aprendizaje no supervisado.
La diferencia fundamental entre ambos tipos estriba en la existencia o no de un agente

externo (supervisor) que controle el proceso de aprendizaje en la red.
Otro criterio que se puede utilizar para diferenciar las reglas de aprendizaje se basa en
considerar si la red puede aprender durante su funcionamiento habitual o si el aprendizaje supone
la desconexión de la red; es decir su inhabilitación hasta que el proceso termine. En el primer caso,
se trataría de un aprendizaje ON LINE, mientras que el segundo se conoce como aprendizaje OFF
LINE.
Cuando el aprendizaje es OFF LINE se distingue entre una frase de aprendizaje o de

entrenamiento y una fase de operación o funcionamiento, existiendo un conjunto de datos de
entrenamiento y un conjunto de datos de prueba que serán utilizados en la correspondiente fase.
En las redes con Aprendizaje OFF LINE, los pesos de las conexiones permanecen fijos después que
termina la etapa de entrenamiento de la red. Debido a su carácter estático, estos sistemas no
presentan problemas de estabilidad en su funcionamiento.
En las Redes con aprendizaje ON LINE no se distingue entre fase de entrenamiento y de

operación, de tal forma que los pesos varían dinámicamente siempre que se presente nueva
información al sistema. En este tipo de redes, debido al carácter dinámico de las mismas, el
estudio de la estabilidad es un aspecto fundamental. [13]
9
Marco Teórico. 10
Tabla 1-2 Tipos de redes con aprendizaje supervisado más conocidas
TIPO DE APRENDIZAJE SUPERVIZADO MODELO DE RED
PERCEPTRON
APRENDIZAJE POR ADALINE/MADALINE
OFF LINE
CORRECCIÓN DE ERROR BACK-PROPAGATION (BPN)
COUNTERPROPAGATION
LINEAR REWART PENALTY
APRENDIZAJE POR
ON LINE ASSOCIATIVE REWART PENALTY
REFUERZO
ADAPTIVE HEURISTIC CRITIC (AHC)
APRENDIZAJE BOLTZMANN MACHINE
OFF LINE
ESTOCASTICO CAUCHY MACHINE
Tabla 1-3 Tipos de redes con aprendizaje no supervisado más conocidas
TIPO DE APRENDIZAJE NO SUPERVIZADO MODELO DE RED
HOPFIELD
LEARNING MATRIX
LINEAR ASSOCIATIVE MEMORY (LAM)
OFF LINE
OPTIMAL LAM
DRIVE-REINFORCEMENT
APRENDIZAJE HEBBIANO
FUZZY ASSOCIATIVE MEMORY (FAM)
ADDITIVE GROSSBERG
SHUNTING GROSSBERG
ON LINE
BIDIRECTIONAL ASSOC MEM. (BAM)
ADAPTIVE BAM
LEARNING VECTOR QUANTIZER
APRENDIZAJE
COGNITRON/NECOGNITRON
COMPETITIVO
OFF LINE TOPOLOGY PRESERVING MAP
/COOPERATIVO
ON LINE ADAPTIVE RESONANCE THEORY
10
Marco Teórico. 11
1.1.5. Entrenamiento de las redes neuronales artificiales
Una de las principales características de las RNA es su capacidad de aprendizaje. El

entrenamiento de RNA muestra algunos paralelismos con el desarrollo intelectual de los seres
humanos. No obstante aun cuando parece que se ha conseguido entender el proceso de
aprendizaje conviene ser moderado porque el aprendizaje de las RNA está limitado.
El objetivo del entrenamiento de una RNA es conseguir una aplicación determinada, para
un conjunto de entradas produzca el conjunto de salidas deseadas o mínimamente consistentes. El
proceso de entrenamiento consiste en aplicación de diferentes conjuntos o vectores de entrada
para que se ajusten los pesos de las interconexiones según un procedimiento predeterminado.
Durante la sesión de entrenamiento los pesos convergen gradualmente hacia los valores que
hacen que cada entrada produzca el vector de salida deseado.
Los algoritmos de entrenamiento o los procedimientos de ajuste de los valores de las

conexiones de las RNA se pueden clasificar en dos grupos: Supervisado y No Supervisado.
Entrenamiento Supervisado: Estos algoritmos requieren el emparejamiento de cada vector

de entrada con su correspondiente vector de salida. El entrenamiento consiste en presentar un
vector de entrada a la red, calcular la salida de la red, compararla con la salida deseada, y el error
o diferencia resultante se utiliza para realimentar a la red y cambiar los pesos de acuerdo con el
algoritmo que tiende a minimizar el error.
Las parejas de vectores del conjunto de entrenamiento se aplican secuencialmente y de

forma cíclica. Se calcula el error y el ajuste de los pesos por cada pareja hasta que el error para el
conjunto de entrenamiento entero sea un valor pequeño y aceptable.
Entrenamiento No Supervisado: Los sistemas neuronales con entrenamiento supervisado

han tenido éxito en muchas aplicaciones y sin embargo tienen muchas críticas debido a que desde
el punto de vista biológico no son muy lógicos. Resulta difícil creer que existe un mecanismo en el
cerebro que compare las salidas deseadas con las salidas reales. En el caso de que exista, ¿de
dónde provienen las salidas deseadas?
Los sistemas no supervisados son modelos de aprendizaje más lógicos en los sistemas
biológicos. Desarrollados por Kohonen en 1984 y otros investigadores, estos sistemas de
aprendizaje no supervisado no requieren de un vector de salidas deseadas y por tanto no se
realizan comparaciones entre las salidas reales y salidas esperadas. El conjunto de
El algoritmo de entrenamiento modifica los pesos de la red de forma que produzca

vectores de salida consistentes. El proceso de entrenamiento extrae las propiedades estadísticas
del conjunto de vectores de entrenamiento y agrupa en clases los vectores similares.
11
Marco Teórico. 12
1.1.6. El Perceptrón
El Perceptrón [3] fue la primera red neuronal artificial. Era computacionalmente factible
sobre el hardware de aquella época, estaba basada en modelos biológicos y era capaz de
aprender. Desafortunadamente también sufría de importantes debilidades: la inhabilidad de
aprender a realizar una importante clasificación de tareas. Sin embargo, comentar sobre eta red
puede contribuir a entender cercanamente redes relacionadas las cuales son inmensamente
prácticas.
Rosenblatt propuso varias variaciones del Perceptrón pero la más sencilla consiste de tres
capas. La primera es una entrada “retina”. Está conectada a una segunda capa, compuesta de lo
que él llamo “unidades de asociación”, las cuales actúan como detectores de caracteres, esta capa
finalmente se conecta a una capa de salida. Las unidades (neuronas) en su modelo producen una
salida que es una suma la cual tiene un umbral con un peso, de sus entradas. [3]
1.1.7. Implementación y tecnologías emergentes
El resurgimiento de la computación neuronal en los últimos años se ha producido por el

desarrollo teórico de nuevos modelos matemáticos del comportamiento del cerebro y por el
desarrollo de nuevas tecnologías que ya están siendo utilizadas en una gran variedad de
aplicaciones comerciales.
Entre los avances o desarrollos tecnológicos que permiten la realización de la computación

neuronal destacan los programas de simulación software, los aceleradores en los chips de silicio y
los procesadores ópticos hardware.
Simuladores Software: constituyen una de las formas más versátiles con las que se pueden
implementar redes neuronales. Estos programas constituyen todo un sistema de desarrollo para
prototipos de Redes Neuronales. Estos programas se utilizan para diseñar, construir, entrenar y
probar Redes neuronales artificiales para resolver problemas complejos y problemas del mundo
real.
Los primeros simuladores software se ejecutaban en ordenadores grandes con
demasiados recursos pero el avance de los ordenadores personales en capacidad de procesado y
capacidad de memoria hace posible que exista una serie de simuladores software de grandes
prestaciones que corren sobre ordenadores personales. Entre otros paquetes software se incluye
Neural Works, Neuralyst, Explore Net y Kwowledge Net.
Aceleradores Hardware: la naturaleza paralela de la computación neuronal se presta a

realizar diseños concretos y a medida de dispositivos físicos, aceleradores hardware, que aceleren
la ejecución de los cálculos. Los aceleradores hardware para los sistemas de computación
neuronal son dispositivos físicos constituidos por diferentes procesadores interconectados que
ayudan a la compilación y ejecución del comportamiento de las ANN. Una de las ventajas de los
aceleradores hardware diseñados específicamente para la computación neuronal es el aumento
de la velocidad de procesado. Esta característica permite utilizar las ANN en aplicaciones de
tiempo real.
12
Marco Teórico. 13
Robert Hecht-Nielsen desarrolló el acelerador Mark III hardware que constaba de 8100
procesadores y trabajaba como un periférico de un VAX. La mayoría de las casas comerciales
dedicadas al diseño de las ANN han desarrollado diferentes tarjetas basadas en los diferentes
procesadores existentes, diseñadas para trabajar en el entorno de un ordenador personal PC y
presentando un progresivo ratio de actualizaciones e interconexiones por segundo.
Chips de Silicio: Otro de los campos de la investigación en el mundo de las ANN al margen
de los simuladores software y aceleradores hardware, es la integración de todos los componentes
de computación neuronal en un chip de silicio. Un ejemplo concreto es el chip Electronic Neural
Network (EEN) de la compañía AT&T que contiene 256 transistores-neuronas y más de 100.000
resistencias-sinapsis. Actualmente este chip se está utilizado para aplicaciones de compresión del
ancho de banda de imágenes de vídeo para poder ser transmitidas por una línea telefónica.
Existen muchas compañías y centros de investigación que están trabajando en el desarrollo de
circuitos integrados diseñados para computación neuronal. La mayoría de las aplicaciones de estos
chips son la simulación de procesos sensitivos como; visión de imágenes y la audición de sonidos.
1.2. Implementación en dispositivos programables
1.2.1. Dispositivo lógico programable FPGA
Un Dispositivo Lógico Programable (Programmable Logic Device, PLD) es un chip de

propósito general para la implementación de circuitos lógicos. Contiene un conjunto de elementos
lógicos agrupados de diversas maneras. Puede ser visto como una “caja negra” que contiene
compuertas lógicas e interruptores programables, los cuales permiten a las compuertas
conectarse entre sí para formar cualquier circuito lógico requerido [5].
Se clasifican según el grado de complejidad y cantidad de recursos lógicos presentes en el

dispositivo. Así, existen SPLD (Simple PLD), dentro de los cuales están los PLA (Programmable Logic
Array), PAL (Programmable Array Logic), PLA/PAL Registradas (Registered PLA/PAL), GAL (Generic
PAL); CPLD (Complex PLD); FPGA (Field-Programmable Gate Array) [5].
Dentro de este contexto, un FPGA (Arreglo de puertas programables en campo) es un PLD

que soporta implementaciones de circuitos lógicos y sistemas digitales relativamente grandes y
son programables en campo, es decir, es el lugar del diseño junto al diseñador. Presenta una
arquitectura virgen, la cual puede ser configurada a necesidad, logrando una gran diversidad de
aplicaciones. El almacenamiento de estas conexiones se realiza en una SRAM en la mayoría de los
casos, pero también puede realizarse mediante FLASH o antifuse [5].
13
Marco Teórico. 14
1.2.2. Arquitectura genérica
Básicamente, un FPGA contiene bloques lógicos, recursos de interconexión y unidades de

entrada y salida [5].
Los bloques lógicos están conformados por tablas de verdad (Look-Up Table, LUT), la cual
es un circuito programable que permite implementar cualquier función lógica de un número
determinado de entradas, por flip-flops y multiplexores.
Para controlar las conexiones necesarias entre los bloques lógicos los recursos de
interconexión y las unidades de entrada-salida se programan dichas conexiones mediante técnicas
de programación con la tecnología de celdas SRAM.
Adicionalmente puede contar con elementos adicionales y bloques dedicados como

memorias, PLL, multiplicadores, MAC, DSP, microprocesadores; todo esto según el FPGA.
1.2.3. Descripción de la arquitectura
La arquitectura de la familia Spartan-3E se compone de cinco elementos funcionales y

fundamentales programables. [5]
• Bloques lógicos configurables (CLB) contienen flexibles tablas de consulta (LUT) que
implementan la lógica más elementos de almacenamiento utilizados como flip-flops.
CLBs realizar una amplia variedad de funciones lógicas, así como almacenado de datos.
• Bloques de Entradas / Salidas (IOBs) que controlan el flujo de datos entre los pines de
E / S y lógica interna del dispositivo. Cada IOB apoya el flujo bidireccional de datos más 3
estados de operación. Soportan una gran variedad de señales, entre ellos cuatro de alto
rendimiento diferencial.
Doble velocidad de datos (DDR) de los registros:
• Bloques RAM proporciona almacenamiento de datos en forma de bloques

de doble puerto 18-Kbit.
• Los bloques multiplicadores aceptan dos números binarios de 18 bits

y calculan el producto.
• Administrador de Reloj Digital (DCM) provee bloques de auto-calibración, soluciones

totalmente digitales para distribuir, retrasar, multiplicar, dividir el cambio de fase en el
reloj.
14
Marco Teórico. 15
Estos elementos están organizados como se muestra en la ilustración 1. Un anillo IOBs

rodea de una serie regular de CLB. Cada dispositivo tiene dos columnas bloques RAM, excepto
para el XC3S100E, que tiene una columna. Cada columna RAM se compone de varios bloques RAM
18-Kbit.Cada bloque de RAM está asociado con un multiplicador. Las MCD se colocan en el centro
con dos en la parte superior y dos en la parte inferior del dispositivo. La XC3S100E tiene sólo un
DCM en la parte superior e inferior, mientras el XC3S1200E y el XC3S1600E añade dos MCDs a
cada extremo.
La familia Spartan-3E Figura 1.5 cuenta con una amplia red de registros que interconectar
los cinco elementos funcionales, la transmisión de señales entre ellos. Cada elemento funcional
tiene asociado una matriz de conmutación que permite múltiples conexiones de enrutamiento
Figura 1.6[12]
Figura 1.5 Arquitectura de la familia Spartan-3E
15
Marco Teórico. 16
Figura 1.6 Diagrama de interconexión en el FPGA
1.2.4. Lenguaje de descripción de hardware VHDL
Es un Lenguaje de Descripción de Hardware (HDL: Hardware Description Language) que describe

el comportamiento de un circuito o sistema electrónico cuyo circuito o sistema físico (real) puede
ser implementado en el dispositivo respectivo.
Es utilizado principalmente, junto con Verilog, para implementar circuitos en FPGA’s, CPLD´s y en
el campo de los ASIC’s, siendo este diseño portable y reusable.
Cabe mencionar que las sentencias VHDL son inherentemente concurrentes, es decir, se ejecutan
simultáneamente. Solamente las que se encuentren dentro de procesos, funciones o procesos son
ejecutados de manera secuencial.
Para realizar esta labor, se utilizan las denominadas herramientas EDA (Electronic Design
Automation) creadas especialmente para las tareas de síntesis, implementación y simulación de
16
Marco Teórico. 17
circuitos descritos. Algunas son ofrecidas dentro de los entornos de desarrollo de los fabricantes
(Quartus II, MAXPLUS II, ISE) mientras que otros son desarrollados y ofrecidos por compañías EDA
especializadas como Leonardo Spectrum (sintetizador de Mentor Graphics). [5]
17
Marco Teórico. 18
18
Algoritmos de entrenamiento Perceptrón y de Retropropagación (Backpropagation) 19
Capítulo 2 Algoritmos de
entrenamiento Perceptrón y de
Retropropagación
(Backpropagation)
19
2.1 Introducción
En este capítulo examinaremos un grupo de redes neuronales que tienen una arquitectura
similar. Este es el grupo de las redes con conexiones hacia adelante, las cuales se caracterizan por
arquitecturas en niveles y conexiones estrictamente hacia adelante entre neuronas. Estas redes
son todas buenas clasificadoras de patrones y utilizan aprendizaje supervisado.
En este grupo se incluyen el Perceptrón, las redes ADALINE y MADALINE y la red

Backpropagation. El Perceptrón y las redes ADALINE y MADALINE tiene un importante interés
histórico y han abierto el camino para el desarrollo de otras redes neuronales. Por otro lado, la red
Back-Propagation es probablemente una de las más utilizadas hoy en día. [13]
2.1. Las Redes ADALINE y MADALINE
Las redes ADALINE (ADAptive LINear Element) ver Figura 2.1 y MADALINE (Múltiple
ADALINE) ver Figura 2.2 fueron desarrollados por Bernie Widrow [Widrow 60] en la Universidad
de Stanford poco después de que Rosenblatt desarrollara el Perceptrón. La red ADALINE está
limitada a una única neurona de salida, mientras que MADALINE puede tener varias. [13]
20
Figura 2.1 Red de una Capa ADALINE
21
Figura 2.2Red multicapa MADALINE
22
ADALINE y MADALINE utilizan la denominada regla Delta de Hidrow-Hoff o regla del

mínimo error cuadrado medio (LMS), basada en la búsqueda del mínimo de una expresión del
error entre la salida deseada y la salida lineal obtenida antes de aplicarle la función de activación
escalón (frente a la salida binaria utilizada en el caso del Perceptrón). Debido a esta nueva forma
de evaluar error, estas redes pueden procesar información analógica, tanto de entrada como de
salida, utilizando una función de activación lineal o sigmoidal.
Tabla 2-1 Funciones de activación o de transferencia
23
2.2. Perceptrón
Perceptrón formado por varias neuronas de lineales para recibir las entradas a la red y una
entrada de salida, es capaz de decidir cuando una entrada presentada a lared pertenece a una de
las dos clases que es capaz de reconocer.
La única neurona de salida del Perceptrón realiza la suma ponderada de las entradas, resta
el umbral y pasa el resultado a una función de transferencia de tipo escalón.
Figura 2.3 El Perceptrón
La regla de decisión es pertenecer +1 si el patron presentado pertenece a la clase A, o -1 si

el patrón pertenece a la clase B. La salida dependerá de la entrada neta (suma de las entradas x1
ponderadas) y del valor umbral 0.
Sin, embargo , el Perceptrón , al constar sólo de una capa de entrada y otra de salida con
una única neurona, tiene una capacidad de representación bastante limtada. Este modelo solo es
capaz de discriminar patrones muy sencillos, linealmente separables. El caso más conocido es la
imposibildad del Perceptrón de representar la función OR-EXCLUSIVA.
24
El algoritmo de aprendizaje del perceptrón es de tipo supervizado, lo cual requiere que sus
resultados sean evaluados y se realicen las oportunas modificaciones del sistema si fuera
necesario.
Se pueden usar Perceptrones como maquinas de universales de aprendizaje.

Desgraciadamente , no puede aprender a realizar todo tipo de clasificaciones: en realidad solo
puede aprender clasificaciones faciles (problemas de orden 1). Esa limitación se debe a que un
Perceptrón usa un separador lineal como celula de decición, con lo cual no es posible realizar sino
una sola separación lineal (por medio de un hiperplano).
2.3. Algoritmo de entrenamiento Perceptrón
El proceso de entrenamiento, el Perceptrón se expone a un conjunto de patrones de

entrada, y los pesos de la red son ajustados de forma que al final del entrenamiento se obtengan
las salidas esperadas para cada uno de esos patrones de entrada.
A continuación veremos el algoritmo de convergencia de ajuste de pesos para realizar el

aprendizaje de un Perceptrón (aprendizaje por corrección de error) con N elementos procesales de
entrada y un único elemento procesal de salida:
1.- Inicialización de los pesos y del umbral:
Inicialmente se asignan valores aleatorios a cada uno de los pesos (wi) de las conexiones y
al umbral (-w0=0).
2.- Presentación de un nuevo par (Entrada, Salida esperada):
Presentar un nuevo patrón de entrada Xp = (x1, x2,…, xN) junto con la salida esperada
d(t).
3.- Calculo de la salida actual:
Y(t) = f[∑i wi (t) xi(t) - 0]
Siendo f(x) la función de transferencia escalón.
25
4.- Adaptación de los pesos:
wi(t+1)= wi (t)+α[d(t)-y(t)]xi(t)
(0≤i≤N)
Donde d(t) representa la salida deseada, y será 1 si el patrón pertenece a la clase A, y -1 es la clase
B. En estas ecuaciones, α es un factor de ganancia en el rango 0.0 a 1.0. [13]
2.4. Red de Retroprogación (Backpropagation)
En 1986, Rumelhart, Hinton y Williams, formalizaron un método para que una red
neuronal aprendiera la asociación que existe entre los patrones de entrada y las clases
correspondientes, utilizando varios niveles de neuronas.
El método backpropagation (propagación del error hacia atrás), basado en la

generalización de la regla delta, a pesar de sus limitaciones, ha ampliado de forma considerable el
rango de aplicaciones de las redes neuronales.
El funcionamiento de la red backpropagation (BPN) consiste en el aprendizaje de un

conjunto predefinido de pares de entradas-salidas dados como ejemplo: primero se aplica un
patrón de entrada como estímulo para la primera capa de las neuronas de la red, se va
propagando a través de todas las capas superiores hasta generar una salida, se compara el
resultado en las neuronas de salida con la salida que se desea obtener y se calcula un valor de
error para cada neurona de salida. A continuación, estos errores se transmiten hacia atrás,
partiendo de la capa de salida hacia todas las neuronas de la capa intermedia que contribuyan
directamente a la salida.
Este proceso se repite, capa por capa, hasta que todas las neuronas de la red hayan
recibido un error que describa su aportación relativa al error total. Basándose en el valor del error
recibido, se reajustan los pesos de conexión de cada neurona, de manera que en la siguiente vez
que se presente el mismo patrón, la salida esté más cercana a la deseada [16][18][19].
La importancia de la red backpropagation consiste en su capacidad de autoadaptar los

pesos de las neuronas de las capas intermedias para aprender la relación que existe ente un
conjunto de patrones de entrada y sus salidas correspondientes. Es importante la capacidad de
generalización, facilidad de dar salidas satisfactorias a entradas que el sistema no ha visto nunca
en su fase de entrenamiento. La red debe encontrar una representación interna que le permita
generar las salidas deseadas cuando se le dan entradas de entrenamiento, y que pueda aplicar,
además, a entradas no presentadas durante la etapa de aprendizaje para clasificarlas. [19][20]
26
Figura 2.4 Algoritmo de Entrenamiento Retroprogación
2.4.1 Regla Delta generalizada
La regla por Widrow en 1960 (regla delta) a sido extendida con redes con capas
intermedias (regla Delta Generalizada) con conexiones hacia adelante (feedforward) y cuyas
células tienen funciones de activación continuas (lineales o sigmoidales), dando lugar al algoritmo
de retropropagación (backpropagation). Estas funciones continuas son no decresientes y
derivables. [13]
La función sigmoidal pertenece a este tipo de funciones, a diferencia de la función escalón

que se utiliza para el Perceptrón, ya que esta última no es derivable en el punto que se encuentra
la discontinuidad.
Este algoritmo utiliza también una función o superficie de error asociada a la red,
buscando el estado estable de mínima energía o de mínimo error a través del camino descendente
27
de la superficie del error. Por ello, realimenta el error del sistema para realizar la modificación de
los pesos en un valor proporcional al gradiente de dicha función de error.
El método que sigue la regla generalizada para ajustar los pesos es exactamente el mismo que el
de la regla utilizada en el Perceptrón y ADALINE; es decir, los pesos se actualizan de forma
proporcional a la delta, o diferencia entre la salida deseada y la obtenida (δ= sal. Deseada – sal.
obtenida). [13]
2.4.3 Estructura y Aprendizaje de la Red Backpropagation
En una red Backpropagation existe una capa de entrada con N neuronas y una capa de
salida con M neuronas y al menos una capa oculta de neuronas internas. Cada neurona de una
capa (excepto las de entrada) recibe entradas de todas las neuronas de la capa anterior y envía su
salida a todas las neuronas de la capa posterior (excepto las de salida). No hay conexiones hacia
atrás feedback ni laterales entre las neuronas de la misma capa.
La aplicación del algoritmo tiene dos fases, una hacia delante y otra hacia atrás. Durante la
primera fase el patrón de entrada es presentado a la red y propagado a través de las capas hasta
llegar a la capa de salida. Obtenidos los valores de salida de la red, se inicia la segunda fase,
comparándose éstos valores con la salida esperada para así obtener el error. Se ajustan los pesos
de la última capa proporcionalmente al error. Se pasa a la capa anterior con una retropopagación
del error, ajustando los pesos y continuando con este proceso hasta llegar a la primera capa. De
esta manera se han modificado los pesos de las conexiones de la red para cada patrón de
aprendizaje del problema, del que conocíamos su valor de entrada y la salida deseada que debería
generar la red ante dicho patrón.
La técnica Backpropagation requiere el uso de neuronas cuya función de activación sea continua, y
por lo tanto, diferenciable. Generalmente, la función utilizada será del tipo sigmoidal.
2.4.2 Pasos para aplicar el Algoritmo de Entrenamiento
1. Inicializar los pesos de la red con valores pequeños aleatorios.
2. Presentar un patrón de entrada y especificar la salida deseada que debe generar la red.
3. Calcular la salida actual de la red.
Para ello se presentan las entradas a la red y se calcula la salida de cada capa hasta llegar a la capa
de salida, ésta será la salida de la red. Los pasos son los siguientes:
28
Se calculan las entradas netas para las neuronas ocultas procedentes de las neuronas de entrada.
Para una neurona j oculta:
Ecuación 1
En donde el índice h se refiere a magnitudes de la capa oculta; el subíndice p, al p-ésimo vector de

entrenamiento, y j a la j-ésima neurona oculta. El término θ puede ser opcional, pues actúa como
una entrada más.
Se calculan las salidas de las neuronas ocultas:
Ecuación 2
Se realizan los mismos cálculos para obtener las salidas de las neuronas de salida:
Paso 4 . Calcular los términos de error para todas las neuronas.
Si la neurona k es una neurona de la capa de salida, el valor de la delta es: δ
Ecuación 3
La función f debe ser derivable. En general disponemos de dos formas de función de salida:
La selección de la función depende de la forma que se decida representar la salida: si se desea que
las neuronas de salida sean binarias, se utiliza la función sigmoidal, en otros casos, la lineal.
29
Para una función lineal, tenemos:
mientras que la derivada de una función sigmoidal es:
por lo que los términos de error para las neuronas de salida quedan:
Si la neurona j no es de salida, entonces la derivada parcial del error no puede ser evaluada
directamente, por tanto se obtiene el desarrollo a partir de valores que son conocidos y otros que
pueden ser evaluados.
La expresión obtenida en este caso es:
donde observamos que el error en las capas ocultas depende de todos los términos de error de la
capa de salida. De aquí surge el término propagación hacia atrás.
Paso 5. Actualización de los pesos: para ello utilizamos un algoritmo recursivo, comenzando por las
neuronas de salida y trabajando hacia atrás hasta llegar a la capa de entrada, ajustando los pesos
de la siguiente forma:
Para los pesos de las neuronas de la capa de salida:
Para los pesos de las neuronas de la capa oculta:
30
En ambos casos, para acelerar el proceso de aprendizaje se puede añadir un término momento.
Paso 6. El proceso se repite hasta que el término de error
resulta aceptablemente pequeño para cada uno de los patrones aprendidos [4][5].
2.4.3 Dimensiones de la red. Número de capas ocultas
No se pueden dar reglas concretas para determinar el número de neuronas o número de

capas de una red para resolver un problema concreto.
Respecto al número de capas de la red, en general tres capas son suficientes (entrada -
oculta-salida). Sin embargo, hay veces que un problema es fácil de resolver con más de una capa
oculta. El tamaño de las capas, tanto de entrada como de salida, suele estar determinado por la
naturaleza de la aplicación. En cambio, decidir cuántas neuronas debe tener una capa oculta no
suele ser tan evidente. El número de neuronas ocultas interviene en la eficiencia de aprendizaje y
de generalización de la red. No hay ninguna regla que indique el número óptimo, en cada
problema se debe ensayar. [13]
31
32
Implementación de Algoritmos de entrenamiento en VHDL (unidad de control y máquinas de
33
estado finito)
Capítulo 3 Implementación de
Algoritmos de entrenamiento en
VHDL (unidad de control y
máquinas de estado finito)
33
34
estado finito)
3.1. Introducción
Un FSMD (máquina de estado finito con ruta de datos) combina una FSM y circuitos
secuenciales. Los FSM, que algunas veces se conoce como una ruta de acceso de control,
examinan los mandatos externos y el estado, y genera las señales de control para especificar la
operación regular de circuitos secuenciales, que se conocen colectivamente como una ruta de
datos. La FSMD es utilizada para poner en práctica los sistemas descritos por RT (registro
transferencia) metodología, en la que las operaciones se especifican como manipulación de datos
y la transferencia de una colección de registros. [22]
3.2. Operación única del RT

La operación específica un RT (registro transferencia) es la manipulación de datos y la
transferencia de un solo registro de destino. Está representado por la notación
Donde rdest está el registro de destino, rsrc1,r src2, y rsrcn son la fuente registra, y f ( .)
especifica la operación que se va a realizar. La notación indica que el contenido de la fuente los
registros son alimentados a la f (.). La cual se realiza mediante un circuito combinatorio, y el
resultado se pasa a la entrada del registro de destino y se almacena en el registro de destino en el
siguiente flanco de reloj. Las siguientes operaciones son varias formas de representar RT:
 Una constante 0 es almacenado en la r1 registro

 El contenido del registro r1 se vuelve a escribir.
34
35
estado finito)
Figura 3.1Diagrama de Bloques
Figura 3.2Diagrama de tiempo
 El registro r2 se mueve a la derecha tres posiciones y, a continuación,
volver a escribir el contenido.
 El contenido del registro r1 es transferido al registro r2.

 El contenido del registro i se incrementa en 1 y el resultado se escribe en
en i.
 La suma de la s1, s2, y s3 registra se escribe en el d.
 El cuadrado se escribe en el registro y.
La operación de RT se puede implementar mediante la construcción de un circuito

combinatorio para la función y la conexión de la entrada y salida de los registros f (.).
En el diagrama de bloques se muestra que para mayor claridad, se utiliza el registro y los
siguientes sufijos para representar la entrada y la salida de un registro. Se tiene en cuenta que
cada operación de RT está sincronizada por el reloj. El resultado de la función f (.) no se almacena
para registrar el destino hasta el siguiente flanco ascendente del reloj.
3.2. Decisión de caja de registro ASMD
La aparición de un gráfico ASMD es similar a la de un diagrama de flujo normal. La principal

diferencia es que la operación de RT en un gráfico ASMD es controlado por un reloj incorporado
señal y el registro de destino se actualiza cuando se cierra la FSMD el bloque ASMD actual, pero no
dentro del bloque.
Ejemplo:
35
36
estado finito)
Figura 3.3Diagrama ASM
Figura 3.4Diagrama a bloques
El + r-1 r operación en realidad significa que:
 r_next <= r_reg – 1;

 r_reg <= r_next en el borde de subida del reloj (es decir, cuando se cierra el
bloque actual).
36
37
estado finito)
3.3. Máquina de Estados Finitos
Un FSM (máquina de estados finitos) se utiliza para modelar un sistema que transita entre un
número finito de estados internos. Las transiciones dependen de la entrada del estado y externa
actual. A diferencia de un circuito secuencial regular, las transiciones de estado de la FSM, que no
presentan un sencillo y repetitivo patrón. Su lógica siguiente estado por lo general se construye a
partir de cero y, a veces se conoce como Lógica "al azar". Esto es diferente de la lógica siguiente
estado de un circuito secuencial regular, que se compone principalmente de los componentes
"estructurados", como incrementos y palancas de cambio.
se proporciona un resumen de las características básicas y la representación de FSM y discutir

la obtención de códigos de HDL. En la práctica, la aplicación principal de un FSM es la de actuar
como el controlador de un sistema digital de gran tamaño, que examina los comandos externos y
el estado y activa las señales de control adecuadas para controlar el funcionamiento de una ruta
de datos, el cual por lo general se compone de componentes secuenciales regulares.
3.3.1 Representación FSM

El FSM se suele especificar mediante un diagrama de estado abstracto o carta ASM (estado
algorítmico diagrama de la máquina), tanto la captura de la entrada del FSM, la producción, los
estados y las transiciones en una representación gráfica. Las dos representaciones proporcionan la
misma información. La representación FSM es más compacta y mejor para aplicaciones sencillas.
La representación gráfica ASM es algo así como un diagrama de flujo y es más descriptivo para
aplicaciones con una transición compleja condiciones y acciones.
Un diagrama de estado se compone de nodos, que representan los estados y están dibujados
como círculos y arcos de transición anotados. Una expresión lógica se expresa en términos de
señales de entrada se asocia con cada arco de transición y representa una condición específica. El
arco se toma cuando el correspondiente expresión se evalúa verdadero.
Los valores de salida Moore se colocan en el interior del círculo, ya que dependen sólo del
estado actual. Los valores de salida Mealy se asocian con las condiciones de arcos
3.4.1 Descripción ASM

Un diagrama ASM se compone de una red de bloques de ASM. Un bloque de ASM se compone
de una caja de estado y una red opcional de las casillas de decisión o salidas condicionales.
Un cuadro de estado representa un estado en el FSM, y los valores de salida afirmado Moore
se enumeran dentro de la caja. Tenga en cuenta que sólo tiene un camino de salida. Una caja de
decisión prueba la condición de entrada y determina que salen camino a tomar. Cuenta con dos
vías de salida, marcada T y F, que se corresponden con los valores verdaderos y falsos de la
enfermedad. A condicionales listas de los cuadros de salida afirmaron valores de salida Mealy y
37
38
estado finito)
por lo general se coloca después de un cuadro de decisión. Indica que la señal de salida de lista se
puede activar sólo cuando se cumple la condición correspondiente en el cuadro de decisión. [22]
Figura 3.5 Máquina de estados finitos y su equivalente en diagrama ASM
3.5 Modelado de Hardware en VHDL
Un modelo de hardware en VHDL se describe en dos partes, la declaración de la entidad y la

arquitectura asociada parte del cuerpo. [21]
ENTIDAD
CUERPO 1 CUERPO 2 CUERPO N

Figura 3.6 Componentes de una arquitectura
La declaración de la entidad da un nombre al modelo que se está desarrollado y también

declara sus señales de interfaz externos (llamados puertos): sus nombres, modos (in, out, inout,
buffer) y sus tipos.
38
39
estado finito)
3.3.1 ¿Qué es Síntesis?
La síntesis es el proceso de construir una lista de conexiones a nivel de compuertas de un

modelo de un circuito descrito en VHDL. Un programa de síntesis genera un net list RTL (FF, ALU,
multiplexor, interconectados por medio de cables). Por lo tanto, el constructor módulo de RTL es
necesario y el propósito de este constructor es la construcción de cada uno de los bloques de RTL
requeridos a partir de una biblioteca de componentes predefinidos (de destino especificado por el
usuario de tecnología).
Después de producir una lista de conexiones a nivel de puertas, un optimizador de la lógica lee
en este net list y optimiza el circuito de la zona y el momento especificado por el usuario
limitaciones.
3.3.2 Síntesis en un proceso de diseño
Un circuito puede ser descrito de muchas maneras diferentes, no todos los cuales pueden
ser sintetizables. Esto es debido al hecho de que VHDL fue diseñado principalmente como lenguaje
de simulación y no para la síntesis.
No hay ningún subconjunto estandarizado de VHDL para síntesis.
No hay objeto directo en VHDL que significa un cerrojo o un flip-flop, Por lo tanto, cada
sistema de síntesis proporcionan diferentes mecanismos para modelar un flip-flop o un latch.
3.3.3 Los valores para Modelar Hardware
VHDL proporciona dos clases de objetos de datos, de señales y variables, que

puede ser utilizado para modelar los titulares básicos de valor en el hardware.
Los valores titulares básicos en el hardware son:
• Alambre
• Flip-flop (un dispositivo activado por flancos)
• Latch (un dispositivo sensible al nivel)
En VHDL, una señal, o una variable declarada en un proceso, conserva su valor

a través de toda la ejecución de la simulación, infiriendo así la memoria.
39
40
estado finito)
Reglas generales para la inferencia latch
Regla 1: Una variable se le asigna en una sentencia condicional (if or case).

Regla 2: La variable no se le asigna en todas las ramas de la condicional declaración.
Regla 3: El valor de las variables necesita ser salvados entre múltiples invocaciones del proceso.
Las tres condiciones deben cumplirse antes de que una variable se deduzca como un Latch.
3.3.4 FSM, Código de desarrollo en VHDL

El procedimiento de desarrollo de código para una FSM es similar a la de un circuito
secuencial regular. En primer lugar, separar el registro de estado y luego derivar el código de la
lógica del estado siguiente y la lógica combinacional de salida. La principal diferencia es la lógica
del estado siguiente. Para una FSM, el código de la lógica del estado siguiente sigue el flujo de un
diagrama de estado o diagrama ASM.
Durante la síntesis, el software asigna automáticamente los valores en un tipo de datos

enumerado a representaciones binarias, un proceso conocido como asignación de estados.
Aunque no existe un mecanismo para llevar a cabo esto de manera manual, que rara vez es
necesario. [21]
40
Diseño y descripción de la implementación de una unidad de control en hardware para ejecutar
41
el algoritmo de entrenamiento y comparación con su equivalente en software
Capítulo 4 Diseño y descripción de

la implementación de una unidad
de control en hardware para
ejecutar el algoritmo de
entrenamiento y comparación con
su equivalente en software
41
42
4.1. Introducción
Como se ha establecido en el objetivo, se busca mostrar las ventajas de la implementación

de redes neuronales en software incluyendo dentro del mismo FPGA el algoritmo de
entrenamiento, así se obtiene un modelo más parecido al de las redes neuronales biológicas las
cuales tienen un alto nivel de paralelismo y respuestas muy rápidas a diferencia de la
implementación de una red neuronal en software, que pierde esta característica de paralelismo y
sumado a esto una respuesta más lenta al ser códigos que se ejecutan de manera secuencial.
En este capítulo se describe la implementación del algoritmo de entrenamiento en VHDL

haciendo uso de una unidad de control así como los factores que influyen en su diseño y los
puntos considerados en su modelado teniendo en cuenta que se busca programar una
arquitectura sintetizable e implementable en hardware.
Se realiza también en esta sección una comparación de la implementación en software de

los mismos algoritmos de entrenamiento de redes neuronales (perceptrón y retropropagación),
programados en C++ con Visual Studio 2012 para resaltar la importancia de las diferencias entre
las implementaciones en hardware y software.
4.2. Descripción del diseño de la unidad de control
4.2.1. Puertos
Las unidades de control requieren de puertos por los cuales se comuniquen, con el resto
del hardware, en los puertos se han incluido entrada y salida de datos, reloj y reset.
4.2.2. Sistema de reloj
El sistema de reloj de la unidad de control toma la frecuencia de operación directamente

del oscilador que incluye la placa de entrenamiento del FPGA Xilinx Spartan-3E, su frecuencia de
operación es de 50 MHz, entonces cada ciclo del reloj dura 2 nano segundos.
42
43
Figura 4.1 Oscilador de la tarjeta del FPGA
Es importante notar que dentro del sistema de reloj que se desarrolló para la unidad de
control, se hace uso de los flancos de subida para actualizar el valor de las variables, como se
mencionó en el capítulo 3, es necesario trabajar las variables con 2 estados, uno futuro y uno
actual ya que si se intenta usar la variable normal como usualmente se hace en lenguajes como C,
es muy probable tener errores y advertencias de fallas por latch (enclavamiento o
retroalimentación).
Figura 4.2 Flanco de subida del ciclo de reloj
Dentro de esta misma sección de reloj se define como es que el sistema se comportará
ante un reset, lo que se estableció es que la máquina de estados se regrese al primer estado y los
valores de las variables se restablezcan a sus valores iniciales para repetir el proceso de
entrenamiento.
En la Figura 4.3 se muestra el ejemplo de un sistema de reloj utilizado en la unidad de

control utilizada para entrenar una red en VHDL.
43
44
Figura 4.3 Sistema de reloj en VHDL
4.2.3. Variables y registros
VHDL cuenta con una gran variedad de tipos de variables disponibles para almacenar
datos. Para el caso de las redes neuronales es necesario contar con variables enteras con signo y
variables de punto flotante con signo. Las variables enteras con signo son parte de la librería
básica de VHDL por lo que no es necesario desarrollar una librería propia para hacer uso de ellas,
en el caso de las variables de punto flotante no es así. VHDL no tiene en sus librerías básicas
soporte para variables de punto flotante ni de punto fijo por lo que es necesario, por ejemplo para
el caso de una red neuronal de retropropagación, desarrollar o implementar una librería de punto
flotante ya que el uso de este tipo de variable es necesario. Actualmente hay disponibles librerías
para el uso de punto flotante y fijo en VHDL, estas se pueden conseguir en el sitio
http://www.vhdl.org. Es importante mencionar que no todas las operaciones con punto flotante
son sintetizables por lo que se tiene que realizar un estudio profundo de las características con las
que cuenta esta librería para ajustarla a las necesidades del proyecto en el cuál se implementará
Todas las variables tienen un valor futuro y uno registrado o actual para que, como se
mencionó en la descripción del reloj, al terminar un ciclo de reloj la variable actualice su valor.
44
45
Figura 4.4 Registro de variable en estados futuro y presente
4.2.4. Función de activación para la red neuronal
Como se estudió en el Capítulo 2, las diferentes arquitecturas de redes neuronales

requieren de diferentes funciones de activación. En el caso de un perceptrón se puede utilizar una
función escalón, en el caso de una red de retropropagación se necesita una función de activación
derivable como la sigmoidal. Dentro de la arquitectura principal de entrenamiento se debe definir
una sección que evalúe la función de activación y relacionarla con la máquina de estados.
4.2.5. Máquina de estados
4.2.5.1. Máquina de estados para realizar el entrenamiento
Dentro de las opciones que ofrece VHDL para realizar un proceso, la más adecuada para
este caso es la implementación de una máquina de estados ya que cuando se define bien como
trabajará la transición de estados y como se comportarán las variables involucradas en este
proceso, la sintetización se logra sin problemas por lo que se obtiene una arquitectura
implementable en hardware. Mostrar gráficamente una máquina de estados es poco práctico en
este caso ya que cuenta con varias operaciones internas en cada estado por lo que se muestran
diagramas de flujo generalizados para hacer más simple la visualización de cómo se implementan
los algoritmos.
El perceptrón con el que se realizan las pruebas es el de la Figura 4.5, este es el perceptrón
que se entrena para ambos casos, software y hardware
45
46
Figura 4.5 Diagrama del perceptrón.
En el caso del algoritmo de entrenamiento de un perceptrón se sigue el diagrama de flujo

de la Figura 4.6 la cual realiza el entrenamiento exitosamente, este diagrama de flujo muestra de
manera generalizada como se realiza la ejecución del algoritmo, las etiquetas que están escritas en
los recuadros corresponden al nombre que se le asignó a cada estado.
Figura 4.6 Máquina de estados para el perceptrón
46
47
Figura 4.7 Diagrama de bloques de hardware capaz de realizar el entrenamiento de un perceptrón.
47
48
En la Figura 4.7 se muestra el equivalente en bloques de hardware de una unidad de

control diseñada con una lógica del estado siguiente (de la cual se habla en el Capítulo 3) que es
capaz de realizar el entrenamiento del perceptrón. Se observa que esta unidad de control está
formada por flip-flops, comparadores, sumadores y multiplicadores. A la salida de los flip-flops se
tiene lo que se ha mencionado como estado siguiente y a la entrada el estado actual, los cuales
con los pulsos de reloj en conjunto con el resto de los componentes, pueden hacer las operaciones
necesarias con los registros para entrenar el perceptrón.
Para el caso del entrenamiento por retropropagación se muestra en la Figura 4.8 se

muestra el diagrama de la red de retropropagación que se entrenó en ambos casos, software y
hardware para realizar la comparación de los resultados de ambas implementaciones. En la Figura
4.9 se muestra el diagrama de flujo generalizado con las etiquetas que corresponden a los estados
declarados.
Figura 4.8 Diagrama de la red de retropropagación
48
49
Figura 4.9 Máquina de estados para retropropagación
Importante reafirmar que se debe definir completamente todas las posibilidades de

transición de estados en VHDL, realizar una correcta actualización y asignación de valores a las
variables para evitar advertencias, casos de incertidumbre y errores en la sintetización.
4.2.5.2. Explicación de las funciones de los estados de la máquina de estados
4.2.5.2.1 Descripción de la máquina de estados para un perceptrón de una capa
Aquí se describen las funciones que realizan los estados de la máquina de estados de la
Figura 4.6 para realizar el entrenamiento de un perceptrón
init_value: En este estado se inicializan las todas las variables (pesos, polarización, errores,
alpha de aprendizaje, contadores, etc.).
49
50
in_sel: Se seleccionan las parejas de patrones de entrada-salida que servirán de muestras

para el entrenamiento, como lo establece un entrenamiento supervisado.
net_calc: Se realiza el cálculo de la función de activación.
ak_calc: Se calcula la salida actual del perceptrón.
ek_calc: Se calcula el error actual entre el resultado de la salida actual y el valor de salida
deseado.
ek_eval: Se evalúa el error actual para decidir si es necesario recalcular los pesos o no.
También controla el contador con el que se seleccionan los patrones de entrada y salida, si es que
este ha alcanzado el último patrón de entradas y salidas el contador es reiniciado.
weigh_calc: Cálculo de los nuevos pesos y del error total de la época de entrenamiento.
et_eval: Evaluación del error total, si se encuentra fuera del valor de tolerancia se realiza
una nueva época de entrenamiento, reiniciando también el contador que selecciona las parejas de
patrones entrada/salida.
done: El error total se encuentra dentro del margen de tolerancia, el entrenamiento ha

terminado.
others: Este es un estado que debe ser incluido por defecto dentro del proceso de
máquina de estados en VHDL, sirve para considerar todas aquellas posibilidades que aunque
tengan poca probabilidad de suceder, deben ser especificadas para no caer en una incertidumbre,
en este caso si hay una transición incorrecta por una mala actualización de las variables que
controlan las transiciones de estados, la máquina de estados se reinicia.
4.2.5.2.1 Descripción de la máquina de estados para el entrenamiento de retropropagación
Al haber ya implementado una máquina de estados que logra satisfactoriamente el

entrenamiento de un perceptrón, se puede usar este modelo como base para el entrenamiento de
retropropagación el cuál varía principalmente en su función de activación que en este caso es una
función sigmoidal la cual es evaluada por medio de una tabla de valores, la retropropagación del
error y el uso de punto flotante.
La evaluación de la función sigmoidal por medio de una tabla de valores se usa ya que el
cálculo de operaciones que involucran funciones exponenciales es complicado de implementar en
VHDL.
Como se observa en la Figura 4.9, el entrenamiento de retropropagación en este caso está

diseñado para cumplir un determinado número de épocas. Esto se hizo ya que al utilizar una
50
51
función de activación sigmoidal evaluada por medio de una tabla de valores, los cálculos pierden
un poco de precisión y es probable que el error tarde más en converger u oscile.
La red neuronal descrita que se implementa es de 2 unidades de entrada, 2 ocultas y 1 de

salida con función de activación sigmoidal, y se enlistan los estados junto con una descripción de
su función en el entrenamiento.
init_value: Se inicializan todos los registros (pesos, polarizaciones, alpha de aprendizaje,

etc.).
in_sel: Se selecciona el par de patrones de entrada-salida que servirán de muestras para el

entrenamiento, como lo establece un entrenamiento supervisado.
calc_hidden: Se calculan las salidas de las neuronas de la capa oculta.
calc_out: Se calculan las salidas de las neuronas de la capa de salida.
calc_oitput_adjustment: Se calcula el ajuste de los pesos para las neuronas de la capa de

salida.
calc_hidden_adjustment: Se calcula el ajuste de los pesos para las neuronas de la capa

oculta.
weigh_adjustment: Se calculan los pesos nuevos.
stop_condition: Si se ha realizado el número de épocas deseado, se sigue hacia el estado

done_training, de lo contrario se avanza hacia new_epoch.
new_epoch: Se inicia otra época de entrenamiento avanzando hacia el estado de selección

de los pares de patrones entrada-salida.
others: Este es un estado que debe ser incluido por defecto dentro del proceso de
máquina de estados en VHDL, sirve para considerar todas aquellas posibilidades que aunque
tengan poca probabilidad de suceder, deben ser especificadas para no caer en una incertidumbre,
en este caso si hay una transición incorrecta por una mala actualización de las variables que
controlan las transiciones de estados, la máquina de estados se reinicia.
51
52
4.2.6. Sintetizabilidad
En VHDL se cuenta con varias instrucciones y sentencias las cuales pueden ser útiles con el
fin de simulación pero no todas las instrucciones del lenguaje son sintetizables. Para crear una
arquitectura sintetizable se deben tener muchos aspectos en cuenta ya que nunca se debe olvidar
que se está describiendo una arquitectura de hardware, interconexiones dentro del FPGA las
cuales están presentes todo el tiempo, muy diferente al modelo de programación al que
usualmente estamos acostumbrados, un modelo secuencial en el que las instrucciones se ejecutan
una tras otra (por ejemplo lenguaje C/C++) y no todas al mismo tiempo, el caso de VHDL.
También es posible que algunas instrucciones sean sintetizables pero solo bajo situaciones
muy bien definidas por lo que es necesario prestar mucha atención a como se utilizan, tal es el
caso de los ciclos for, por mencionar uno.
En el caso del punto flotante la sintetizabilidad es alcanzable pero costosa, el uso de punto
flotante en hardware es una operación que requiere de hasta 3 veces más recursos que el uso de
punto flotante en software. Aun así se puede lograr sintetizar pero es necesario definir muy
claramente las magnitudes de las variables y las operaciones que se realizarán, es posible que se
obtengan algunas advertencias en la sintetización pero en las simulaciones se puede comprobar el
correcto funcionamiento.
4.3. Comparación con la implementación en software.
Paralelo a las pruebas realizadas para el desarrollo en hardware de la unidad de control

capaz de realizar el entrenamiento de la red neuronal, se implementaron los algoritmos de
entrenamiento perceptrón y retropropagación en lenguaje C++ para experimentar las diferencias
entre cada método de programación. Un listado de las principales diferencias se muestra en la
Tabla 4-1.
52
53
Tabla 4-1 Diferencias entre las implementaciones en hardware y software
Implementación en hardware (Xilinx Spartan Implementación en software (Visual Studio

3-E programado con VHDL-93) 2012 C++)
Se requiere de registros futuros y presentes. No necesita de registros futuros y presentes.
No cuenta con funciones nativas de punto Cuenta con funciones de punto flotante.
flotante pero hay librerías funcionales
disponibles.
Arquitectura paralela. Pierde la característica del paralelismo.
Los ciclos de trabajo son muy rápidos. La ejecución es más lenta ya que por su
naturaleza secuencial las instrucciones se
ejecutan una tras otra.
No requiere de una computadora para trabajar Se requiere de una computadora para que la
ya que programado el FPGA la red se entrena y red neuronal se entrene.
ejecuta sobre la misma placa.
Se tiene acceso y control a todo registro que se Al ser un lenguaje de medio nivel puede que no
utilice en el programa, el programador crea y se tenga control total de los registros
manipula los a nivel hardware la estructura de involucrados en las macros del lenguaje. Esto
la red neuronal por lo que el diseño es más también hace que la ejecución pueda sea más
flexible. lenta
Cuenta con un simulador muy potente en el Cuenta con herramienta de Debugger para
que se pueden observar todos os registros y depurar el programa
cómo se comportan en tiempo
En la Figura 4.10 se muestra como es notable la diferencia entre la forma de realizar una
misma operación en cada uno de los lenguajes y como es la actualización de los registros en VHDL
haciendo uso de los estados futuros y registrados, la operación realizada es la actualización de
pesos para un perceptrón.
53
54
Figura 4.10 Comparación de las características del código para una misma función
Esta operación tan sencilla en C++ para ser implementada en VHDL tiene que ser realizada
en un estado dedicado a la misma operación y después, con el flanco de subida del reloj, el valor
del registro futuro (next) será almacenado en el registro actual o registrado (reg).
VHDL cuenta con una instrucción de ciclo for pero en un caso como este no es práctico
implementarla ya que no será sintetizable dentro de una máquina de estados.
54
Simulación y resultados 55
Capítulo 5 Simulación y resultados
55
5.1. Herramientas de simulación
Para simular el entrenamiento se hizo uso de la herramienta integrada a Xilinx ISE Design
Suit 13.1, llamada ISE Simulator. En este simulador se puede observar cómo se comportan los
registros con respecto al tiempo y el paso de los pulsos de reloj del sistema.
Los resultados son comparados con los programas de implementación en C++ con fines de
comprobación del correcto funcionamiento así como, una vez más, encontrar diferencias en el
rendimiento de las 2 diferentes formas de implementación (hardware y software) de un mismo
algoritmo de entrenamiento.
5.2 Revisión de sintaxis y sintetización.
Antes de poder simular una arquitectura diseñada en VHDL es necesario que se haga una
revisión de sintaxis utilizando las herramientas integradas del entorno de desarrollo. Es muy
importante notar que a pesar de que se realice la revisión de sintaxis de manera correcta es
posible que la arquitectura no sea sintetizable, esto por que como el nombre del proceso lo
menciona, solo revisa la sintaxis del código desarrollado, esto abarca que las líneas estén bien
escritas y que no hagan falta caracteres como “;” al final de estas, etc.
Figura 5.1 Sintetización correcta
56
Ya que se tiene la revisión de sintaxis se puede realizar la implementación del diseño y si

todo es marcado como correcto entonces la arquitectura programada puede ser implementada en
el FPGA.
Figura 5.2 Implementación correcta
Este paso es importante ya que el objetivo de esta tesis es realizar una arquitectura que
sea implementable en el FPGA y no sólo simulable.
El entorno de desarrollo también nos muestra información sobre la cantidad de recursos

consumidos por una arquitectura ya sintetizada, también junto con un resumen de advertencias y
errores que pudieran haber sucedido en la sintetización.
Figura 5.3 Resumen de recursos consumidos y notificaciones
En la Figura 5.3 se muestra la cantidad de recursos y de slices consumidas por la

arquitectura de entrenamiento del perceptrón junto con el reporte de errores. La información
57
mostrada es cero errores y advertencias en la sintetización, 1 slice utilizada de 4656 disponibles en

el FPGA, también la cantidad de puertos utilizados.
5.3 Simulación con ISE Simulator
5.3.1 Entrenamiento del perceptrón
En la Figura 5.4 se muestra el resultado de la simulación de la arquitectura de

entrenamiento del perceptrón.
En la columna llamada name se enlistan las diferentes señales y registros que se analizan
en la simulación y las principales son
Función de activación: net
Pesos: w1, w2
Polarización: b
Errores: ek, et
Estados: state_next, state_reg
Reloj: clock
Reset: reset
Esta simulación es de 2 micro segundos y se observa que antes de alcanzar los 2,000 nano
segundos el perceptrón ya alcanzó el estado llamado done, el estado que de acuerdo a la máquina
de estados desarrollada, indica que el entrenamiento ha terminado, también se observa que los
valores de los registros han dejado de variar al alcanzar el estado done. Antes de llegar al estado
done se observa que los estados están realizando la transición, en la Figura 5.5 se muestra un
aumento de la imagen por medio de la herramienta de zoom de ISE Simulator, también se
observa cómo la transferencia de valor de los registros next a los registros reg tienen un pequeño
retraso por que como se mencionó, la actualización de los registros se ejecuta en el flaco de
subida y se puede comprobar en la simulación que también cuenta con la señal clock.
58
Figura 5.4 Simulación
59
Figura 5.5 Transiciones
60
Figura 5.6 Entrenamiento concluido
61
Se observa en la Figura 5.6 como se da la transición de estados en el flanco de subida, también se

observa como la máquina de estados inicia en el estado init_value y la transición sigue el orden de
acuerdo al algoritmo de entrenamiento, así se realizarán las épocas de entrenamiento hasta llegar
al estado done cuando el error esté dentro del margen de tolerancia.
En la Figura 5.6 se observa la transición de estados hasta alcanzar el estado done, se

puede ver que ek (error actual) y et (error total de la época) quedan en cero, el entrenamiento ha
concluido.
En este ejemplo de simulación, el perceptrón se entrenó para comportarse como una

compuerta OR y de la Figura 5.4 se puede observar que los pesos obtenidos al concluir el
entrenamiento son w1=1 w2=1 y b=0, estos resultados coinciden con el entrenamiento de
perceptrón implementado en C++.
Figura 5.7 Resultados de entrenamiento en C++
La arquitectura de entrenamiento funciona y es capaz de aprender más patrones, el

entrenamiento como compuerta OR solo es con el fin de comprobar que se está realizando el
aprendizaje de manera correcta pero esta arquitectura implementable en FPGA puede aprender
otros patrones.
A continuación se muestran imágenes de la misma arquitectura realizando el aprendizaje de otros

patrones y la comparación de resultados en C++.
62
5.3.1.1 Simulación de diferentes patrones de entrenamiento
Figura 5.8 Simulación del entrenamiento como compuerta NOR
63
Figura 5.9 Entrenamiento como compuerta NOR en C++
Figura 5.10 Entrenamiento como compuerta AND en C++
64
Figura 5.11Simulación del entrenamiento como compuerta AND
65
Figura 5.12 Simulación del entrenamiento como compuerta NAND

66
Figura 5.13 Entrenamiento como compuerta NAND en C++
De las simulaciones (Figura 5.8, Figura 5.11 y Figura 5.12) y haciendo la comparación
(Figura 5.9,Figura 5.10 y Figura 5.13) del entrenamiento se obtuvieron los mismos resultados que
en la versión del programa en lenguaje C++ pero como se puede ver en los diagramas de tiempo,
el entrenamiento concluye rápidamente, en tiempos que no sobrepasan los 3 microsegundos, el
rendimiento del algoritmo implementado en un FPGA se ve mejorado de manera muy notable ya
que el paralelismo de la arquitectura permite que un gran número de operaciones sean realizadas
en un mismo ciclo de reloj.
En la Tabla 5-1 se resumen los valores obtenidos para los entrenamientos del perceptrón, así
como el tiempo que tomaron para concluir.
67
Tabla 5-1 Valores y tiempos de los diferentes entrenamientos para el perceptrón.
Patrón a Valor obtenido para Error total al fin del Tiempo

aprender pesos y simulación entrenamiento (nanosegundos)
Compuerta W1 1 0 1870
OR W2 1
B 0
Compuerta W1 -1 0 1920
NOR W2 -1
B 1
Compuerta W1 2 0 2870
AND W2 1
B 2
Compuerta W1 -2 0 2910
NAND W2 -1
B 3
5.3.2. Entrenamiento de la red de retropropagación
Para la red de retropropagación se realizará el entrenamiento de la red como una compuerta XOR.
También se muestra la comparación del mismo entrenamiento realizado en software con C++.
Para el entrenamiento en software se mostrarán los valores obtenidos para entrenamientos de
5,000 y 20,000 épocas para hacer la comparación con los valores que se obtienen por el
entrenamiento en hardware con 5,000 épocas.
Para la red de retropropagación, como se mencionó antes, se hizo uso de las librerías de punto
flotante que se pueden conseguir en www.vhdl.org y cumplen con la norma de la IEEE 754 para el
manejo de variables de punto flotante.
68
Figura 5.14 Simulación del entrenamiento de la red de retropropagación como compuerta XOR
69
En la Figura 5.14 se observa una parte de la simulación del entrenamiento. Se puede ver que el
entrenamiento de la red termina en 4.4 milisegundos y en este caso como el punto flotante se
implementó por medio de una librería externa solo se puede ver el valor de los registros en bits.
En la Figura 5.15 se muestran los resultados obtenidos para el mismo entrenamiento realizado en
C++ utilizando 5,000 épocas y en la Figura 5.16 se muestran los resultados para 20,000 épocas.
Figura 5.15 Entrenamiento de la red de retropropagación como compuerta XOR en C++ con 5,000 épocas
Figura 5.16 Entrenamiento de la red de retropropagación como compuerta XOR en C++ con 20,000 épocas.
Para facilitar la comparación de los datos, se resumen en la Tabla 5-2 junto a los valores obtenidos
por el entrenamiento en hardware convertidos a valor decimal.
70
Tabla 5-2 Comparación de los valores obtenidos.
Parámetro Entrenamiento en C++ Entrenamiento en Implementación con

(5,000 épocas) C++(20,000 épocas) VHDL (5,000 épocas)
weight_i1_h1 -4.29183 -5.0262 -5.9327116
weight_i2_h1 -4.28157 -5.01865 -5.4639354
hidden1 6.34633 7.48544 8.393847
weight_i1_h2 -6.17604 -6.64727 -7.0977945
weight_i2_h2 -6.1105 -6.60834 -7.1770186
hidden2 2.41079 2.74414 3.0035756
weight_h1_o1 8.58844 10.4693 9.863032
weight_h2_o1 -8.79571 -10.6107 -9.975169
output1 -4.00181 -4.98722 -4.5072393
Error 9.98E-4 1.33E-4 -3.1467463E-4
Tiempo 4 milisegundos
Los valores obtenidos por el entrenamiento realizado con la implementación en VHDL son
cercanos a los que se obtienen por medio de una implementación típica en software con la
ventaja de que el entrenamiento se realiza muy rápido y se puede realizar sobre el mismo FPGA.
También se puede observar que la magnitud del error es pequeña así entonces se nota que este
método de entrenamiento por hardware es confiable.
71
72
Conclusiones y futuras posibilidades de desarrollo 73
Capítulo 6 Conclusiones y futuras

posibilidades de desarrollo
73
6.1. Conclusiones
De las simulaciones se observa que la arquitectura de entrenamiento implementada es

capaz de alcanzar resultados satisfactorios y en un tiempo muy corto que no pasa de algunos
microsegundos (en este caso aproximadamente 2 microsegundos para una capa), es un tiempo
muy corto comparando esto con las maneras típicas de implementar una red neuronal, por
ejemplo en un sistema embebido basado en microprocesador (como un microcontrolador o DSP)
el cual en ese tiempo continuaría esperando la estabilización de voltaje de alimentación para
poder iniciar la ejecución del programa y apuntar a la dirección de inicio. También la
implementación de esta arquitectura de entrenamiento en FPGA tiene ventajas sobre una
implementación en software ya que la segunda necesita de una computadora se dedique
únicamente a la tarea de control neuronal, procesos como reconocimiento y clasificación
consumen muchos recursos del procesador, sumado a esto el uso de lenguajes de medio o alto
nivel así como toolboxes (como las que se pueden adquirir para MatLab o Labview) hacen que la
respuesta de el algoritmo sea más lenta.
El paralelismo del FPGA es uno de los factores clave que permite que el entrenamiento se
realice tan rápido. Al incrementar el número de neuronas y capas el entrenamiento tomará más
tiempo pero seguirá siendo muy rápido.
La flexibilidad que ofrece VHDL para el modelado de hardware es un punto muy

importante para la implementación de diferentes arquitecturas de redes neuronales y no se limita
al perceptrón o la retropropagación, estas 2 arquitecturas son los primeros pasos para la
implementación de redes más grandes y complejas.
Tener un hardware dedicado a una tarea específica es una de las maneras de incrementar
la eficiencia de un sistema, la implementación de redes neuronales en hardware permite una alta
eficiencia la cual mejorará notablemente el desempeño de un sistema que requiera control
neuronal de alto rendimiento.
La implementación de una red neuronal con un paralelismo real hace que las redes
neuronales electrónicas se asemejen más al modelo de las redes neuronales biológicas, de las
cuales se busca imitar el comportamiento de aprendizaje y son la base de la analogía utilizada en
esta área de la computación.
Los sistemas digitales complejos están conformados por varios módulos más pequeños y
simples y una característica de VHDL es que permite este tipo de integración de entidades
pequeñas y sencillas en la arquitectura principal, así como su interconexión para poder generar un
sistema digital más grande y complejo. Al tener una neurona funcionando en VHDL, es posible
realizar redes neuronales de mayores dimensiones.
74
6.2. Futuras posibilidades de desarrollo
Las redes neuronales actualmente siguen siendo ampliamente implementadas en software

ya que su tiempo de diseño suele ser menor haciendo uso de lenguajes de alto nivel y
herramientas de diseño como las que incluyen MatLab o Labview pero, la implementación en
hardware es un área la cuál puede ser explorada con fines de aplicaciones de neurocomputo de
alto rendimiento, su procesamiento en tiempo real permite que la eficacia de su desempeño sea
mucho mayor en tareas de alta exigencia.
También se pueden diseñar sistemas neuronales embebidos dedicados a la observación de

plantas con la finalidad para entrenarse y, posteriormente trabajar sin la necesidad de tener una
computadora involucrada en el proceso de aprendizaje, con la finalidad de realizar diagnóstico de
falla, operaciones de mantenimiento y monitoreo
75
76
Bibliografía 77
Bibliografía
[1] Fausett, Laurene. Fundamentals of neural networks.
[2] Robert L. Harvey. Neural network principles. Prentice-Hall International
[3] Timothy Masters. Practical neural network necipes in C++. Academic Press, Inc.
[4] Synplify (sintetizador de Synplicity) y ModelSim (simulador de Mentor Graphics).
[5+ Stephen Brown, Zvonko Vranesic. “Fundamentals of Digital Logic with VHDL Design”, McGraw-
Hill
[6+ Volnei A. Pedroni. “Circuit Design with VHDL”, MIT Press
[7+ Altera‟s Corporation. “Cyclone II Device Handbook”, Volumen 1
[8] Hecht-Nielsen, Robert Counter-Propagation Networks IEEE First International Conference on

Neural Networks, VolumeII.
[9] Hecht-Nielsen, Robert. Neurocomputing. Addison Wesley, Reading, MA, 1990
[10] Mare, Harston & Pap. Handbook of Neural Computing Applications. Academic Press,
San Diego, 1990
[11] Journals. IEEE Transactions on Neural Networks
[12] • Spartan-3E Starter Kit Board Page

http://www.xilinx.com/s3estarter
[14]• UG230: Spartan-3E Starter Kit User Guide
[15]http://www.xilinx.com/support/documentation/
userguides/ug230.pdf
[13].”Redes Neuronales Artificiales Fundamentos, modelos y aplicaciones”

José R. Hilera/Víctor J. Martínez, editorial Alfaomega, edición 2000
[16] José R. Hilera y Victor J. Martinez, “Redes Neuronales Artificiales”, Alfaomega-Rama,

2000
[17] S.Y. Kung, "Digital Neural Networks", Prentice Hall, 1993.
[18] E. Castillo Ron, Á. Cobo Ortega, J. M. Gutiérrez Llorente, R. E. Pruneda González,

“Introducción a la Redes Funcionales con Aplicaciones”, Paraninfo, 1999
77
Bibliografía 78
[19] J.A. Freeman y D.M. Skapura, "Redes Neuronales: Algoritmos, Aplicaciones y Técnicas de
Programación", Addison-Wesley, 1993.
[20] Bonifacio Martín y Alfredo Sanz, “Redes Neuronales y Sistemas Difusos”, Alfaomega-
Rama, 2002
*21+ David G. Maxines, Jessica Alcalá, “VHDL el arte de programar sistemas digitales”, CECSA
Tecnologico de Monterrey, continental primera edición 2002
[22] Pong P. Chu, “FPGA PROTOTYPING BY VHDL EXAMPLES Xilinx Spartan” TM-3 Version
Cleveland State University, 2008 by John Wiley & Sons, Inc
78
Anexos 79
Anexos
Especificaciones generales de la familia de FPGA Spartan-3E
79
Anexos 80
80
Anexos 81
Código en VHDL para la red neuronal de retropropagación

----------------------------------------------------------------------------------
-- Company:
-- Engineer: Ernesto Antonio Peña Serrato
--
-- Create Date: 03:16:04 04/25/2013
-- Design Name:
-- Module Name: neuralnetwork - training
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library ieee, ieee_proposed;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee_proposed.fixed_float_types.all;
use ieee_proposed.fixed_pkg.all;
use ieee_proposed.float_pkg.all;
use ieee.math_real.all;
-- Uncomment the following library declaration if using

-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;
-- Uncomment the following library declaration if instantiating

-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity neuralnetwork is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
z : out STD_LOGIC;
clock : in STD_LOGIC;
reset : in STD_LOGIC);
end neuralnetwork;
architecture training of neuralnetwork is

--==============STATES DECLARATION=====================
81
Anexos 82
type state_type is (init_value, in_sel, calc_hidden, calc_hidden_sig1, calc_hidden_sig2,

calc_out, calc_output_sig, calc_output_adjustment,
calc_hidden_adjustment,
weigh_adjustment, stop_condition, new_epoch, done_training);
signal state_reg, state_next: state_type;
--==============SIGNALS DECLARATION====================
--signals according to the neural network diagram

signal input1_reg, input1_next, input2_reg, input2_next: float (8 downto -12);
signal weight_i1_h1_reg, weight_i1_h1_next, weight_i2_h1_reg, weight_i2_h1_next,
hidden1_reg, hidden1_next: float (8 downto -12);
signal weight_i1_h2_reg, weight_i1_h2_next, weight_i2_h2_reg, weight_i2_h2_next,
hidden2_reg, hidden2_next: float (8 downto -12);
signal weight_h1_o1_reg, weight_h1_o1_next, weight_h2_o1_reg, weight_h2_o1_next,
output1_reg, output1_next: float (8 downto -12); --as float variables in both cases, reg and next
signal output_hidden1_reg, output_hidden1_next: float (8 downto -12);
signal output_hidden2_reg, output_hidden2_next: float (8 downto -12);
signal output_output1_reg, output_output1_next: float (8 downto -12);
signal output1_adjustment_reg, output1_adjustment_next: float (8 downto -12);
signal hidden2_adjustment_reg, hidden2_adjustment_next: float (8 downto -12);
signal hidden1_adjustment_reg, hidden1_adjustment_next: float (8 downto -12);
signal target_reg, target_next: float (8 downto -12);
signal LEARNRATE: float (8 downto -12);
signal i_reg, i_next: unsigned (1 downto 0);
signal epoch_next, epoch_reg: unsigned (15 downto 0);
--signals required by the training process
-- learning_rate,weigh_adjustment
begin
--=====================CLOCK & RESET=======================

process(clock,reset)
begin
if reset='1' then
state_reg <= init_value;
elsif (clock'event and clock='1') then
state_reg <= state_next;
input1_reg <= input1_next;
input2_reg <= input2_next;
target_reg <= target_next;
hidden1_reg <= hidden1_next;
hidden2_reg <= hidden2_next;
output1_reg <= output1_next;
weight_i1_h1_reg <= weight_i1_h1_next;
82
Anexos 83

weight_h1_o1_reg <= weight_h1_o1_next;
weight_h2_o1_reg <= weight_h2_o1_next;
output_hidden1_reg <= output_hidden1_next;
output_hidden2_reg <= output_hidden2_next;
output_output1_reg <= output_output1_next;
output1_adjustment_reg <= output1_adjustment_next;
hidden1_adjustment_reg <= hidden1_adjustment_next;
hidden2_adjustment_reg <= hidden2_adjustment_next;
i_reg <= i_next;
--LEARNRATE <= to_float(0.5,LEARNRATE);
--ITER <= 10000;
epoch_reg <= epoch_next;
--next values are stored in the current signal
end if;
end process;
--=================STATE MACHINE============================
process(state_reg, input1_reg, input2_reg,
weight_i1_h1_reg, weight_i2_h1_reg, hidden1_reg,
weight_i1_h2_reg, weight_i2_h2_reg, hidden2_reg,
weight_h1_o1_reg, weight_h2_o1_reg, output1_reg,
output_hidden1_reg, hidden2_adjustment_reg, output_output1_reg,
output1_adjustment_reg, hidden2_adjustment_reg, hidden1_adjustment_reg,
target_reg, LEARNRATE, epoch_reg, i_reg, output_hidden2_reg)
begin
--next values are stored in the current signal
state_next <= state_reg;
input1_next <= input1_reg;
input2_next <= input2_reg;
target_next <= target_reg;
hidden1_next <= hidden1_reg;
hidden2_next <= hidden2_reg;
output1_next <= output1_reg;
weight_i1_h1_next <= weight_i1_h1_reg;
weight_h1_o1_next <= weight_h1_o1_reg;
weight_h2_o1_next <= weight_h2_o1_reg;
output_hidden1_next <= output_hidden1_reg;
output_hidden2_next <= output_hidden2_reg;
output_output1_next <= output_output1_reg;
output1_adjustment_next <= output1_adjustment_reg;
hidden1_adjustment_next <= hidden1_adjustment_reg;
hidden2_adjustment_next <= hidden2_adjustment_reg;
i_next <= i_reg;
LEARNRATE <= to_float(0.5,LEARNRATE);
83
Anexos 84
epoch_next <= epoch_reg;
--=====next sate logic==========

case state_reg is
when init_value =>
input1_next <= to_float(0.0, input1_next);
target_next <= to_float(0.0, target_next);
hidden1_next <= to_float(0.2, hidden1_next);
hidden2_next <= to_float(-0.3, hidden2_next);
output1_next <= to_float(0.4, output1_next);
weight_i1_h1_next <= to_float(0.1, weight_i1_h1_next);
weight_i1_h2_next <= to_float(-0.2, weight_i1_h2_next);
weight_h1_o1_next <= to_float(0.5, weight_h1_o1_next);
weight_h2_o1_next <= to_float(-0.4, weight_h2_o1_next);
output_hidden1_next <= to_float(0.0, output_hidden1_next);
output_output1_next <= to_float(0.0, output_output1_next);
output1_adjustment_next <= to_float(0.0, output1_adjustment_next);
hidden1_adjustment_next <= to_float(0.0, hidden1_adjustment_next);
hidden2_adjustment_next <= to_float(0.0, hidden2_adjustment_next);
i_next <= "00";
LEARNRATE <= to_float(0.5,LEARNRATE);
epoch_next <= (others=>'0');
state_next <= in_sel;
--signals set to their initial values
when in_sel =>

--inputs selection
if i_reg="00" then
i_next <= "01";
elsif i_reg="01" then
i_next <= "10";
i_next <= "11";
else
84
Anexos 85

i_next <= "00";
epoch_next <= epoch_reg + 1;
end if;
state_next <= calc_hidden;
when calc_hidden =>

output_hidden1_next <= input1_reg*weight_i1_h1_reg + input2_reg*weight_i2_h1_reg +
hidden1_reg;
output_hidden2_next <= input1_reg*weight_i1_h2_reg + input2_reg*weight_i2_h2_reg +
hidden2_reg;
--calculate outputs for the hidden layer units
state_next <= calc_hidden_sig1;
--F[-6]=0.0
--F[-5]=0.0066
--F[-4]=0.0179
--F[-3]=0.0474
--F[-2]=0.1192
--F[-1]=0.2689
--F[0]=0.5
--F[1]=0.7310
--F[2]=0.8807
--F[3]=0.9525
--F[4]=0.9820
--F[5]=0.9933
--F[6]=1.0
when calc_hidden_sig1 =>

if output_hidden1_reg <= to_float(-6.0, output_hidden1_reg) then --x < -6
else
else
else
else
if output_hidden1_reg <= to_float(-2.0, output_hidden1_reg) then --x< -2
else
85
Anexos 86
else
if output_hidden1_reg >= to_float(6.0, output_hidden1_reg) then --x>6
else
if output_hidden1_reg >= to_float(5.0, output_hidden1_reg) then --x < 5
else
if output_hidden1_reg >= to_float(4.0, output_hidden1_reg) then --x<4
else
else
else
if output_hidden1_reg >= to_float(1.0, output_hidden1_reg) then --x>=1
else --x<0
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
state_next <= calc_hidden_sig2;
when calc_hidden_sig2 =>

else
else
else
else
86
Anexos 87

else
else
else
else
if output_hidden2_reg >= to_float(4.0, output_hidden2_reg) then --x<4
else
else
else
if output_hidden2_reg >= to_float(1.0, output_hidden2_reg) then --x>=1
else --x<0
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
state_next <= calc_out;
when calc_out =>

output_output1_next <= output_hidden1_reg*weight_h1_o1_reg +
output_hidden2_reg*weight_h2_o1_reg + output1_reg;
--calculate output unit's output value
state_next <= calc_output_sig;
when calc_output_sig =>

if output_output1_reg <= to_float(-6.0, output_output1_reg) then --x < -6
87
Anexos 88

else
else
else
else
if output_output1_reg <= to_float(-2.0, output_output1_reg) then --x< -2
else
if output_output1_reg <= to_float(-1.0, output_output1_reg) then --x< -1
else
if output_output1_reg >= to_float(6.0, output_output1_reg) then --x>6
else
if output_output1_reg >= to_float(5.0, output_output1_reg) then --x < 5
else
if output_output1_reg >= to_float(4.0, output_output1_reg) then --x<4
else
if output_output1_reg >= to_float(3.0, output_output1_reg) then --x < 3
else
if output_output1_reg >= to_float(2.0, output_output1_reg) then --x>2
else
if output_output1_reg >= to_float(1.0, output_output1_reg) then --x>=1
else --x<0
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
88
Anexos 89
state_next <= calc_output_adjustment;
when calc_output_adjustment =>

output1_adjustment_next <= output_output1_reg*(1-output_output1_reg)*(target_reg-
output_output1_reg);
--Calculate the error
state_next <= calc_hidden_adjustment;
when calc_hidden_adjustment =>

hidden2_adjustment_next <= output_hidden2_reg*(1-
output_hidden2_reg)*output1_adjustment_reg*weight_h2_o1_reg;
hidden1_adjustment_next <= output_hidden1_reg*(1-
output_hidden1_reg)*output1_adjustment_reg*weight_h1_o1_reg;
state_next <= weigh_adjustment;
when weigh_adjustment =>

weight_i1_h1_next <= weight_i1_h1_reg+LEARNRATE*hidden1_adjustment_reg*input1_reg;
weight_h1_o1_next <=
weight_h1_o1_reg+LEARNRATE*output1_adjustment_reg*output_hidden1_reg;
weight_h2_o1_next <=
weight_h2_o1_reg+LEARNRATE*output1_adjustment_reg*output_hidden2_reg;
hidden1_next <= hidden1_reg+LEARNRATE*hidden1_adjustment_reg;
hidden2_next <= hidden2_reg+LEARNRATE*hidden2_adjustment_reg;
output1_next <= output1_reg+LEARNRATE*output1_adjustment_reg;
state_next <= stop_condition;
when stop_condition =>

if epoch_reg = "0001001110001000" then
state_next <= done_training;
else
--epoch_next <= epoch_reg + 1;
state_next <= new_epoch;
end if;
when new_epoch =>

when done_training =>

state_next <= done_training;
when others =>

state_next <= init_value;
89
Anexos 90
end case;
end process;
z <= a xor b;
end training;
90
Anexos 91
Código en VHDL para el perceptrón

----------------------------------------------------------------------------------
-- Company:
-- Engineer: Ernesto Antonio Peña Serrato
--
-- Create Date: 22:01:39 03/31/2013
-- Design Name:
-- Module Name: perceptron - neurona
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- Uncomment the following library declaration if using

-- arithmetic functions with Signed or Unsigned values
use IEEE.NUMERIC_STD.ALL;
-- Uncomment the following library declaration if instantiating

-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity perceptron is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
z : out STD_LOGIC;
clock : in STD_LOGIC;
reset : in STD_LOGIC);
end perceptron;
architecture neurona of perceptron is

--===============STATE LABELS=====================
type state_type is (init_value, in_sel, net_calc, ak_calc, ek_calc, ek_eval, weigh_calc, et_eval,
done);
signal state_reg, state_next: state_type;
--====================SIGNALS=====================
signal w1_reg, w1_next: signed(7 downto 0);
signal w2_reg, w2_next: signed(7 downto 0);
91
Anexos 92
signal b_reg, b_next: signed(7 downto 0);

signal ak_reg, ak_next, dk_reg, dk_next,
ek_reg,ek_next, et_reg, et_next, p0_reg, p0_next,
p1_reg, p1_next, p2_reg, p2_next,alpha: signed(1 downto 0);
signal net_reg, net_next: signed(9 downto 0);
signal i_reg, i_next: unsigned(1 downto 0);
--signal h: signed(9 downto 0);
--signal a1, b1: signed(1 downto 0);
--signal w1, w2: signed(7 downto 0);
begin
--=====================CLOCK & RESET=======================
process(clock,reset)
begin
if reset='1' then
state_reg <= init_value;
elsif (clock'event and clock='1') then
state_reg <= state_next;
w1_reg <= w1_next;
w2_reg <= w2_next;
b_reg <= b_next;
i_reg <= i_next;
net_reg <= net_next;
ak_reg <= ak_next;
dk_reg <= dk_next;
ek_reg <= ek_next;
et_reg <= et_next;
p0_reg <= p0_next;
p1_reg <= p1_next;
p2_reg <= p2_next;
end if;
end process;
--=================STATE MACHINE============================
process(state_reg,w1_reg, w2_reg, b_reg,net_reg,i_reg,
ak_reg, dk_reg, ek_reg, et_reg, p0_reg, p1_reg, p2_reg)
begin
--=====signals initialization=====
state_next <= state_reg;
w1_next <= w1_reg;
w2_next <= w2_reg;
b_next <= b_reg;
net_next <= net_reg;
ak_next <= ak_reg;
dk_next <= dk_reg;
ek_next <= ek_reg;
et_next <= et_reg;
p0_next <= p0_reg;
p1_next <= p1_reg;
92
Anexos 93
p2_next <= p2_reg;

alpha <= "01";
i_next <= i_reg;
--=====next sate logic==========

case state_reg is
when init_value =>
net_next <= (others=>'0');
ak_next <= (others=>'0');
dk_next <= (others=>'0');
ek_next <= "01";
et_next <= "01";
p0_next <= (others=>'0');
alpha <= "01";
i_next <= "00";
w1_next <= (others=>'0');
w2_next <= (others=>'0');
b_next <= (others=>'0');
when in_sel =>

if i_reg="00" then
p0_next<="01";
p1_next<=(others=>'0');
dk_next<="01";
p0_next<="01";
p2_next<="01";
dk_next<="01";
p0_next<="01";
p1_next<="01";
dk_next<="01";
else
p0_next<="01";
p1_next<="01";
p2_next<="01";
dk_next<="00";
end if;
state_next <= net_calc;
when net_calc =>
93
Anexos 94
net_next <= p1_reg*w1_reg + p2_reg*w2_reg + b_reg*p0_reg;

state_next <= ak_calc;
when ak_calc =>

if net_reg>"0000000000" then
ak_next <= "01";
else
ak_next <= "00";
end if;
state_next <= ek_calc;
when ek_calc =>

ek_next <= dk_reg - ak_reg;
state_next <= ek_eval;
when ek_eval =>

if ek_reg /= "00" then
state_next <= weigh_calc;
elsif i_reg/="11" then
if i_reg = "11" then
i_next <= "00";
et_next <= "00";
else
i_next <= i_reg + 1;
end if;
else
state_next <= et_eval;
end if;
when weigh_calc =>

w1_next <= w1_reg + alpha*ek_reg*p1_reg;
w2_next <= w2_reg + alpha*ek_reg*p2_reg;
b_next <= b_reg + alpha*ek_reg*p0_reg;
et_next <= "01";
state_next <= et_eval;
when et_eval =>

if et_reg /= "00" then
if i_reg = "11" then
i_next <= "00";
et_next <= "00";
else
i_next <= i_reg + 1;
end if;
else
state_next <= done;
94
Anexos 95
end if;
when done =>

state_next <= done;
when others =>

state_next <= init_value;
end case;
end process;
z<=a and b;
end neurona;
95
Anexos 96
96
Anexos 97
Código en C++ para la red neuronal de retropropagación

// bpxorie1.cpp : Defines the entry point for the console
application.
//
#include "stdafx.h"
/* XOR backpropagation network*/

#include "conio.h"
#include "iostream"
#include "math.h"
using namespace std;
#define ITER 10000

#define LEARNRATE 0.5
// Function declaratation
void Train(float a, float b, float result);
void Run(float a, float b);
float Sigmoid(float num);
// Variable declaration
float input1; // The XOR input
float input2; // The XOR input
float target; // The desired XOR output
// The neural network variables (the neurons and the weights)

float hidden1 = 0.2; // These values should be random...
between -1.0 and 1.0
float hidden2 = -0.3;
float output1 = 0.4;
float weight_i1_h1 = 0.1;

float weight_i1_h2 = -0.2;
float weight_h1_o1 = 0.5;
float weight_h2_o1 = -0.4;
/*
* The main function
*/
int _tmain(int argc, _TCHAR* argv[]) {
// Train
for(int i=0; i<ITER; i++){
Train(1.0,1.0,0.0);
Train(1.0,0.0,1.0);
Train(0.0,0.0,0.0);
Train(0.0,1.0,1.0);
97
Anexos 98
// Show results
Run(0.0,0.0);
Run(0.0,1.0);
Run(1.0,0.0);
Run(1.0,1.0);
system("PAUSE");
return 0;
}
/*
* Name: Train
* Input: Two inputs and the desired result
* Pre: The inputs and results are floats in the range 0.0 -
1.0
* Post: The weight of the neural network are adjusted
(trained..)
*/
void Train(float a, float b, float result){
input1 = a;
input2 = b;
target = result;
float output_hidden1;
float output_output1;
// Calculate the outputs

output_hidden1 = input1 * weight_i1_h1 + input2
* weight_i2_h1 + hidden1;
output_hidden1 = Sigmoid(output_hidden1);

output_output1 = output_hidden1 * weight_h1_o1 +

output_hidden2 * weight_h2_o1 + output1;
output_output1 = Sigmoid(output_output1);
// Calculate the error

float output1_adjustment = output_output1 * (1-output_output1)
* (target - output_output1);
float hidden2_adjustment = output_hidden2 * (1-output_hidden2)
* output1_adjustment * weight_h2_o1;
float hidden1_adjustment = output_hidden1 * (1-output_hidden1)
* output1_adjustment * weight_h1_o1;
// Adjust the weights

98
Anexos 99
weight_i1_h1 = weight_i1_h1 + LEARNRATE * hidden1_adjustment *

input1;
input1;
input2;
input2;
weight_h1_o1 = weight_h1_o1 + LEARNRATE * output1_adjustment *
output_hidden1;
weight_h2_o1 = weight_h2_o1 + LEARNRATE * output1_adjustment *
output_hidden2;
hidden1 = hidden1 + LEARNRATE * hidden1_adjustment;
hidden2 = hidden2 + LEARNRATE * hidden2_adjustment;
output1 = output1 + LEARNRATE * output1_adjustment;
}
/*
* Name: Run
* Input: Two inputs
* Pre: The inputs are floats in the range 0.0 - 1.0
* Post: Shows the output of the neural network
*/
void Run(float a, float b){
input1 = a;
input2 = b;
float output_output1;
// Calculate the outputs, same code as the train function


output_output1 = output_hidden1 * weight_h1_o1 +

output_hidden2 * weight_h2_o1 + output1;
output_output1 = Sigmoid(output_output1);
// Show the result

cout << output_output1;
if(output_output1 >= 0.5) cout << "\t (1)";
if(output_output1 < 0.5) cout << "\t (0)";
cout << endl;
}
99
Anexos 100
/*
* Name: Sigmoid
* Input: One input
* Pre: The input is a float (positive or negative)
* Post: Returns the result of the sigmoid function
*/
float Sigmoid(float num) {
return (float)(1/(1+exp(-num)));
}
100
Anexos 101
Código en C++ para el perceptrón

// perceptron.cpp : Defines the entry point for the console
application.
//
#include "stdafx.h"
//#include "stdio.h"
#include "conio.h"
#include "iostream"
#include "math.h"
//#include <stdlib.h>
//#include <time.h>
using namespace std;
int z[4],selec,p[3];
int i=0,j=0;
float net=0.0,ak=0.0,err[4],errt=1.0,d[4],w[3],alpha=1.0,h[4];
void calcnet(void)
{
while(errt!=0.0)
{
err[0]=0.0;
err[1]=0.0;
err[2]=0.0;
err[3]=0.0;
errt=0.0;
for(j=0;j<=3;j++)
{
err[j]=0.0;
if(j==0)
{
p[1]=0;
p[2]=0;
}
else if(j==1)
{
p[1]=0;
p[2]=1;
}
else if(j==2)
{
p[1]=1;
p[2]=0;
}
else if(j==3)
{
p[1]=1;
p[2]=1;
}
ak=0.0;
101
Anexos 102
net=0.0;
for(i=0;i<=2;i++)
{
net=net+p[i]*w[i];
}
cout<<"net="<<net<<" ";
if(net>0)
{
ak=1.0;
}
err[j]=d[j]-ak;
if(err[j]!=0.0)
{
cout<<"error="<<err[j]<<"\n";
cout<<"Nueva iteracion,recalcular W\n";
errt=1.0;
for(i=0;i<=2;i++)
{
w[i]=w[i]+alpha*err[j]*p[i];
}
}
}
}
}
int _tmain(int argc, _TCHAR* argv[])

{
h[0]=1.5;
h[1]=0.5;
h[2]=1.5;
w[0]=1.5;
w[1]=1.5;
w[2]=0.5;
z[0]=0;
z[1]=0;
z[2]=0;
z[3]=0;
p[0]=1;
p[1]=0;
p[2]=0;
cout<<"Como desea entrenar la neurona?\n";
cout<<"1)Compuerta OR\n";
cout<<"2)Compuerta NOR\n";
cout<<"3)Compuerta AND\n";
cout<<"4)Compuerta NAND\n";
while(selec<=0||selec>4)
{
cin>>selec;
}
if(selec==1)
{
102
Anexos 103
d[0]=0.0;
d[1]=1.0;
d[2]=1.0;
d[3]=1.0;
}
if(selec==2)
{
d[0]=1.0;
d[1]=0.0;
d[2]=0.0;
d[3]=0.0;
}
if(selec==3)
{
d[0]=0.0;
d[1]=0.0;
d[2]=0.0;
d[3]=1.0;
}
if(selec==4)
{
d[0]=1.0;
d[1]=1.0;
d[2]=1.0;
d[3]=0.0;
}
calcnet();
cout<<"\nLa neurona ha sido entrenada\n";
cout<<"W(1)="<<w[1]<<"\n";
cout<<"W(2)="<<w[2]<<"\n";
cout<<"b="<<w[0]<<"\n\n";
cout<<"Evaluacion de la funcion de la neurona\n";
h[0]=0*w[1]+0*w[2]+w[0];
if(h[0]>0) z[0]=1;
h[1]=0*w[1]+1*w[2]+w[0];
if(h[1]>0) z[1]=1;
h[2]=1*w[1]+0*w[2]+w[0];
if(h[2]>0) z[2]=1;
h[3]=1*w[1]+1*w[2]+w[0];
if(h[3]>0) z[3]=1;
cout<<"Entradas Salida\n";
cout<<"X1 X2 Z\n";
cout<<"0 0"<<" "<<z[0]<<"\n";
cout<<"0 1"<<" "<<z[1]<<"\n";
cout<<"1 0"<<" "<<z[2]<<"\n";
cout<<"1 1"<<" "<<z[3]<<"\n";
//cout<<errt;
system("PAUSE");
return 0;
}
103

Implementacion de Una Red Neuronal en Un Fpga Con Lenguaje Descriptor de Hardware PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Implementacion de Una Red Neuronal en Un Fpga Con Lenguaje Descriptor de Hardware PDF

Cargado por

Copyright:

Formatos disponibles

INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERÍA

IMPLEMENTACIÓN DE UNA RED NEURONAL EN UN

QUE PARA OBTENER EL TÍTULO DE:

PEÑA SERRATO ERNESTO ANTONIO

DR. LÓPEZ CÁRDENAS RODRIGO

México, D.F. Febrero, 2014

Juan Fernando Davila Lopez

Corroborar que es posible implementar en hardware el entrenamiento de una red neural

 Implementar el algoritmo de entrenamiento del perceptrón

El hecho de contar con dispositivos lógicos programables de gran tamaño y la

El desarrollo tecnológico que se ha observado en los dispositivos lógicos programables,

– Neurociencia Computacional y Cognición Computacional: Comunicación Neuronal; Aprendizaje y

– Aplicación de la Computación Neuronal en Dominios Biomédicos, Clínicos y Medioambientales

La implementación hardware es un aspecto determinante objeto de este trabajo. Esto por

Las redes neuronales de manera inherente tienen un procesamiento masivamente

Estructura del proyecto terminal

Capítulo 1 Marco Teórico.

1.1. Redes Neuronales Artificiales

1.1.1. Principios básicos de las Redes Neuronales

 El procesamiento de información se lleva a cabo en muchos elementos simplemente llamados

Una red neuronal consiste en un gran número de elementos simples de procesamiento

Figura 1.1 Una neurona artificial simple

 El elemento procesador recibe varias señales

En la Figura 1.2 se puede observar un ejemplo de una neurona biológica.

Figura 1.2 Neurona biológica

1.1.2. Aplicaciones de las redes neuronales

Las características especiales de los sistemas de computación neuronal modernos

La computación neuronal provee un acercamiento mayor al reconocimiento y percepción

 Análisis y Proceso de señales

Conversión Texto a Voz: uno de los principales promotores de la computación neuronal en

La ventaja que ofrece la computación neuronal frente a las tecnologías tradicionales en la

Compresión de Imágenes: la compresión de imágenes es la transformación de los datos de

Reconocimiento de Caracteres: es el proceso de interpretación visual y de clasificación de

Reconocimiento de Patrones en Imágenes: una aplicación típica es la clasificación de

Problemas Combinatorios: en este tipo de problemas con solución mediante cálculo

Procesado de la Señal: en este tipo de aplicación existen tres clases diferentes de

Predicción: en el mundo real existen muchos fenómenos de los que conocemos su

Modelado de Sistemas: los sistemas lineales son caracterizados por la función de

Servo Control: un problema difícil en el control de un complejo sistema de

1.1.3 Arquitecturas típicas de las redes neuronales

Usualmente es conveniente mirar a las neuronas organizadas en capas. Típicamente las

1.1.3.1. Redes de una capa

Figura 1.3 Red de una capa

1.1.3.2 Redes multicapa

Figura 1.4 Red multicapa

Tabla 1-1 Redes neuronales multicapa más conocidas

N. DE CAPAS TIPOS DE CONEXIONES MODELO DE RED

1.1.4. Mecanismos de Aprendizaje

Durante el proceso de aprendizaje, los pesos de las conexiones en la red sufren

Un aspecto importante respecto al aprendizaje en redes neuronales es conocer cómo se

Estos criterios determinan lo que se conoce como la regla de aprendizaje de la red. De

 Redes Neuronales con aprendizaje supervisado.

La diferencia fundamental entre ambos tipos estriba en la existencia o no de un agente

Cuando el aprendizaje es OFF LINE se distingue entre una frase de aprendizaje o de

En las Redes con aprendizaje ON LINE no se distingue entre fase de entrenamiento y de

Tabla 1-2 Tipos de redes con aprendizaje supervisado más conocidas

TIPO DE APRENDIZAJE SUPERVIZADO MODELO DE RED

Tabla 1-3 Tipos de redes con aprendizaje no supervisado más conocidas

TIPO DE APRENDIZAJE NO SUPERVIZADO MODELO DE RED

1.1.5. Entrenamiento de las redes neuronales artificiales

Una de las principales características de las RNA es su capacidad de aprendizaje. El

Los algoritmos de entrenamiento o los procedimientos de ajuste de los valores de las