Post on 25-Jun-2022
SISTEMA DIGITAL DE RECONOCIMIENTO DE PATRONES MEDIANTE REDES
NEURONALES CONVOLUCIONALES
MARÍA ALEJANDRA SIERRA LIZARAZO
PONTIFICIA UNIVERSIDAD JAVERIANA
FACULTAD DE INGENIERÍA
DEPARTAMENTO DE INGENIERÍA ELECTRÓNICA
BOGOTÁ D.C, COLOMBIA
JUNIO DE 2017
SISTEMA DIGITAL DE RECONOCIMIENTO DE PATRONES MEDIANTE REDES
NEURONALES CONVOLUCIONALES
MARÍA ALEJANDRA SIERRA LIZARAZO
T.G. 1625
Trabajo de grado presentado como requisito parcial para optar el título de:
Ingeniería Electrónica
Director:
Catalina Alvarado Rojas, Ph.D.
Codirectores:
Carlos Alberto Parra Rodríguez, Ph.D.
Luisa Fernanda García Vargas, M.Sc.
Pontificia Universidad Javeriana
Facultad de Ingeniería
Departamento de Ingeniería Electrónica
Bogotá, Colombia
2017
PONTIFICIA UNIVERSIDAD JAVERIANA
FACULTAD DE INGENIERÍA
DEPARTAMENTO DE INGENIERÍA ELECTRÓNICA
RECTOR MAGNÍFICO: P. JORGE HUMBERTO PELAEZ PIEDRAHITA, SJ.
DECANO ACADÉMICO: ING. JORGE LUÍS SANCHEZ TÉLLEZ
DIRECTOR DE CARRERA: ING. ALEJANDRA GONZÁLES
DIRECTOR DE PROYECTO: ING. CATALINA ALVARADO ROJAS
CODIRECTORES DEL PROYECTO: ING.CARLOS ALBERTO PARRA RODRÍGUEZ
ING. LUISA FERNANDA GARCÍA VARGAS
Agradecimientos
Al terminar este proceso, es inevitable agradecer a todos los que hicieron parte de él. Gracias
Dios, porque me diste la oportunidad de decidir por mis medios lo que sería mi vida y me
permitiste luchar cada día para cumplir mis metas llena de bendiciones incalculables. Gracias
padres, por luchar por una familia increíble y apoyarme siempre que sentía la necesidad de
poner a flote mis ideas, por más locas que pareciesen; gracias hermanos por estar ahí con el
único objetivo de alegrarme la vida.
Gracias a quienes hicieron esto posible, a las ingenieras Luisa y Catalina por ser mujeres
ejemplo a seguir, por dejarme ver que lo más importante de hacer las cosas es apasionarse por
ellas y por mostrarme en esas horas de clase y de reuniones, lo que me gustaría hacer de aquí en
adelante. Al ingeniero Carlos por su franqueza, sinceridad, grandes ideas y sobre todo por
aceptar la dirección de mi trabajo de grado cuando fue necesario. A la familia Ojeda Cardona,
por hacerme parte de ella y apoyarme día tras día cuando me encontraba lejos de casa. A mis
amigos y futuros colegas, por ser un grupo de personas increíbles que además de estar ahí
pasando por los mismos momentos, siempre me brindaron una palabra o un consejo que
ayudara, claro está, con una gota de humor y una pizca de bullying.
Gracias por aquel día en que dijiste que esperarías a que fuera ingeniera para sentirte mucho
más orgullosa de mi… ¡Gracias abuela, porque desde donde estas sé que sientes la misma
felicidad que yo!
Tabla de contenido
Introducción ................................................................................................................................................... 1
Marco Teórico ................................................................................................................................................ 2
2.1. Imágenes: procesamiento y binarización ............................................................................................ 2
2.2. Redes Neuronales Artificiales ............................................................................................................. 3
2.2.1. Redes Neuronales Artificiales de Topología Clásica (ANN) ....................................................... 3
2.2.2. Redes Neuronales Artificiales Convolucionales (CNN) .............................................................. 4
2.2.2.1. Capa Convolucional .............................................................................................................. 5
2.2.2.2. Capa de Maxpooling ............................................................................................................. 5
2.2.2.3. Transferencia de conocimiento ............................................................................................. 6
2.2.2.4. LeNet5: Red Neuronal Convolucional para la identificación de dígitos escritos .................. 6
2.3. Redes Neuronales Convolucionales Artificiales en FPGA ................................................................. 7
2.3.1. ¿Qué es una FPGA? ..................................................................................................................... 7
2.3.2. Implementaciones de CNN en FPGA .......................................................................................... 7
Objetivo Del Proyecto .................................................................................................................................... 9
3.1. Objetivo Específico 1: Diseño e Implementación de la Capa Convolucional ..................................... 9
3.2. Objetivo Específico 2 y 5: Creación de la Base de Datos y Diseño e Implementación de la CNN en
Software (Entrenamiento) ........................................................................................................................ 11
3.3. Objetivo Especifico 3: Diseño e Implementación de la CNN en FPGA (Prueba) ............................ 11
3.4. Objetivo Específico 4: Validación de resultados .............................................................................. 12
Desarrollo ..................................................................................................................................................... 13
4.1. Fase De Entrenamiento ..................................................................................................................... 13
4.2. Fase De Prueba .................................................................................................................................. 14
Protocolo De Pruebas y Análisis De Resultados .......................................................................................... 17
5.1. Fase De Entrenamiento ..................................................................................................................... 17
5.1.1. Creación de la base de datos....................................................................................................... 17
5.1.2. Validación del entrenamiento de LeNet5 ................................................................................... 18
5.1.3. Validación del entrenamiento de la CNN de identificación de vocales del lenguaje de señas... 19
5.1.4. Validación del entrenamiento de la CNN exclusivo para cada voluntario ................................. 21
5.2. Fase De Prueba .................................................................................................................................. 24
5.2.1. Validación de funcionalidad: comparación de datos de entrenamiento ..................................... 24
5.2.2. Validación de funcionalidad: cálculo del error de entrenamiento .............................................. 24
5.2.2. Validación uso de recursos ......................................................................................................... 26
Conclusiones Y Recomendaciones .............................................................................................................. 27
Bibliografía .................................................................................................................................................. 28
Tabla de Figuras
Figura 1. Red neuronal artificial de topología clásica, explicación de la topología general y de la
neurona como unidad....................................................................................................................... 3
Figura 2. Red neuronal artificial convolucional, explicación de la topología general. ................... 4
Figura 3. Ejemplo del movimiento de los kernel en una imagen .................................................... 5
Figura 4. Topología final de la Red Convolucional Artificial LeNet5. Tomada de [8]. ................. 7
Figura 5. Circuito general de una FPGA, recursos básicos y pines de conexión para entrada y salida
de datos o sistemas periféricos periféricos. ..................................................................................... 7
Figura 6. Procesamiento de la imagen y resultado del paso por la capa convolucional en software,
(a) imagen original adquirida en formato de mapa de bits, (b) pre procesamiento de la imagen:
binarización mediante el umbral de Otsu, (c) Resultado de la convolución de la imagen binarizada
con 9 filtros convolucionales ......................................................................................................... 10
Figura 7. Diagrama de bloques de la neurona convolucional implementada en hardware. .......... 10
Figura 8 . Diagrama de bloques de la unidad neuronal básica para las capas totalmente conectadas.
....................................................................................................................................................... 12
Figura 9. Imágenes de la base de datos (voluntario 1), representación de las vocales del lenguaje
de señas. ......................................................................................................................................... 13
Figura 10. Ejemplos de la base de datos para el entrenamiento de la red LeNet5, dígitos escritos.
....................................................................................................................................................... 13
Figura 11. Ejemplos de la base de datos binarizada de la representación de las vocales en el lenguaje
de señas .......................................................................................................................................... 14
Figura 12. Representación gráfica de la base de datos .................................................................. 18
Figura 13. Diagrama de barras de la diferencia entre los errores de entrenamiento y prueba de
LeNet5. .......................................................................................................................................... 18
Figura 14. Diagrama de barras de la diferencia entre el error de prueba y el error de entrenamiento
cuando se varía la tasa de aprendizaje en cada iteración ............................................................... 19
Figura 15. Diagrama de barra de la diferencia entre el error de prueba y el error de entrenamiento
cuando se varia el número de neuronas en la capa oculta de revisión los datos en cada iteración 20
Figura 16. Diagrama de barra de la diferencia entre el error de prueba y el error de entrenamiento
cuando se varia el número de épocas de revisión los datos en cada iteración ............................... 20
Figura 17. Porcentajes de la matriz de confusión para el voluntario 1 .......................................... 21
Figura 18. Porcentajes de la matriz de confusión para el voluntario 2 .......................................... 21
Figura 19. Porcentajes de la matriz de confusión para el voluntario 3 .......................................... 22
Figura 20. Ejemplos de imágenes binarizadas de la representación de las vocales 𝑎 y 𝑒, para los
tres voluntarios respectivamente. .................................................................................................. 22
Figura 21. Comparación entre las imágenes binarizadas de la representación de las vocales 𝑢 e 𝑖, del voluntario 1 y el voluntario 3................................................................................................... 23
Figura 22. Matriz de confusión para todos los voluntarios, porcentajes de sensibilidad y
especificidad para la implementación final en software ................................................................ 23
Figura 23. Diagrama de barras del error de prueba de la arquitectura implementada en FPGA ... 26
1
Introducción
Los sistemas de aprendizaje de máquina, que han tenido un gran avance en los últimos años, permiten
el desarrollo de tecnologías de toma de decisiones, reconocimiento y predicción de patrones, para
aplicaciones cotidianas. Como mencionan en [1], los ordenadores muestran un gran avance en cuanto al
procesamiento lógico, cada vez más rápido y eficiente; sin embargo, se ha cuestionado en diversas ocasiones
si en realidad las máquinas pueden llegar a pensar o a entender aquello que pretende como respuesta el
usuario común. Adicional a esto, el sistema de aprendizaje del ser humano ha sido tomado como referencia
para el desarrollo de técnicas bio-inspiradas, teniendo en cuenta que se considera al cerebro como el sistema
de cómputo más eficiente y a la vez más complejo [2].
Cuando se hace referencia al aprendizaje de máquina, se debe realizar la implementación de un
algoritmo lógico-matemático, que sirve como base del sistema en el procesamiento de los datos de entrada.
Dichos datos, representan características del patrón a clasificar o detectar, sin embargo, en deep learning, o
aprendizaje profundo, el objetivo es que los mismos algoritmos extraigan las características del objeto sin
hacer un procesamiento previo.
Debido a esto, en las últimas décadas se han propuesto numerosos sistemas cerebro-inspirados (brain-
inspired) a partir de redes neuronales artificiales (ANN), que constan de variadas topologías y permiten
diferentes características de aprendizaje. En la mayoría de los casos, se han diseñado algoritmos en software
para la implementación de las topologías de ANN. Sin embargo, en la actualidad, se requiere un
procesamiento en tiempo real, portátil, energéticamente eficiente y con capacidades de comunicación y
envío de la información en paralelo. De esta manera, el estudio de la implementación de estas redes en
hardware es de gran interés [3].
Este trabajo de grado se desarrolló en hardware una aplicación de ANN de topología convolucional,
a partir de un sistema de cómputo con capacidades limitadas, una FPGA. Estas redes, relativamente recientes
y que han tenido una gran popularidad, están basadas en la corteza visual primaria del cerebro, mejorando
las técnicas de reconocimiento de patrones al aumentar la velocidad de comunicación entre las neuronas
artificiales de la red por un algoritmo de probabilidad diferente [4]. Se presenta en este documento una
implementación en FPGA de este tipo de topologías, debido a que estos sistemas tienen la capacidad de
hacer procesamiento en paralelo de los datos.
Por lo anterior, en el presente documento se le introduce al lector dentro de un marco teórico en donde
se presentan preámbulos y referencias de los temas de procesamiento de imágenes, redes neuronales
convolucionales y la implementación de estas en FPGA. Seguido a esto, el lector conocerá los objetivos del
proyecto y como fueron solucionados, de manera tal que podrá ampliar esta información en el capítulo de
Desarrollo teniendo en cuenta cada una de las especificaciones y procesos para la etapa de entrenamiento y
prueba.
Finalmente, se hace un análisis de resultados con las implementaciones en cada etapa de una topología
en específico, teniendo esto en cuenta, se presentan conclusiones y mejoras a futuro para la continuación
del proyecto.
2
Capítulo 2
Marco Teórico
2.1. Imágenes: procesamiento y binarización
Las imágenes, como señales en dos dimensiones, han permitido la representación visual de sistemas
en un determinado tiempo. Los sensores de captura de imágenes funcionan censando la cantidad de
radiación, de manera que cada sensor presenta un ancho de banda determinado dependiendo de la porción
del espectro que quiere captar.
Una imagen proporciona información visual en un instante de tiempo determinado, lo que implica,
que el procesamiento de la misma, para análisis e investigación, es de los pasos con mayor importancia en
la toma de decisiones [3]. Así como las señales, las imágenes, se pueden ver como una función en donde
variables independientes, generaran un valor en una variable dependiente. Dicha función, se genera a través
del muestreo en donde cada muestra de una matriz se conoce como un píxel, lo que implica que, entre
mayor número de píxeles muestreados mayor resolución o mayor tamaño, o que al disminuir el muestreo
puede aparecer distorsión o efectos no deseados o disminuir el tamaño.
La binarización de una imagen, genera que los valores de la variable dependiente, sean unos y ceros,
lo que se conoce también como imágenes a blanco y negro, respectivamente. Por tanto, el hecho de binarizar
una imagen implicará, hacer un proceso de umbralización, en donde se pretende separar los objetos que la
componen, por ejemplo, el objeto de interés y el fondo de la imagen.
La binarización de la imagen puede ser global o local, la primea implica que un mismo umbral se
aplica a toda la imagen, y la segunda determina un umbral para cada uno de los píxeles de acuerdo con el
método utilizado o los píxeles vecinos. Para binarizar una imagen, mediante umbralización global, se utiliza,
generalmente, el histograma de la misma. Este último, representa la cantidad de veces que aparece un color
o un nivel de grises en la imagen, permitiendo también el análisis de distribución de los mismos. Cabe
aclarar, que existen en la actualidad diversos métodos de binarización, teniendo como base el histograma
de la imagen, además actualmente, existen diversos métodos de procesamiento y umbralización de
imágenes, diseñados en torno a aplicaciones específicas, que permiten resaltar y administrar la información
relevante y necesaria que quiere el usuario final.
Uno de los métodos de binarización comúnmente utilizado es conocido como el método de
segmentación del umbral de Otsu, que ha representado una de las técnicas más simples y con buenos
resultados a lo largo del desarrollo de procesamiento digital de imágenes. De esta manera, el método trabaja
calculando el histograma de una imagen y escogiendo un umbral óptimo de separación entre píxeles blancos
y negros; para determinar dicho umbral, el algoritmo disminuye la varianza(1) intra-clase y aumenta la
varianza entre-clase.
𝜎2 = 𝑃1𝑃2(𝜇1 − 𝜇2)2 (1)
Como se observa en (1), la varianza depende de 𝑃1 y 𝑃2, que son las probabilidades de pertenecer a
cada uno de los grupos de píxeles, y de 𝜇1 y 𝜇2 que representan los valores medios de cada uno de los
grupos.
El método consiste en que mientras el umbral “temporal” (𝑢), sea menor al máximo nivel de gris de
la imagen, se calcula la varianza(1), de manera que si esta resulta mayor a la varianza máxima anterior el
3
nuevo umbral será el valor de 𝑢. Es importante notar que, la varianza máxima inicial es cero y que 𝑢 tomará
valores desde 𝑢 = 1 hasta 𝑢 = 𝐺𝑚𝑎𝑥 − 1 [4].
2.2. Redes Neuronales Artificiales
2.2.1. Redes Neuronales Artificiales de Topología Clásica (ANN)
En el desarrollo de sistema bio-inspirados, el cerebro siempre ha sido tenido en cuenta como el mejor
sistema de cómputo. Gracias a esto, el desarrollo de algoritmos inspirados en él ha sido estudiando desde
hace ya varios años.
Una red neuronal artificial, como se define en [5], es un conjunto de unidades aditivas (neuronas)
organizadas en capas e interconectadas entre sí; en donde cada una de las conexiones cuenta con un valor
de identificación llamado peso. Los pesos, se multiplican con el valor de entrada a la neurona y
posteriormente, esta, suma cada uno de los resultados de los productos para entregar un valor final.
Generalmente, cada una de las neuronas cuenta con una función de activación, la cual conecta los pesos con
la entrada y determina el estado de la neurona [6], estas funciones pueden ser operaciones vectoriales
(producto punto) u operaciones en términos de la distancia.
El entrenamiento de las ANN es supervisado, es decir, que recibe las etiquetas de los datos a ser
clasificados. Adicionalmente, implementa un algoritmo feedforward, que consiste en una realimentación de
la salida, es decir, que la ANN recibirá las características del patrón a clasificar, hará las operaciones en
cada capa y posteriormente comparará el valor de salida con la etiqueta real, si esta etiqueta es correcta
permitirá el paso del dato siguiente, si no, se devolverá modificando los pesos de las neuronas hasta que la
salida sea lo más cercano al valor de la etiqueta real [5].
En la Figura 1, se observa la imagen general de una red neuronal de topología clásica, la cual está
compuesta por un conjunto organizado de capas y los pesos de las neuronas son representados por las flechas
que las interconectan entre sí. En primer lugar todas la ANN cuentan con una capa de entrada de los datos,
la cual recibe las características 𝑥𝑛 del patrón a clasificar; seguido a esto se encuentran las capas ocultas, el
número de estas capas además del número de las neuronas depende del entrenamiento y de la aplicación
para la cual es usada la ANN. Finalmente, se tiene la capa de clasificación, la cual arrojará la etiqueta final
del dato clasificado; es importante aclarar que la etiquetas que recibe la red neuronal son etiquetas binarias
y que el número de neuronas de la capa de clasificación depende del número de clases en las que están
divididos los datos.
Figura 1. Red neuronal artificial de topología clásica, explicación de la topología general y de la neurona como unidad
4
2.2.2. Redes Neuronales Artificiales Convolucionales (CNN)
En el desarrollo de sistemas inteligentes, como se afirma en [1], las redes neuronales convolucionales
han sido el mayor éxito en sistemas bio-inspirados de aprendizaje de máquina; sus inicios radican en la
neurociencia, cuando los neurólogos David Hubel y Torsten Wiesel investigaron, durante aproximadamente
10 años, el sistema de visión de los mamíferos. Los experimentos consistieron en mirar la actividad neuronal
de un gato cuando se le proyectaban, en un lugar específico, una serie de imágenes; obteniendo como
resultado que las neuronas respondían fuertemente a diversos patrones de iluminación. En lo que al deep
learning respecta, más allá de la fisiología para llevar la imagen del ojo al cerebro, es concentrarse en la
corteza visual primaria de este último, ubicada en la parte posterior de la cabeza. La anatomía de esta corteza,
está dispuesta en mapas bidimensionales, lo que es análogo a matrices de dos dimensiones cuyos potenciales
de acción varían de acuerdo a los estímulos recibidos, además de esto, la corteza visual primaria cuenta con
células simples, representadas artificialmente con funciones lineales de un sistema, y células complejas, que
responden a pequeños cambios de iluminación.
En los algoritmos de las CNN, se cuenta con una topología similar a las tres características de la
anatomía de la corteza visual primaria, la primera es la capa convolucional que recibe el patrón de entrada,
siendo esta comparada con los mapas bidimensionales anatómicos, la explicación a profundidad de esta
capa será explicada en el apartado 1 de este subtítulo. Las células simples, están representadas por la capa
de rectificación lineal, que se encarga de igualar a cero todos los resultados obtenidos de símbolos negativos.
Finalmente, las células complejas, están representadas por la capa de maxpoolling, que se encarga de
seleccionar un conjunto de datos de la salida de la capa rectificación lineal y modificarlos de acuerdo a
diversos métodos, que serán explicados más adelante. Cabe aclarar, que el entrenamiento en CNN también
se hace mediante el método de feedforward, además de que la compone también una ANN como capa de
salida, y de esta forma los parámetros de los filtros convolucionales y los pesos de la red se van modificando
de acuerdo a las salidas del sistema.
En la Figura 2 se puede observar la topología de una CNN, la cual recibe un patrón de entrada que
interactúa con un filtro convolucional, seguido a esto con el selector de datos para la linealización y
finalmente la ANN para la clasificación final.
Figura 2. Red neuronal artificial convolucional, explicación de la topología general.
5
2.2.2.1. Capa Convolucional
La capa convolucional de las CNN es el factor principal de estas, debido a que permite que se reciba
el patrón puro a clasificar y no características extraídas del mismo.
Como su nombre lo indica, la capa convolucional cuenta con una operación llamada convolución. La
convolucion es la operación del cálculo del área bajo la curva del producto entre dos funciones, una de estas
rotada en torno al origen como se ve en la ecuación (2), y en función de un tiempo continuo 𝜏.
𝑦(𝑡) = 𝑥(𝑡) ∗ ℎ(𝑡) = ∫ 𝑥(𝜏)ℎ(𝑡 − 𝜏) 𝑑𝜏∞
−∞
(2)
Contrario a lo anterior, para las aplicaciones de aprendizaje de máquina, tal como se referencia en
[1], la convolución se realiza en tiempo discreto y generalmente sobre arreglos multidimensionales; para el
caso de las CNN los arreglos son: segmentos de píxeles de la imagen de entrada (𝐼(𝑚, 𝑛)) y el kernel (𝐾(𝑖 −𝑚, 𝑗 − 𝑛), que es el parámetro adaptado por el algoritmo de aprendizaje.
Lo anterior, significa que teniendo en cuenta la definición de (2) se puede hacer el cálculo de la
convolución entre los arreglos como una sumatoria del corrimiento o desplazamiento del uno sobre el otro,
sin embargo no puede ser infinita debido a que los arreglos tienen la obligatoriedad de que son de dimensión
finita. De esta manera, en (3) la ecuación muestra la convolución en dos dimensiones para el procesamiento
de datos en las CNN.
𝑆(𝑖, 𝑗) = (𝐼 ∗ 𝐾)(𝑖, 𝑗) = ∑ ∑ 𝐼(𝑚, 𝑛)𝐾(𝑖 − 𝑚, 𝑗 − 𝑛)
𝑛𝑚
(3)
Para el caso de (3), 𝑚 y 𝑛 son las dimensiones de la imagen filas y columnas, respectivamente, y las
variables 𝑖 y 𝑗, indican el corrimiento del kernel en filas y columnas sobre la misma. Por ejemplo, en la
Figura 3, las dimensiones de la imagen son 𝑚 = 4 y 𝑛 = 4, pero las posiciones de los kernel son diferentes
para cada caso; en el Kernel 1 la posición 𝑖 = 1 y la posición 𝑗 = 1, en el Kernel 2 la posición 𝑖 = 2 y la
posición 𝑗 = 2.
Figura 3. Ejemplo del movimiento de los kernel en una imagen
De acuerdo a (3), la convolución del kernel y la imagen para el ejemplo de la Figura 3 tendrá como
resultado en su primera iteración lo que se muestra en (4).
𝑆(1,1) = (𝐼 ∗ 𝐾)(1,1) = [𝑎 𝑏𝑐 𝑑
] ∗ [𝑤 𝑥𝑦 𝑧] = 𝑎𝑤 + 𝑏𝑥 + 𝑐𝑦 + 𝑑𝑧
(4)
Es notorio, finalmente, que en la operación de convolución en dos dimensiones no se está haciendo
la rotación de ninguna de las funciones (Imagen o Kernel) en torno al origen, debido a esto, esta operación
puede verse más claramente como una correlación entre las matrices operadas; lo que permite, que en las
CNN no todos los datos de la entrada se conecten a cada una de las neuronas (kernel) si no que más bien
genera un proceso eficiente de generación de imágenes nuevas por conjuntos de datos, aumentando la
eficiencia en el algoritmo, permitiendo la disminución de los tiempos de cómputo y logrando establecer
características como detección de bordes o formas en la imagen o patrón de entrada a clasificar.
6
2.2.2.2. Capa de Maxpooling
La capa de maxpooling se genera principalmente como una manera de reducción de los datos de
entrada a la siguiente capa, en esta, se agrupan píxeles de la imagen y se encunetra un patrón de relación
entre ellos [1] que remplaza la salida de la capa convolucional sin perder lo que ya fue detectado. Esta capa,
además, ayuda al sistema a tolerar modificaciones en la entrada generando que la salida sea
aproximadamente invariante.
Existen diversos métodos de agrupación implementados en esta capa, sin embargo, siempre se
garantiza que estos tomen valores en un área no muy amplia de vecinos rectangulares, lo que evita la pérdida
de información en la imagen de salida de la agrupación. Algunos de los métodos más usados para la decisión
de la generación del nuevo dato son: cálculo del promedio, cálculo de la mediana, identificación de la moda,
identificación del dato mayor, entre otros.
2.2.2.3. Transferencia de conocimiento
Cuando se habla de técnicas de regresión y clasificación, se establecen algoritmos o sistemas
determinados para aplicaciones específicas, sin embargo, muchos de estos sistemas, están ligados a datos
fijos y establecidos, de manera que cuando el sistema recibe un patrón nuevo o una característica diferente,
este debe ser reconstruido totalmente [1].
Como se menciona en [7], la transferencia de conocimiento está basada en reconocer y aplicar los
conocimientos y tareas anteriores a nuevas tareas, logrando así extraer el conocimiento de uno o más fuentes
y aplicarlo a un sistema nuevo. El reto entonces no es la transferencia de conocimiento sino establecer los
parámetros a transferir.
Para el aprendizaje de máquina, y especialmente aplicaciones de aprendizaje profundo es muy usual
hacer sistemas de conocimiento transferido aplicándolos a nuevas soluciones, debido a que la clasificación
en bruto de un sistema requiere de al menos 3000 datos para entrenamiento de acuerdo con lo referido en
[1]. Entonces, se establece que los parámetros a transferir hacen referencia a los datos (vectores o valores)
que garantizan el funcionamiento del sistema inicial. Por ejemplo, al hacer transferencia de conocimiento
en una máquina de vectores de soporte (SVM) lo ideal es que se pasen los vectores de soporte de esta
máquina al segundo sistema. En conclusión, para aprendizaje de máquina, la transferencia de conocimiento
se puede interpretar como la inicialización de los valores del sistema transferido para su posterior
entrenamiento.
2.2.2.4. LeNet5: Red Neuronal Convolucional para la identificación de dígitos escritos
Yann LeCun, es actualmente el director del Departamento de Investigación en Inteligencia Artificial
de Facebook. Su área de investigación principal está ligada a la percepción visual de patrones, especialmente
con redes de transformadores gráficos y CNN.
Durante los últimos años Yann LeCun, con su equipo de trabajo, desarrollo una CNN capaz de
reconocer dígitos manuscritos o impresos por una máquina, a la cual llamaron LeNet5 [8]. Esta CNN cuenta
con una base de datos de 5000 dígitos (Figura 10) escritos a mano, con dimensión de [28𝑥28] píxeles. Su
topología original tiene una capa convolucional de 20 filtros de tamaño [5𝑥5] y corrimiento de 1 píxel tanto
en filas como en columnas, seguida de una rectificación lineal y una capa de maxpooling con agrupamiento
de 4 píxeles y corrimiento de 2 píxeles en filas y en columnas, finalmente cuenta con una ANN de una capa
oculta de 8 neuronas y una capa de salida de 10 neuronas. Sin embargo, con el avance de los protocolos de
pruebas de esta topología, se generaron curiosidades nuevas en cuanto a la rotación, la translación, la forma,
el ancho e incluso la escala del símbolo escrito, lo que generó una topología más robusta (Figura 4)
permitiendo que el ruido de las imágenes de entrada diese la clasificación correcta de la etiqueta del dato.
Es importante resaltar, que esta CNN ha sido de gran ayuda en cuanto a modelos de transferencia de
conocimientos, como, por ejemplo, la identificación de patrones de letras manuscritas o impresas.
7
Figura 4. Topología final de la Red Convolucional Artificial LeNet5. Tomada de [8].
2.3. Redes Neuronales Convolucionales Artificiales en FPGA
2.3.1. ¿Qué es una FPGA?
La FPGA, Field Programmable Gate Array, considerada, tal como su nombre lo indica, como un
dispositivo programable, es una matriz bidimensional de bloques lógicos configurables capaces de
interconectarse entre sí, mediante conmutadores que unen las pistas para la configuración de los elementos
lógicos dispuestos en bloques [9].
Las FPGA se componen básicamente de tres elementos principales. El primero de ellos son los
bloques lógicos, cuya arquitectura cuenta con módulos de lógica combinatoria (independientes del reloj del
sistema) y de lógica secuencial (dependientes de la señal de reloj del sistema). El segundo elemento principal
con el que se componen las FPGA, es la arquitectura de interconexión, que permite recursos de ruteo entre
los bloques de circuitos lógicos establecidos por el usuario. Finalmente, la FPGA cuenta con bloques
memoria que permiten el almacenamiento remoto o inicializado de datos para la conexión de los bloques.
La Figura 5. Circuito general de una FPGA, recursos básicos y pines de conexión para entrada y salida de
datos o sistemas periféricos., presenta un sistema general de la configuración interna de la FPGA.
Figura 5. Circuito general de una FPGA, recursos básicos y pines de conexión para entrada y salida de datos o sistemas
periféricos.
periféricos.
8
Lo anterior le permite al usuario final dividir el circuito digital en bloques básicos y asignarlos al
sistema de ruteo del dispositivo. Entre las ventajas del uso de la FPGA es que genera un sistema hardware
de prototipo rápido e interfaz amigable con el programador. Sin embargo, según [9], las FPGA cuentan con
la infalible desventaja relacionada con el uso energético ineficiente y los retardos que se generan de acuerdo
al número de elementos lógicos utilizado. Como consecuencia de esto, en la actualidad, las compañías estás
trabajando, no para disminuir el retardo que de por sí presentan los elementos lógicos en la conexión, sino
que también, implementan sistemas de reloj a las tarjetas cuya frecuencia sea menor y por tanto su tiempo
de computo más rápido [10].
2.3.2. Implementaciones de CNN en FPGA
Las CNN han demostrado una amplia aplicación, sobretodo en estudios de visión por computación y
reconocimiento de sistemas de audio. Con el objetivo de mejorar los algoritmos, reducir tiempo de cómputo
y aumentar la eficiencia de estas redes, se han creado diversas plataformas de implementación hardware
que permiten la comprobación de los sistemas de clasificación; dichas plataformas se han implementado en
tarjetas de procesamiento gráfico (GPU) y FPGA, generando incluso comparaciones entre estas últimas.
En lo que concierne a la implementación de las CNN en FPGA, como se indica en [11] , se tiene
mayor ahorro energético y menor retardo temporal en los procesos de clasificación, comparada con otros
dispositivos. Por otra parte, en [12], los autores afirman que el hecho de poder tener un sistema digital
hardware con procesamiento en paralelo presenta una manera efectiva de obtener los resultados deseados
guiados por tiempos de computación muy bajos de acuerdo al reloj del sistema, además de la reducción del
ancho de banda y la creación de arquitecturas flexibles adaptadas a la aplicación correspondiente.
Las características que hacen que las CNN sean implementadas en FPGA, nombradas en [12], radican
sobretodo en ver este algoritmo como un conjunto de operaciones básicas repetitivas, tarea que los sistemas
digitales programables logran desarrollar muy bien. En primer lugar, las FPGA cuentan con numerosos
bloques de procesamiento digital de las señales, proporcionando una implementación eficiente del proceso
de dichas operaciones, y, en segundo lugar, se cuenta en las FPGA con un sistema de ruteo de fácil
programación de manera que se usa la menor cantidad de unidades lógicas posibles.
Finalmente, cabe aclarar que para el desarrollo de estas aplicaciones en FPGA es necesario un amplio
uso de bloques de memoria [11], debido a que para las fases del proceso de desarrollo se implementan
memorias auxiliares que posteriormente se comparan para la disminución de las tasas de error. Además de
esto, para la validación de la implementación se dejan fijos los valores de las memorias de manera que
después estén listos para ser leídos.
9
Capítulo 3
Objetivo Del Proyecto
El objetivo general propuesto para este proyecto es implementar en FPGA una red neuronal
convolucional artificial capaz de identificar las cinco vocales del lenguaje de señas, utilizado por personas
con discapacidad auditiva.
Para el desarrollo del sistema se plantearon 5 objetivos específicos, de manera que se logrará hacer
la implementación final y la validación de los resultados obtenidos. A continuación, se muestran los
objetivos específicos trazados:
1. Diseñar e implementar la arquitectura de la capa convolucional, para la extracción de
características de los patrones, en hardware y software.
2. Diseñar e implementar una ANN de topología convolucional en software y calcular el error de
entrenamiento.
3. Diseñar e implementar la arquitectura del sistema digital para programar una ANN de topología
convolucional en FPGA, de acuerdo a los parámetros obtenidos en software.
4. Validar estadísticamente los resultados de la clasificación mediante medidas de desempeño como
sensibilidad, especificidad y error de la etapa de prueba.
5. Construir una base de datos etiquetada de imágenes de lenguaje de señas con las cinco vocales,
siguiendo un protocolo experimental adecuado.
A continuación, se explicará la solución planteada para cada objetivo específico y el desarrollo de la
misma, de manera que al lograr integrar cada una de dichas soluciones se haya cumplido el objetivo general
del trabajo.
3.1. Objetivo Específico 1: Diseño e Implementación de la Capa Convolucional
Como se mencionó en 2.2.2.1. Capa Convolucional, en general el diseño de la capa convolucional es
lo que permitirá a la CNN implementar una técnica de aprendizaje profundo debido a que el algoritmo no
recibirá una matriz de características, sino, los patrones puros.
Para el caso del desarrollo de la capa convolucional en software, no se puede hacer una prueba de
esta por separado de la red, debido a que la clasificación se obtiene de acuerdo a la respuesta del algoritmo
en cada capa. Sin embargo, esta capa entregará los filtros convolucionales, es decir las matrices que
recorrerán la imagen original formando tantas imágenes nuevas como filtros existan (Figura 6); los
parámetros de principal importancia para la programación de esta capa son el tamaño de los filtros en sus
dos dimensiones, el número de filtros y el número de píxeles que moverá el filtro al recorrer la imagen. Se
deben tener en cuenta las dimensiones del filtro y del corrimiento para garantizar que se recorra la imagen
completa, haciendo la convolución correcta de la misma, si el resultado de la ecuación (5) es entero. esto
indica que la imagen será recorrida completamente y mostrará el número de neuronas convolucionales de
la red.
NeuronasCNN =𝐶𝑜𝑙𝑢𝑚𝑛𝑎𝑠 𝐼𝑚𝑎𝑔𝑒𝑛 − 𝐶𝑜𝑙𝑢𝑚𝑛𝑎𝑠 𝐹𝑖𝑙𝑡𝑟𝑜
𝐶𝑜𝑟𝑟𝑖𝑒𝑚𝑖𝑒𝑛𝑡𝑜 𝐹𝑖𝑙𝑡𝑟𝑜+ 1
(5)
10
(a) (b) (c)
Figura 6. Procesamiento de la imagen y resultado del paso por la capa convolucional en software, (a) imagen original adquirida en
formato de mapa de bits, (b) pre procesamiento de la imagen: binarización mediante el umbral de Otsu, (c) Resultado de la
convolución de la imagen binarizada con 9 filtros convolucionales
Para el caso del hardware, la implementación de esta capa, que es la que proveerá las características
del sistema, recibe las matrices de los filtros entregados por el software y los almacena en una memoria
RAM interna de la FPGA, al igual que lo hace con la imagen a clasificar. Teniendo la imagen y todos los
filtros se realiza de manera paralela la convolución. Es decir, que a diferencia del software en el diseño
digital no es necesario que termine un filtro para iniciar con el otro; adicionalmente, se almacena cada uno
de los píxeles de las imágenes nuevas en memorias RAM de un puerto en la FPGA. El diagrama de bloques
de esta capa puede observarse en el Anexo 1. 𝑒 del documento.
Cuando el bloque de control de esta capa recibe la señal de inicio, empieza a leer la información de
las memorias de la imagen de acuerdo a la dirección que envía el contador de imagen obteniendo a la salida
100 bits que pasan por el bloque de selección, este último, de acuerdo a la información que recibe del
contador de stride filas (corrimiento) selecciona los 5 bits que se utilizarán en la iteración para la operación
de convolución.
Figura 7. Diagrama de bloques de la neurona convolucional implementada en hardware.
Para los filtros convolucionales, teniendo en cuenta la dirección que envía el contador de “dirección
de filtro” se leerán cinco datos por cada uno, cada uno de estos pasará a la neurona convolucional, Figura 7,
la cual multiplica estos valores por los valores que entrega el selector de imagen y acumula los resultados
11
guardándolos en almacenadores temporales. Este proceso se repite tantas veces como columnas tengan los
filtros convolucionales, para el caso, se repite 5 veces, y después se escribe el resultado en la Memoria
convolucional, lo que generará los datos de imágenes nuevas (tantas imágenes como filtros convolucionales
existan). Cuando se terminan las columnas del filtro este se mueve por de acuerdo al corrimiento establecido
y el proceso se repite hasta que se terminen de recorrer todas las columnas de la imagen, posteriormente se
desplaza el filtro de manera vertical y se hace el mismo proceso hasta llegar al número de filas total de la
imagen, ver Figura 2.
3.2. Objetivo Específico 2 y 5: Creación de la Base de Datos y Diseño e
Implementación de la CNN en Software (Entrenamiento)
Para la fase de entrenamiento de la CNN es necesario contar con una base de datos etiquetada, de
manera que se tengan los datos a clasificar, se sepa lo que cada dato indica y se tengan los valores reales
para posteriormente analizar los resultados. Asimismo, es importante tener una cantidad considerable de
datos, de manera que no se llegue a un sistema sobre-entrenado y se puedan realizar procedimientos de
validación cruzada en diversas iteraciones. Como se indica en el apartado 4.1. Fase De Entrenamiento, el
proceso de desarrollo para la solución de este objetivo, además de la creación de la base datos, se tiene un
entrenamiento previo de la red LeNet5 para la transferencia de conocimiento, cuya topología se muestra en
el Anexo 4. Posteriormente se realiza el entrenamiento de la CNN de identificación de las vocales del
lenguaje de señas que cuenta con 8 capas de procesamiento de datos ordenadas de la siguiente manera: capa
de entrada de la matriz de datos que recibe una matriz de [100 𝑥100] píxeles, capa convolucional transferida
de la red entrenada anteriormente, capa de rectificación lineal en donde se anulan los valores negativos del
sistema, capa de maxpooling, una ANN con una capa oculta de 20 neuronas, cantidad decidida de acuerdo
a los resultados del entrenamiento, y una capa de salida de 5 neuronas debido a que se requiere la
clasificación entre 5 clases. Finalmente se cuenta con una capa de clasificación que determina el valor mayor
disparado por las neuronas y garantiza la salida de la etiqueta (Anexo 4). En 4.1. Fase De Entrenamiento,
se amplía la información sobre el funcionamiento de la CNN implementada.
3.3. Objetivo Especifico 3: Diseño e Implementación de la CNN en FPGA
(Prueba)
Teniendo la CNN entrenada en software se procede a la realización de la arquitectura del sistema
digital en hardware, contando con la ventaja de que varias de las operaciones se pueden hacer en paralelo,
disminuyendo los tiempos de procesamiento.
La forma de solución de este objetivo está basada en la sincronización de la arquitectura de cada una
de las capas, en donde se implementa un sistema de control general que consta de 18 estados, en los cuales
se recibe alternamente la información de fin de cada capa y se entrega la información de inicio de la
siguiente.
Se plantean entonces, ocho bloques principales adicionales al control del sistema, los primeros en
activar serán: el bloque de entrada de recepción de filtros, el bloque de recepción de los pesos de la capa
oculta, el bloque de recepción de los pesos de la capa de salida y el bloque de entrada de la imagen,
respectivamente. Después, de que se tienen todos los datos almacenados en las memorias, se activan las
capas cuya arquitectura fue diseñada para la obtención de una etiqueta de salida. En primer lugar, la capa
convolucional toma los datos de la imagen y los filtros, produciendo 20 imágenes nuevas, almacenadas en
diferentes unidades de memoria RAM de un puerto, que son la entrada a la capa de maxpooling, la cual
también almacena, en 20 memorias, imágenes de salida más pequeñas en donde después cada pixel será
multiplicado por un peso establecido de cada neurona de la capa oculta, para su posterior clasificación con
la capa de salida de 5 neuronas y la capa de detección del mayor de los datos de la salida. Es importante
notar que: la arquitectura de cada neurona (Figura 8) está basada en la adición acumulativa del producto del
peso por el dato correspondiente.
12
Cuando el control general detecta el fin del proceso de clasificación queda a la espera del envió de la
instrucción de recepción de una imagen nueva o un reinicio del sistema. Los diagramas de bloques de la
arquitectura implementada se encuentran en el Anexo 1, y la explicación ampliada del funcionamiento en
4.2. Fase De Prueba.
Figura 8 . Diagrama de bloques de la unidad neuronal básica para las capas totalmente conectadas.
3.4. Objetivo Específico 4: Validación de resultados
Para la validación de resultados, tanto en entrenamiento en software como prueba en hardware, se
establecieron procesos estadísticos de conteo de falsos positivos, falsos negativos, verdaderos falsos y
verdaderos negativos. Adicionalmente, en la validación de resultados en entrenamiento de la CNN se pudo
analizar como afectaba a cada una de las clases la variación de parámetros como la cantidad de neuronas en
la capa oculta, el porcentaje de datos para entrenamiento, la tasa de aprendizaje y el número de épocas de
corrimiento por los datos. El proceso anterior, era satisfactorio siempre y cuando se hubiese hecho un buen
entrenamiento de la red de transferencia de conocimiento LeNet5, debido a que los pesos de los filtros
convolucionales se ajustaban de acuerdo a los valores iniciales que daba esta red. Por lo anterior, se hicieron
diversas pruebas de validación del entrenamiento de LeNet5, teniendo cuidado que no hubiese un sobre
aprendizaje de los datos y que la diferencia entre los errores de prueba y entrenamiento no fuesen de gran
magnitud.
El entrenamiento de la CNN para imágenes del lenguaje de señas, tuvo una validación a fondo sobre
la relación de la representación de las vocales entre sí, debido a que las posiciones de la mano en algunas
de ellas tienden a tener características similares visibles al humano, pero invisibles para la máquina. Esta
validación se hizo mirando las etiquetas que entregaba la CNN después del entrenamiento y haciendo conteo
del número de veces que confundía a una letra con otra obteniendo matrices de confusión por cada una de
las clases.
Del mismo modo, se hizo validación de resultados por cada uno de los voluntarios, con el objetivo
de ver que tanto influye la forma de posicionamiento de la mano, el tamaño de la misma o incluso la
iluminación de la imagen, adquiriendo porcentajes de errores de entrenamiento en diversas iteraciones y
con validación cruzada de los datos.
Visto que, se tiene un protocolo de comunicación entre el software y el hardware, se validaron
resultados de eficiencia en envió de la información, de manera que se pudiera medir el tiempo de transmisión
de los datos, y la verificación de la llegada de todos paquetes mediante las capas de entrada del hardware,
para llegar a hacer correcciones para trabajos futuros o buscar otro protocolo de comunicación e inclusive
pensar en la programación de caliente de la FPGA para que esta misma haga el entrenamiento.
Finalmente, para la implementación de la CNN en FPGA se hicieron además de la evaluación de
resultados ya nombrada, comparaciones con lo obtenido en el entrenamiento debido a la cuantización de los
pesos que se hizo de manera que fuese un hardware menos complejo, pero de igual manera eficiente y útil.
Además, se hizo medición del tiempo de cómputo de la tarjeta para la entrega del resultado, conteo y
verificación del uso de unidades lógicas y del uso de unidades de memoria por cada capa implementada, de
manera que se analizará si el prototipo puede disminuir en tamaño para ser un sistema comercial.
13
Capítulo 4
Desarrollo
4.1. Fase De Entrenamiento
Para el presente trabajo, se creó una base de datos de 450 imágenes, 150 imágenes por voluntario y
30 por representación de vocal. Se organiza la base de datos en carpetas separadas por voluntario y la
etiqueta de cada imagen viene dada en las propiedades y en el nombre de la misma, es importante recalcar
que las imágenes no son tomadas con cámaras profesionales ni de muy alta resolución debido a que se está
generando un prototipo de aplicaciones a futuro que debe ser económico y eficiente, de la misma manera,
se tiene como restricciones de la toma de las imágenes que el voluntario debe usar un guante negro de nitrilo
y la captura se realiza en fondo blanco, preferiblemente liso y con iluminación ambiente (Figura 9).
Figura 9. Imágenes de la base de datos (voluntario 1), representación de las vocales del lenguaje de señas.
Posteriormente, se procedió a hacer el entrenamiento de la CNN, sin embargo, según se escribió en
el capítulo 2 (2.2.2.3. Transferencia de conocimiento) el entrenamiento de una CNN requiere de por lo
menos 3000 datos para la generación correcta de filtros convolucionales y para que la red no clasifique
todos los datos en la misma clase. Como tan solo se tienen 450 imágenes de ejemplo se realiza entonces una
transferencia de conocimiento con la red pre-entrenada LeNet5, cuya base de datos tiene 5000 ejemplos.
Las imágenes de estos dígitos solo tienen un canal, es decir que son imágenes a blanco y negro como las
mostradas en la Figura 10, lo que implicó un pre-procesamiento de las imágenes de la base de datos de las
vocales en el lenguaje de señas, una binarización mediante el umbral de Otsu, que generó 450 imágenes a
blanco y negro (Figura 11).
Figura 10. Ejemplos de la base de datos para el entrenamiento de la red LeNet5, dígitos escritos.
14
Figura 11. Ejemplos de la base de datos binarizada de la representación de las vocales en el lenguaje de señas
Se entrenó inicialmente la red LeNet5 y posteriormente se utilizó la capa convolucional,
concatenando esta última a capas nuevas en la CNN de clasificación de las vocales en lenguaje de señas, en
otras palabras, la red pre-entrenada dará a la nueva red unos valores de inicialización en los filtros de la capa
convolucional, además de los tamaños ya preestablecidos de la misma. En el Anexo 4 se muestra la topología
de LeNet5 y de la CNN nueva creada. Así mismo, se ve que se implementan las capas de rectificación lineal
y la capa softmax, la cual rectifica la salida de las neuronas de las capas totalmente conectadas con una
función sigmoide.
Con el fin de elegir la topología correcta, como se nota no se pueden modificar los parámetros de la
capa convolucional, la CNN de clasificación de las señas de las vocales fue entrenada 100 veces por cada
modificación de parámetro que se le hacía, en donde los datos obtenidos se podrán leer en 4.1. Fase De
Entrenamiento del presente documento, es necesario tener en cuenta que se variaron parámetros como:
número de capas ocultas y neuronas en dichas capa, tasa de aprendizaje de los datos, número de épocas de
paso sobre los datos y disminución del gradiente del error de la red, y se midieron parámetros de
sensibilidad, especificidad, error de entrenamiento y tiempo de computación.
Finalmente, de acuerdo a los resultados óptimos de los parámetros medidos se escoge la topología de
la CNN de clasificación de las vocales del lenguaje de señas mostrada en el Anexo 4 y se envían los datos
de la red a través del puesto serial a la FPGA, en este punto, es importante recalcar que el hardware que se
diseñó no maneja punto flotante ni signos, únicamente números naturales; por tal razón antes del envío de
los pesos se hace una conversión de manera que si el número es negativo tomará un valor entre 0 y 128
dependiendo del máximo negativo y si es positivo tomará un valor entre 129 y 255 dependiendo del máximo
positivo (6). Esta cuantización solo se realiza para los filtros convolucionales y para los pesos, de manera
que la transmisión serial enviara un byte (8 bits) por cada dato, mientras que para la imagen se envían 8 bits,
pero no se hace cuantización debido a que solo se tienen valores de 1 y 0 porque es imagen a blanco y negro.
𝐷𝑎𝑡𝑜 𝑎 𝑒𝑛𝑣𝑖𝑎𝑟 =
𝐷𝑎𝑡𝑜 ∗ 128
𝑀𝑎𝑥𝑖𝑚𝑜 𝑝𝑜𝑠𝑖𝑡𝑖𝑣𝑜+ 127 𝐷𝑎𝑡𝑜 ≥ 0
𝐷𝑎𝑡𝑜 ∗ 128
𝑀𝑎𝑥𝑖𝑚𝑜 𝑛𝑒𝑔𝑎𝑡𝑖𝑣𝑜𝐷𝑎𝑡𝑜 < 0
(6)
4.2. Fase De Prueba
El diseño de la arquitectura de la CNN inicia con la capa de entrada de los datos, aunque en el software
se tiene también una capa de entrada estas serán diferentes debido a que en el caso de la implementación en
FPGA la capa de entrada de los datos se encarga de recibir los bits de información de la red de manera serial,
lo que implica que esta capa sincroniza entre el envío de datos del computador a la FPGA, en el Anexo 1 en
los apartados 𝑏, 𝑐 y 𝑑, se pueden ver los diagramas de bloques de las capas de entrada para la imagen, los
filtros convolucionales y los pesos de las capas totalmente conectadas.
Para el envío de los datos, se implementa un conversor USB a serial, configurado con 4 pines:
transmisión, recepción, polarización y GND. Este conversor, actúa como un atenuador de la señal enviada
por el computador, debido a que disminuye los voltajes desde ±15𝑉 hasta señales digitales entre 0𝑉 y 3.3𝑉,
15
adicionalmente cuenta con un tiempo de subida y bajada de la señal de 0.3𝑛𝑠, lo que permite un menor
porcentaje de retardos en la transmisión del sistema.
Posteriormente, teniendo el almacenamiento de los datos registrados, el sistema cuenta con la opción
de inicio del mismo, representada en una señal activa en bajo dada por un pulsador de la tarjeta de desarrollo.
Cuando el sistema recibe la señal de inicio, el bloque de control general se encarga de darle paso al
procesamiento de cada una de las capas actuando este como un sistema de sincronización, en el Anexo 1. 𝑎
se tiene el diagrama de bloques general del sistema y en el Anexo 2. 𝑎 el AHPL del bloque de control del
mismo.
Antes de iniciar con la explicación del sistema, cabe aclarar que siempre que se hace lectura o
escritura de datos en las memorias del diseño de la CNN se tiene un tiempo de espera de 3𝑠 garantizando
entonces que se escriban los datos correctos en la memoria o que cuando se pidan los datos sin
almacenamiento final se tengan los valores verídicos.
Después de recibir la señal de inicio, el control general da paso a la capa convolucional (Anexo 1. 𝑒)
activando el bloque de control de la misma, cuyo AHPL se puede observar en el Anexo 2. 𝑏, el
funcionamiento de esta capa se ha explicado en el presente capítulo en el apartado 3.1. Objetivo Específico
1: Diseño e Implementación de la Capa Convolucional.
Cuando el procesamiento de la capa convolucional termina, el control general del sistema le envía la
señal de inicio a la capa de maxpooling (el diagrama de bloques de esta capa se encuentra en el Anexo 1. 𝑓. y el AHPL del control en el Anexo 2. 𝑐.), esta capa toma las imágenes obtenidas, que están previamente
almacenadas en las memorias de salida de la capa convolucional, y seleccionando de a 4 píxeles vecinos
determina el mayor de estos generando una imagen nueva reducida con un procesamiento de acuerdo a los
vecinos cercanos de cada dato. El número mayor que va encontrando, se almacena en memorias de salida
de la capa de maxpooling para su posterior uso.
En este punto, es necesario hacer el análisis de reducción de dimensionalidad a medida que el patrón
va pasando por las diferentes capas, aplicando la ecuación (5):
1. Capa convolucional: recibe una imagen de [100 × 100] píxeles y 20 filtros convolucionales de [5 × 5] que se desplazan sobre la imagen con un corrimiento de un píxel tanto en filas como en columnas.
𝑁𝑒𝑢𝑟𝑜𝑛𝑎𝑠 𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖𝑜𝑛𝑎𝑙𝑒𝑠 =𝐹𝑖𝑙𝑎𝑠 𝐼𝑚𝑎𝑔𝑒𝑛 − 𝐹𝑖𝑙𝑎𝑠 𝑓𝑖𝑙𝑡𝑟𝑜
𝐶𝑜𝑟𝑟𝑖𝑚𝑖𝑒𝑛𝑡𝑜+ 1 =
100 − 5
1+ 1 = 96
𝑃𝑎𝑡𝑟𝑜𝑛𝑒𝑠 𝑑𝑒 𝑠𝑎𝑙𝑖𝑑𝑎 = 20
2. Capa de Maxpooling: recibe las salidas de la capa convolucional y agrupa de a 4 píxeles por imagen en
una matriz cuadrada de [2 × 2], con un corrimiento de 2 píxeles.
𝑁𝑒𝑢𝑟𝑜𝑛𝑎𝑠 𝑀𝑎𝑥𝑝𝑜𝑜𝑙𝑖𝑛𝑔 =𝐹𝑖𝑙𝑎𝑠 𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 − 𝐹𝑖𝑙𝑎𝑠 𝐴𝑔𝑟𝑢𝑝𝑎𝑚𝑖𝑒𝑛𝑡𝑜
𝐶𝑜𝑟𝑟𝑖𝑚𝑖𝑒𝑛𝑡𝑜+ 1
𝑁𝑒𝑢𝑟𝑜𝑛𝑎𝑠 𝑀𝑎𝑥𝑝𝑜𝑜𝑙𝑖𝑛𝑔 =96 − 2
2+ 1 = 48
𝑃𝑎𝑡𝑟𝑜𝑛𝑒𝑠 𝑑𝑒 𝑠𝑎𝑙𝑖𝑑𝑎 = 20
Como se mencionó anteriormente en la topología de la CNN implementada, se tiene dos capas ocultas
totalmente conectadas, que forman una red neuronal de topología clásica, cuyo objetivo es tomar los datos
de salida de la capa de maxpooling como datos de entrada y hacer el procedimiento bajo la unidad neuronal
básica (Figura 8).
Para las capas de ANN, ya se han almacenado los pesos correspondientes (7), de manera que, cuando
reciben la señal de inicio empiezan a recorrer la memoria de salida de la capa de maxpooling, con ayuda de
los contadores, quienes indican la dirección del dato que se va leer de la memoria. Cuando ya se tiene el
dato y el peso respectivo, estos son enviados la unidad neuronal en donde se multiplican y posteriormente
16
se acumulan los productos que se van obteniendo, para tener un valor final por cada una de las neuronas de
capa oculta.
𝑁ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑝𝑒𝑠𝑜𝑠 = (𝑁ú𝑚𝑒𝑟𝑜 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎)(𝑁ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑁𝑒𝑟𝑢𝑜𝑛𝑎𝑠) (7)
Para el caso del número de pesos de la capa oculta es importante tener en cuenta que el número de
datos, en este caso, equivale la totalidad de píxeles de las imágenes de salida de la capa de maxpooling, lo
que implica un cálculo adicional del número de datos a la entrada como se muestra en (8).
𝑁ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑎𝑡𝑜𝑠 = (𝐹𝑖𝑙𝑎𝑠 𝑚𝑎𝑥𝑝𝑜𝑜𝑙𝑖𝑛𝑔)(𝐶𝑜𝑙𝑢𝑚𝑛𝑎𝑠 𝑚𝑎𝑥𝑝𝑜𝑜𝑙𝑖𝑛𝑔) (𝐼𝑚á𝑔𝑛𝑒𝑠) (8)
La capa de salida o segunda capa oculta, a diferencia de la primera, no tomará datos de memoria si
no que recibe los datos de los almacenadores temporales de cada una de las unidades neuronales de la
primera capa oculta, posteriormente, realiza el mismo proceso de sumar los productos de dichos datos por
el peso correspondiente y entrega un valor a la salida, con la diferencia que el número de operaciones es
mucho menor debido a las 5 neuronas que representan las 5 clases en las que se va a clasificar (𝑎, 𝑒, 𝑖, 𝑜 , 𝑢).
Los diagramas de bloques de estas capas se pueden encontrar en el Anexo 1 en los apartados 𝑔 y 𝑓, al igual
que los AHPL de los controles locales que se encuentran en el Anexo 2 en los apartados 𝑑 y 𝑓.
Finalmente, se implementó la capa de clasificación, la cual recibe los datos obtenidos por las 5
neuronas de salida e identifica cuál es el mayor de ellos, mediante un sistema de comparadores, además de
esto, esta capa no pierde la información de la neurona que arrojó el mayor valor, debido a que, estas señales
pasan al conversor 7 segmentos que enciende las salidas correspondientes a letra cuya clasificación se
obtuvo como resultado. Por ejemplo, si la neurona 1 arrojó el mayor valor, el display 7 segmentos mostrará
una A construida encendiendo 6 de las 7 salidas que lo conforman y encenderá un led que representa la
neurona 1. Una de las mayores ventajas de esta capa, es que es un sistema asíncrono combinatorio, es decir
que no tiene influencia del reloj del sistema y siempre está haciendo un procesamiento constante de los
datos que recibe.
17
Capítulo 5
Protocolo De Pruebas y Análisis De
Resultados
5.1. Fase De Entrenamiento
5.1.1. Creación de la base de datos
Como ya se sabe, para la fase de entrenamiento es necesario la adquisición de imágenes para el
desarrollo de una base de datos etiquetada y organizada (Anexo 5.1. Archivos: Base de datos); teniendo en
cuenta esto, se elaboró un protocolo de adquisición de las imágenes de manera que pueda ser lo más estable
y similar posible y las variaciones no sean tan amplias entre un voluntario y otro.
El protocolo para la adquisición de las imágenes, al tener relación directa con sujetos de estudio, se
diseña de acuerdo a lo estipulado por el Ministerio de Salud de la República de Colombia en la Resolución
Número 8430 de 1993 [13], en la que se establecen normas científicas, técnicas y administrativas al
momento de realizar investigaciones con sujetos de prueba. A continuación, se listan los pasos a seguir con
el almacenamiento de la base de datos:
1. Se le informa al sujeto de prueba cuál será su participación, indicándole todos los riesgos que le puedan
llegar a suceder, cómo será el manejo de la información y esperando una respuesta de aceptación o no.
2. Firma del consentimiento informado.
3. Preparación del lugar de la toma de las imágenes, como condiciones mínimas se debe garantizar luz
natural de día y un fondo blanco en donde se hará la captura.
4. Preparación del voluntario entregándole un guante negro e indicándole la posición en la que debe poner
su mano
5. Captura de las imágenes teniendo en cuenta que el voluntario ubicará su mano con el guante en la
posición que se le indique y se le pedirá que baje y ubique la mano de nuevo después de cada toma,
garantizando así que no siempre se obtenga la misma imagen. El proceso se repetirá 150 veces en donde
cada 30 movimientos se cambiará la posición para la captura de la mano.
Siguiendo el anterior protocolo de pruebas se logra elaborar una base de datos (Figura 12), con 3
sujetos de prueba, la cual contiene imágenes de la mano de cada voluntario con el guante negro en la posición
indicada, se genera también en las propiedades de cada una de las imágenes un atributo de etiqueta que será
leído posteriormente por el software para la creación del vector de etiquetas de la imagen.
18
Figura 12. Representación gráfica de la base de datos
5.1.2. Validación del entrenamiento de LeNet5
La transferencia de conocimiento, implica hacer una validación de esta capa debido a que se debe
garantizar la topología óptima para el posterior paso de los datos. Para la validación de resultados adecuados
en esta etapa se implementa un protocolo de pruebas que consiste en hacer 100 iteraciones de training y
testing de LeNet5, en cada iteración se calcula el porcentaje de error de los dos factores y al final de hace
un análisis de los errores obtenidos para escoger la topología adecuada.
El análisis de los errores de tener en cuenta que lo ideal es que la diferencia entre el error de
entrenamiento y prueba sea mínima, entonces, se hace la resta del resultado de los dos errores en cada
iteración, posteriormente se calcula el promedio de esta resta y se eliminan todas las iteraciones que hayan
superado ese promedio y que estén por debajo de cero (Error de prueba menor que el error de
entrenamiento), finalmente mediante un análisis del diagrama de barras de la diferencia entre el error de
entrenamiento y prueba se escoge la topología más adecuada, la que menor diferencia tenga, para la
transferencia de conocimiento.
Siguiendo el anterior protocolo de pruebas, se obtienen los resultados de la Figura 13, en donde se
analiza que la menor diferencia se encuentra en la topología entrenada en la iteración número 42, de esta
manera se escoge esta topología como base de la capa convolucional de la CNN de identificación de las
vocales del lenguaje de señas.
Figura 13. Diagrama de barras de la diferencia entre los errores de entrenamiento y prueba de LeNet5.
19
5.1.3. Validación del entrenamiento de la CNN de identificación de vocales del lenguaje de señas
Para probar el entrenamiento de esta CNN se plantea el siguiente protocolo de pruebas diseñado de
manera secuencial, cabe aclarar que en cada paso del protocolo se debe calcular el porcentaje del error de
entrenamiento y del error de prueba del algoritmo por iteración (conteo de falsos positivos, falsos negativos,
verdaderos positivos y verdaderos negativos), para su posterior análisis. Este último, se hará al igual que el
apartado anterior en donde se evaluará la menor diferencia entre los datos de error y se representará mediante
un diagrama de barras.
1. Se realizan 50 iteraciones de entrenamiento, modificando en cada iteración la tasa de aprendizaje por
un valor que empieza en 0.001 y aumenta de a 0.002.
2. Se realizan 21 iteraciones de entrenamiento, modificando en cada iteración la cantidad de neuronas de
la capa oculta con un valor entre 5 y 25.
3. Se realizan 50 iteraciones de entrenamiento, modificando en cada iteración el número de épocas que
pasan por los datos aumentándolas de a 5 y empezando en 1.
De acuerdo con cada una de las variaciones hechas por medio de este protocolo, se escogen los
parámetros definitivos que ayudan en la topología óptima, teniendo en cuenta que se está entrenando con
una combinación de datos de entrada que incluye a los tres voluntarios, el objetivo es ir identificando el
parámetro óptimo desde el más profundo hasta el exterior de la CNN. Es importante notar que la estructura
original de la CNN es la planteada en LeNet5 lo que permite, posteriormente, hacer las modificaciones para
la solución del problema es específico.
De la primera, variación, relacionada con la tasa de aprendizaje de la CNN se obtiene como resultado
el diagrama de barras de la Figura 14, en donde se ve que la diferencia menor entre los errores se presenta
en la iteración 19, en dónde los errores y la tasa de aprendizaje fueron:
𝐸𝑟𝑟𝑜𝑟 𝑒𝑛𝑡𝑟𝑒𝑛𝑎𝑚𝑖𝑒𝑛𝑡𝑜 = 22,45%
𝐸𝑟𝑟𝑜𝑟 𝑑𝑒 𝑝𝑟𝑢𝑒𝑏𝑎 = 22.68%
𝑇𝑎𝑠𝑎 𝑑𝑒 𝑎𝑝𝑟𝑒𝑛𝑑𝑖𝑧𝑎𝑗𝑒 = 0.0039
Figura 14. Diagrama de barras de la diferencia entre el error de prueba y el error de entrenamiento cuando se varía la tasa de
aprendizaje en cada iteración
En seguida, se procede a realizar la segunda prueba que indica la verificación de la cantidad de
neuronas en la capa oculta, variándolas entre 5 y 25, este último es un límite considerable para que el sistema
no empiece a sobre aprender los datos. Los resultados obtenidos se encuentran en la Figura 15, dan a conocer
que el número ideal de neuronas, de acuerdo al protocolo de experimentación es 20, sin embargo, se nota
que también se pudiese remplazar este valor por 5 neuronas, disminuyendo los tiempos de cómputo. Para
comprobar esto, se realizaron pruebas adicionales que consistían en entrenar las CNN con 5 neuronas en la
capa oculta, haciendo validación cruzada de los datos y teniendo como resultado un error promedio de 42%,
20
lo cual es mayor al alcanzado anteriormente, de esta manera se descarta el hecho de la implementación única
de 5 neuronas.
Para el entrenamiento de la CNN con 20 neuronas se obtuvieron los siguientes datos:
𝐸𝑟𝑟𝑜𝑟 𝑒𝑛𝑡𝑟𝑒𝑛𝑎𝑚𝑖𝑒𝑛𝑡𝑜 = 13,85%
𝐸𝑟𝑟𝑜𝑟 𝑑𝑒 𝑝𝑟𝑢𝑒𝑏𝑎 = 14.16%
Figura 15. Diagrama de barra de la diferencia entre el error de prueba y el error de entrenamiento cuando se varia el número de
neuronas en la capa oculta de revisión los datos en cada iteración
En este punto del sistema, se ha tenido una respuesta satisfactoria debido que, al implementar los
parámetros encontrados, los errores de entrenamiento y prueban han disminuido. Finalmente, se implementó
el tercer paso del protocolo en donde se esperaría que el error de entrenamiento sea inversamente
proporcional al aumento del número de épocas de paso por los datos en cada iteración. Para la verificación
de esto, se analiza el diagrama de barras de la Figura 16 , en donde se notan los siguientes valores de ajuste
de la CNN:
𝐸𝑟𝑟𝑜𝑟 𝑒𝑛𝑡𝑟𝑒𝑛𝑎𝑚𝑖𝑒𝑛𝑡𝑜 = 13,05%
𝐸𝑟𝑟𝑜𝑟 𝑑𝑒 𝑝𝑟𝑢𝑒𝑏𝑎 = 14.10%
𝑁ú𝑚𝑒𝑟𝑜 𝑒𝑝𝑜𝑐𝑎𝑠 = 145
Figura 16. Diagrama de barra de la diferencia entre el error de prueba y el error de entrenamiento cuando se varia el número de
épocas de revisión los datos en cada iteración
En este caso, se tiene en cuenta el tiempo de procesamiento del algoritmo debido a que este se
incrementa de acuerdo con el número de épocas que se recorran los datos, el cual fue en promedio de 1693 𝑠
para tener en la última iteración 225 epocas.
Aunque analíticamente para este caso los datos están en el rango promedio de error, y se tiene en
cuenta que no son los mismos, no se generó una gran variación al cambio del número de épocas, de manera
21
que se analiza para esta topología, donde se ha llegado al punto mínimo del descenso del gradiente y que la
curva exponencial del error tiene su asíntota alrededor del 13% del mismo.
5.1.4. Validación del entrenamiento de la CNN exclusivo para cada voluntario
El objetivo principal en este apartado es poder identificar patrones similares entre las señas de un
mismo voluntario y analizar la influencia de los datos entre los tres, para esto se planeta el siguiente
protocolo de pruebas:
1. Entrenar la topología de la CNN óptima con todos los datos de un voluntario.
2. Encontrar la matriz de confusión que permite la comparación de las etiquetas obtenidas con las etiquetas
originales
3. Graficar la correlación de la matriz de confusión
4. Repetir el procedimiento con los datos de los demás voluntarios para hacer análisis de la relación entre
Los resultados obtenidos de acuerdo a la correlación de los datos de las matrices de confusión para
cada voluntario (Figura 17, Figura 18 y Figura 19), mostraron, en primer lugar, la eficiencia del algoritmo
gracias a que la mayor correlación se encuentra en la diagonal de la matriz, garantizando de esta manera
que el error de clasificación es adecuado y que aunque no sea nulo, una gran mayoría de los datos logra
ubicarse en la clase correcta.
Figura 17. Porcentajes de la matriz de confusión para el voluntario 1
Figura 18. Porcentajes de la matriz de confusión para el voluntario 2
A E I O U
A 90% 8% 0% 2% 0%
E 15% 83% 0% 0% 2%
I 0% 0% 81% 0% 19%
O 4% 0% 0% 96% 0%
U 0% 1% 4% 0% 95%
VOLUNTARIO 1
A E I O U
A 86% 14% 0% 0% 0%
E 6% 92% 0% 0% 2%
I 0% 1% 82% 0% 17%
O 1% 0% 0% 99% 0%
U 0% 0% 7% 0% 93%
VOLUNTARIO 2
22
Figura 19. Porcentajes de la matriz de confusión para el voluntario 3
Adicionalmente, en cada uno de los voluntarios se encuentran patrones de relación entre las imágenes,
que implican características, quizá de forma y tamaño similares. El primero de estos patrones se puede notar
en la relación que existe con la representación de las vocales 𝑎 y 𝑒 para los tres voluntarios, dicha relación
causa errores en el sistema de clasificación generando que las imágenes 𝑎 mal etiquetadas se clasifiquen en
𝑒 y viceversa. En la Figura 20 se pude ver un ejemplo de la binarización de las imágenes 𝑎 y 𝑒 para los tres
voluntarios, en donde se nota que la relación en cuanto a longitud del borde de las imágenes y conteo de
píxeles negros si se asemeja. También es claro, que las imágenes del voluntario 1 difieren en gran medida
de las de los otros dos, lo que genera mayores errores al momento de la implementación del sistema de
clasificación.
Figura 20. Ejemplos de imágenes binarizadas de la representación de las vocales 𝑎 y 𝑒, para los tres voluntarios respectivamente.
Otro importante factor notado en los tres voluntarios, es la independencia de la representación de la
señal de la vocal O, ya que esta, a diferencia de las demás cuenta con un centro de píxeles blancos que
permite diferencias en cuanto al conteo o medición de bordes internos. Finalmente, aunque no tan notorio
como la relación entre la 𝑎 y la 𝑒, se encuentra análogo a esto, una relación entre la representación de la 𝑢
y la 𝑖, dicha relación está ligada a la forma de la posición de las manos que a la forma de la imagen binarizada
debido a que no todos los voluntarios contaban con la misma flexibilidad en los dedos ni el mismo tamaño
de la mano (Figura 21).
A E I O U
A 95% 5% 0% 0% 0%
E 2% 98% 0% 0% 0%
I 1% 0% 90% 0% 9%
O 0% 0% 0% 100% 0%
U 0% 0% 3% 0% 97%
VOLUNTARIO 3
23
Figura 21. Comparación entre las imágenes binarizadas de la representación de las vocales 𝑢 e 𝑖, del voluntario 1 y el voluntario 3
Teniendo que, en los tres voluntarios, existe una relación entre uno o varios de los patrones, se debe
analizar si generar la matriz de confusión con los datos de todos los voluntarios presentará características
semejantes o alterará los patrones individualmente establecidos. Para esto, se realiza la correlación de la
matriz de confusión obtenida del entrenamiento de la CNN establecida.
Figura 22. Matriz de confusión para todos los voluntarios, porcentajes de sensibilidad y especificidad para la implementación final
en software
Sensibilidad Especificidad
A 0,91 0,97
E 0,86 0,97
I 0,95 0,99
O 0,99 0,99
U 0,97 0,99
24
En la Figura 22, se ha establecido la correlación entre patrones por medio de la matriz de confusión,
de donde se puede apreciar en primer lugar que la diagonal de la matriz garantiza que el porcentaje de datos
erróneo sea menor al de los patrones correctamente clasificados.
También, se puede observar en las de la vocal inicial 𝑎, están correlacionadas con las de la vocal 𝑒,
de manera que se mantiene el supuesto del parecido de la representación del lenguaje a señas de estas letras.
5.2. Fase De Prueba
El desarrollo de la etapa de prueba de la CNN, es básicamente la implementación en FPGA y la
prueba del correcto funcionamiento de la misma. Para esto se establecen protocolos de prueba que validan
el tiempo de cómputo de la tarjeta para entregar el resultado, la cantidad de unidades lógicas y bits de
memoria implementados en cada bloque principal de la arquitectura.
Adicionalmente, se valida la funcionalidad de la arquitectura, la cual debe tenerse en cuenta para los
datos de entrenamiento y los datos de prueba debido a la cuantización de los pesos que le fueron enviados
para evitar el desarrollo del sistema de punto flotante y solo trabajar con números naturales.
5.2.1. Validación de funcionalidad: comparación de datos de entrenamiento
Aunque desde el comienzo se había establecido que la implementación en hardware de la CNN era
solo para validación de la etapa de prueba, debido a la cuantización que se hace de los pesos en software es
muy importante tener en cuenta qué tanto afecta la modificación de estos a la clasificación de los resultados
de entrenamiento para tener una visión clara de lo que se puede esperar en la etapa de prueba.
El protocolo de pruebas está compuesto por las siguientes etapas:
1. Generación de archivos de inicialización de memoria (.MIF) que contengan las filas de la imagen a
clasificar, las filas de cada uno de los filtros convolucionales, los pesos de la capa oculta y los pesos de
la capa de salida.
2. Compilación del proyecto principal (.QPF)
3. Programación de la FPGA, carga a las tarjetas del archivo de ruteo (.SOF)
4. Oprimir el pulsador de inicio y guardar el valor de salida almacenado
5. Repetir el proceso con todos los datos de entrenamiento teniendo en cuenta que solo se deben generar
los archivos de inicialización de memoria de la imagen a probar
6. Hacer el cálculo del error de entrenamiento y calcular la diferencia entre el error de entrenamiento del
software y del hardware
De acuerdo con el protocolo de pruebas mencionado anteriormente se guardaron los resultados
obtenidos y se calculó el error de entrenamiento (9), teniendo en cuenta que ahora las etiquetas no serán las
originales si no las que arrojo la CNN como salida al entrenar.
𝐸𝑟𝑟𝑜𝑟 𝑇𝑟𝑎𝑖𝑛 𝐹𝑃𝐺𝐴 = 100∑(𝐸𝑡𝑖𝑞𝑢𝑒𝑡𝑎𝑠 𝑆𝑜𝑓𝑡𝑤𝑎𝑟𝑒 ≠ 𝐸𝑡𝑖𝑞𝑢𝑒𝑡𝑎𝑠 𝐹𝑃𝐺𝐴)
𝑁ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑎𝑡𝑜𝑠
(9)
Como la arquitectura de la CNN implementada en FPGA es estándar, no es necesario hacer diferentes
pruebas para la validación del entrenamiento a no ser que se cambien los datos de entrada generando nuevos
archivos de inicialización de memoria para la topología completa de la FPGA. Por otra parte, se hace la
validación del error de entrenamiento aplicando (9) y teniendo en cuenta que en el Anexo 4 se encuentra el
link al archivo “EtiquetasFPGA.xls” en donde se registraron las etiquetas arrojadas por la FPGA para cada
imagen.
𝑁𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑎𝑡𝑜𝑠𝑇𝑟𝑎𝑖𝑛 = 360
𝑁𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑒𝑡𝑖𝑞𝑢𝑒𝑡𝑎𝑠 𝑖𝑔𝑢𝑎𝑙𝑒𝑠 = 285
25
𝐸𝑟𝑟𝑜𝑟 𝑇𝑟𝑎𝑖𝑛 𝐹𝑃𝐺𝐴 = 100 (360 − 285
360) = 20.83%
El porcentaje de error de entrenamiento en la tarjeta FPGA es alto comparado con el
aproximadamente 13.0% del entrenamiento en software. Esto implica que, aunque la cuantización de los
pesos es útil para el desarrollo de una arquitectura simple, se está sacrificando exactitud del algoritmo y de
la clasificación, además se debe tener en cuenta que la cuantización que se aplicó fue lineal, es decir todos
los escalones eran del mismo tamaño, lo que implica que a varianzas muy grandes de los pesos habrá una
pérdida de información. Además de esto, se debe tener en cuenta que la arquitectura implementada ya venía
con el error de entrenamiento del software, de manera que si se hace la comparación de las etiquetas
obtenidas en la FPGA con las etiquetas originales de los datos se podrá encontrar un error del 30%. En la
Tabla 1. Valores de sensibilidad y especificidad de la validación del entrenamiento en hardware
5.2.2. Validación de funcionalidad: cálculo del error de prueba
Como el porcentaje de datos para entrenamiento fue del 80%, el 20% restante será implementado
para sistemas de prueba (91 imágenes), el protocolo de pruebas es el mismo que el implementado en El
desarrollo de la etapa de prueba de la CNN, es básicamente la implementación en FPGA y la prueba del
correcto funcionamiento de la misma. Para esto se establecen protocolos de prueba que validan el tiempo
de cómputo de la tarjeta para entregar el resultado, la cantidad de unidades lógicas y bits de memoria
implementados en cada bloque principal de la arquitectura.
Adicionalmente, se valida la funcionalidad de la arquitectura, la cual debe tenerse en cuenta para los
datos de entrenamiento y los datos de prueba debido a la cuantización de los pesos que le fueron enviados
para evitar el desarrollo del sistema de punto flotante y solo trabajar con números naturales.
5.2.1. Validación de funcionalidad: comparación de datos de entrenamiento, con la diferencia de que
la FPGA no conoce los datos nuevos que se le presentarán.
En el Anexo 4, se encuentra el archivo ‘.xls’ que contiene las etiquetas arrojadas por la FPGA y las
etiquetas de los datos del entrenamiento del algoritmo el software. En este punto, es importante tener en
cuenta que idealmente el porcentaje error que se debería tener es mayor al de la validación del
entrenamiento, de manera que se pueda comprobar que no hay sobre aprendizaje de los datos y que si existe
un sistema de clasificación en la FPGA. Se aplica (9) para calcular el error de prueba del sistema en cada
una de las iteración, teniendo las características arrojadas por la CNN a la hora de hacer testing de sus datos
(Figura 23).
𝑁𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑎𝑡𝑜𝑠𝑇𝑟𝑎𝑖𝑛 = 91
𝑁𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑒𝑡𝑖𝑞𝑢𝑒𝑡𝑎𝑠 𝑖𝑔𝑢𝑎𝑙𝑒𝑠 = 57
𝐸𝑟𝑟𝑜𝑟 𝑇𝑟𝑎𝑖𝑛 𝐹𝑃𝐺𝐴 = 100 (91 − 57
91) = 37.36%
Sensibilidad Especificidad
A 0,79 0,97
E 0,89 0,91
I 0,78 0,94
O 1,00 0,99
U 0,83 0,92
26
Figura 23. Diagrama de barras del error de prueba de la arquitectura implementada en FPGA
Como análisis a este resultado, se puede ver que el error de prueba en las diferentes iteraciones con
variados datos no tiende a un mismo valor, además de esto, como no se cuenta con una base de datos amplia
en la cual, el sistema, no conozca todos los patrones, en algunas iteraciones el dato a clasificar ya era
conocido por el entrenamiento. Cabe aclarar, que, dependiendo las aplicaciones, el desarrollo de este tipo
de arquitecturas puede ser de gran utilidad y de bajo tiempo de procesamiento. Sin embargo, esto solo sucede
cuando se garantiza que dentro del dispositivo ya se encuentran los datos a procesar de manera tal que el
tiempo de envió de los datos a la FPGA sea nulo.
5.2.2. Validación uso de recursos
De las cosas más importantes en el manejo de hardware, es el uso de recursos en cuanto a memoria y
unidades lógicas se trata, en el presente trabajo se implementó la CNN en dos tarjetas Stratix IV, cuyo
sistema cuenta con un reloj digital principal de 10𝑛𝑠, una matriz de memorias de M9K, M144K y MLab,
además de tener la disponibilidad y conexión a múltiples periféricos.
Tabla 2. Medición de recursos hardware usados en las capas de entrada de datos al sistema
Tabla 3. Análisis de usos de recurso por FPGA
En la Tabla 2 y Tabla 3 se observa el uso de recursos en cada una de las capas del sistema y como se
puede notar en términos de unidades lógicas y sistemas de procesamiento de datos la CNN no consumió
sino el 32% de una tarjeta, a pesar de eso, se tuvo que hacer requerimiento de otra debido a la cantidad de
bits que se almacenan para hacer las operaciones en cada capa.
Una solución que puede resultar óptima, para el ahorro de recursos en las tarjetas y la generación de
prototipos de tamaño más pequeño es el uso de un chip integrado de memoria que garantice el
almacenamiento de los datos y permita la lectura de los mismos.
Parámetro de medición Entrada de imagenEntrada Filtros
Convolucionales
Entrada Pesos
Capa Oculta
Entrada Pesos
Capa de Salida
Bloques combinatorios 0 0 0 0
Bloques secuenciales 6 9 8 8
Registros lógicos 1974 1890 79 83
ALUTs 644 578 83 86
Bits de memoria 56320 56320 0 0
% ocupado en FPGA 1% 1% <1% <1%
Parámetro de medición FPGA I FPGA II
Registros lógicos 5.741 862
ALUTs 1.222 169
Bits de memoria 3.700.000 7.373.600
% ocupado en FPGA 6% 26%
27
Capítulo 6
Conclusiones Y Recomendaciones
Una vez implementada la arquitectura de la red neuronal artificial convolucional en FPGA se aprecia
un procesamiento de cómputo rápido y eficaz, capaz de producir tareas paralelas.
Por otra parte, para el desarrollo orientado a este tipo de dispositivos se debe seguir un proceso que
inicia con una evaluación en software, en donde en la fase de entrenamiento, se nota la importancia de una
base de datos específica donde la cantidad de patrones a clasificar, tiene un valor fundamental para el
correcto aprendizaje de la máquina. Igualmente, la idea de la transferencia de conocimiento a un sistema
hardware desde una implementación software, permite a los programadores una alternativa novedosa que
sirve como base o inicialización de los métodos algorítmicos. En este punto, es importante tener en cuenta
que para la transferencia de conocimiento la red pre entrenada debe recibir patrones similares a los originales
de la misma de manera que pueda transferir los datos teniendo como salida una etiqueta adecuada.
Adicionalmente, el entrenamiento de las CNN tiene la característica particular de que gracias a la
implementación de su capa convolucional evita que se le tenga que hacer un procesamiento previo al patrón
a clasificar y seguido a esto, disminuye el número de conexiones en el sistema, lo que genera que el
procesamiento sea más rápido, así siga siendo de manera secuencial.
Por otra parte, la ventaja de la programación directa del hardware, que permite un procesamiento de
las operaciones en paralelo, genera además la simplificación del problema original creando arquitecturas
con bloques de operaciones simples de manera repetitiva, lo cual aumenta la eficiencia energética y
disminuye el tiempo de cómputo de los sistemas.
Para el caso presentado, cuando se segmenta el aprendizaje de máquina (i.e. entrenamiento y prueba)
en dispositivos diferentes, hardware o software, es necesario tener un protocolo de comunicación adecuado
entre los mismos, de manera que no se pierda en la transmisión de datos el tiempo que se está ganando en
el procesamiento en paralelo de las operaciones. Se puede pensar incluso en la programación en caliente de
la FPGA para que la comunicación sea más sencilla y rápida.
Para la implementación de trabajos futuros, se recomienda ampliar la base de datos de los símbolos
del lenguaje de señas, no solo en incluir más señas estáticas, sino, en aumentar el número de muestras por
cada dato de ejemplo, de manera que se evite la transferencia de conocimiento generando una propia CNN
exclusiva de traducción de lenguaje de señas. Adicionalmente, se recomienda el uso de una FPGA más
pequeña (evitando así un gasto energético y la inutilización de las tarjetas) y portátil con una memoria
28
externa de gran capacidad, de manera que, se pueda diseñar un prototipo de un dispositivo portable de uso
comercial.
Finalmente, se recomienda el hecho de poder hacer la captura y la traducción en vivo del lenguaje de
señas, articulando entonces los periféricos de las FPGA que permitan el desarrollo de nuevas ideas de ayuda
a la comunidad con discapacidad auditiva.
Bibliografía
[1] I. Goodfellow, Y. Bengio y A. Courville, Deep Learning, Bostón, MA: MIT Press, 2016.
[2] S. Ghosh, K. Aswani, S. Singh, S. Sahu, D. Fujita y A. Bandyopadhyay, «Design and construction of
a Brain-like computer: A new class of frequency-fractal computing using wireless communication in
a supramolecular organic, inorganic system,» Information, 2014.
[3] R. Adhami y H. Al-Ghaib, «An E-Learning Interactive Course for Teaching Digital Image Processing
at the Undergraduate Level in Engineering,» IEEE, Villach, Australia, 2013.
[4] Universidad Nacional de Quilmes, «Segmentación por Umbralización,» Quilmes, Argentina, 2005.
[5] D. Kriesel, A Brief Introduction to Neural Networks, Bonn, Germany, 2007.
[6] K. Debes, A. Kogenig y H.-M. Gross , «Transfer Functions in Artificial Neural Networks, A
simulation-Based Tutorial,» Brains Minds Media, Ilmenau, Germany, 2005.
[7] S. J. Pan y Q. Yang, «A Survey on Transfer Learning,» IEEE Transactions on Knowledge ana Data
Engineering, Hong Kong, 2009.
[8] Y. Lecun, «LeNet5, Convolutional Neural Networks,» New York University, New York, USA, 2010.
[9] M. L. López y J. L. Ayala, FPGA: Nociones básicas e implementación, Madrid, España:
Departamento de Ingeniería Electrónica, Universidad Politécnica de Madrid, 2004.
[10] P. Brouulim , R. Linhart y V. Pavlicek, «Digital modulation design using Altera FPGA,» Belgrade,
Serbia, 2013.
[11] C. Zhang, D. Wu , J. Sun, G. Sun, G. Luo y J. Cong, «Energy-Efficient CNN Implementation on a
Deeply Pipelined FPGA Cluster,» Computer Science Department, University of California and
PKU/UCLA Joint Research Institute in Science and Engineering, Los Angeles, USA, 2016.
29
[12] P. Meloni, G. Deriu, F. Conti, I. Loi , L. Raffo y L. Benini , «Curbing the Roofline: a Scalable and
Flexible Architecture for CNNs on FPGA,» Department of Electrical, Electronic and Information
Engineering, Bologna, Italia, 2016.
[13] Ministerio de Salud de la República de Colombia, Resolución Número 8430 de 1993, Colombia, 1993.
ANEXOS
Anexo 1: Diagramas De Bloques Del Sistema Desarrollado En FPGA
a) Diagrama de bloques general del sistema
Capa Convolucional Capa de Maxpooling
Primera Capa Oculta
Totalmente conectada
Capa de salida
Totalmente conectadaControl General
Entrada imagen
Entrada Filtros
Convolucionales
813
2
2
2
2
16
40
Capa de clasificación
2
2
5
Respuesta de
salida
7
Inicio
Reloj
Reloj
Entrada Pesos
Capa 1
Entrada Pesos
Capa 2
Dato de
entrada
Dato de
entrada
Disparo de la
neurona
b) Capa de entrada de la imagen
30
c) Capa de entrada de los pesos para las capas totalmente conectadas
d) Capa convolucional y componentes
31
Memoria imagen
Contador Imagen (Dirección)
SelectorPixel
Contador Fila
100
5 5
Escribir
Control_ContImagen Control_ContFilas
3 2
DirecciónEscribir
7
Bit Convolución 0
Bit Convolución 1
Bit Convolución 2
Bit Convolución 3
Bit Convolución 4
DirecciónMáxima
FilaMaxima
DatoEntrada
Memoria Filtro 0
Contador
Dirección Filtro
Memoria Filtro 1
Memoria Filtro 2
Memoria Filtro 20
8
8
8
Contador Filtro
Fila Filtro 0
Fila Filtro 1
Fila Filtro 2
Fila Filtro 3
Fila Filtro 4
8
8
8
8
8
Selector Filtro x20
Reloj
Control_ContadorDireccion
2
Control_ContadorFiltro
2
Dato
EscribirDirección
Escribir
4
Señales
Escribir
20
Máximo Filtro
Máxima Dirección
x20
32
Generador de
imagen
Generador de
filtro
CONTROL
CONVOLUCIONAL
Neurona 0
Neurona 1
Neurona 19
5
5
5
5x8
5x8
5x8
2
2
2
Memoria
Convolución 0
Memoria
Convolucion 1
Memoria
Convolución 20
13
13
13
InicioConvolución
Reloj
Reset
SalidaConvolución 0
SalidaConvolución 1
SalidaConvolución 20
Dato Entrada
Dirección
Escribir Imagen
Dirección
Escribir Filtro
e) Capa de Maxpooling
33
Contador de
Tiempo
Contador de
Stride
Contador 12 bits
Almacenador 1
Contador
Convolución
Memoria
Convolución
Almacenador 2
Almacenador 4
Comparador
Mayor
Almacenador 3
Memoria Max
Pooling
Contador Espera
16 16
16
16
16
2
Control Pooling
22
2
Inicio
Reloj
Fin pooling
Salida
pooling
f) Capa oculta totalmente conectada
Contador Pooling
Memoria Pooling
1
Memoria Pooling
2
Memoria Pooling
3
Memoria Pooling
4
Contador Espera
Selector
Contador datos
Contador Pesos
Memoria Pooling
20Neurona 20
Neurona 3
Neurona 2
Neurona 1
Contador
Dirección de
Pesos
Selector 2
Pesos 1
Pesos 2
Pesos 3
Pesos 20
16
16
16
16
16
16
16
16
8
8
8
8
5
8
8
8
8
2
2
2
2
Inicio RelojFin FC1
Control FC1
Salida Neuronas
40
34
g) Capa de salida
Contador espera
Selector
Contador datos
Contador Pesos
Neurona 4
Neurona 3
Neurona 2
Neurona 1
Contador
Dirección de
Pesos
Selector 2
Pesos 1
Pesos 2
Pesos 3
Pesos 4
40
40
40
405
Neurona 5
40Pesos 5
Pesos
neuronas
capa oculta 1
Pesos de salida
Control capa de
salida
Anexo 2: AHPL del control de cada capa
35
a) Control del Sistema general
1. 𝑅𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 = ′0′
𝑅𝐹𝐶1 = ′0′
𝑅𝐹𝐶2 = ′0′ 𝑅𝑀𝑎𝑥𝑃𝑜𝑜𝑙𝑖𝑛𝑔 = ′0′
𝑅𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝐼𝑚𝑔 = ′0′
𝑅𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝐹𝑖𝑙𝑡𝑟𝑜𝑠 = ′0′
𝑅𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑃𝑒𝑠𝑜𝑠𝐹𝐶1 = ′0′
𝑅𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑃𝑒𝑠𝑜𝑠𝐹𝐶2 = ′0′
→ (𝐼𝑛𝑖𝑐𝑖𝑜𝑆𝑖𝑠𝑡𝑒𝑚𝑎 × 1) + (𝐼𝑛𝑖𝑐𝑖𝑜𝑆𝑖𝑠𝑡𝑒𝑚𝑎̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 2)
2. 𝐼𝑛𝑖𝑐𝑖𝑜𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝐹𝑖𝑙𝑡𝑟𝑜𝑠 = ′1′ → 3
3.
→ (𝐹𝑖𝑛𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝐹𝑖𝑙𝑡𝑟𝑜𝑠 × 4) + (𝐹𝑖𝑛𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝐹𝑖𝑙𝑡𝑟𝑜𝑠̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 3)
4. 𝐼𝑛𝑖𝑐𝑖𝑜𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑃𝑒𝑠𝑜𝑠𝐹𝐶1 = ′1′ → 5
5.
→ (𝐹𝑖𝑛𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑃𝑒𝑠𝑜𝑠𝐹𝐶1 × 6) + (𝐹𝑖𝑛𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑃𝑒𝑠𝑜𝑠𝐹𝐶1̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 5)
6. 𝐼𝑛𝑖𝑐𝑖𝑜𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑃𝑒𝑠𝑜𝑠𝐹𝐶2 = ′1′
→ 7
7.
→ (𝐹𝑖𝑛𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑃𝑒𝑠𝑜𝑠𝐹𝐶2 × 8) + (𝐹𝑖𝑛𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑃𝑒𝑠𝑜𝑠𝐹𝐶2̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 7)
8. 𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟𝐼𝑚𝑎𝑔𝑒𝑛 = ′1′
→ 9
9. L
→ (𝐹𝑖𝑛𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝐼𝑚𝑎𝑔𝑒𝑛 × 10) + (𝐹𝑖𝑛𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝐼𝑚𝑎𝑔𝑒𝑛̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 9)
10. 𝐼𝑛𝑖𝑐𝑖𝑜𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 = ′1′ → 11
11.
→ (𝐹𝑖𝑛𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 × 12) + (𝐹𝑖𝑛𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 11)
12. 𝐼𝑛𝑖𝑐𝑖𝑜𝑃𝑜𝑜𝑙𝑖𝑛𝑔 = ′1′
→ 13
36
13.
→ (𝐹𝑖𝑛𝑃𝑜𝑜𝑙𝑖𝑛𝑔 × 14) + (𝐹𝑖𝑛𝑃𝑜𝑜𝑙𝑖𝑛𝑔̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 13)
14. 𝐼𝑛𝑖𝑐𝑖𝑜𝐹𝐶1 = ′1′ → 15
15.
→ (𝐹𝑖𝑛𝐹𝐶1 × 16) + (𝐹𝑖𝑛𝐹𝐶1̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 15)
16. 𝐼𝑛𝑖𝑐𝑖𝑜𝐹𝐶2 = ′1′ → 17
17.
→ (𝐹𝑖𝑛𝐹𝐶2 × 18) + (𝐹𝑖𝑛𝐹𝐶2̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 17)
18.
→ (𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟𝐼𝑀𝐺 × 8) + (𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟𝐼𝑀𝐺̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 18)
b) AHPL Capa Convolucional
1. 𝐴𝑙𝑚𝑇𝑒𝑚×100 =′ 000000000000′ 𝐶𝑜𝑛𝑡𝐹𝑖𝑙𝑡𝑟𝑜 =′ 0000000′
𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 =′ 0000′
𝐶𝑜𝑛𝑡𝑆𝑡𝑟𝑖𝑑𝑒 =′ 0000000′
𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛 =′ 0000000′
𝐶𝑜𝑛𝑡𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 =′ 000000000000′
→ (𝐼𝑛𝑖𝑐𝑖𝑜𝐶𝑜𝑛𝑡𝑟𝑜𝑙𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 1) + (𝐼𝑛𝑖𝑐𝑖𝑜𝐶𝑜𝑛𝑡𝑟𝑜𝑙𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 × 2)
2. 𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎) → (𝐸𝑠𝑝𝑒𝑟𝑎10 × 3) + (𝐸𝑠𝑝𝑒𝑟𝑎10 × 2)
3. 𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 =′ 0000′
𝐴𝑙𝑚𝑇𝑒𝑚𝑝𝑜𝑟𝑎𝑙 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟
→ 4
4. 𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛)
𝐶𝑜𝑛𝑡𝐹𝑖𝑙𝑡𝑟𝑜 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐹𝑖𝑙𝑡𝑟𝑜)
→ 5
5.
→ (𝑀𝑎𝑥𝐹𝑖𝑙𝑡𝑟𝑜̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 𝑀𝑎𝑥𝐼𝑚𝑎𝑔𝑒𝑛̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 2) + (𝑀𝑎𝑥𝐹𝑖𝑙𝑡𝑟𝑜 × 𝑀𝑎𝑥𝐼𝑚𝑎𝑔𝑒𝑛̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 6) + (𝑀𝑎𝑥𝐹𝑖𝑙𝑡𝑟𝑜
× 𝑀𝑎𝑥𝐼𝑚𝑎𝑔𝑒𝑛 × 11)
6. 𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎)
→ (𝐸𝑠𝑝𝑒𝑟𝑎4 × 7) + (𝐸𝑠𝑝𝑒𝑟𝑎4̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 6)
7. 𝑀𝑒𝑚𝑜𝑟𝑖𝑎𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑃𝑖𝑥𝑒𝑙
𝐴𝑙𝑚𝑇𝑒𝑚𝑝 = ′000000000000′
37
𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎)
→ (𝐸𝑠𝑝𝑒𝑟𝑎10 × 8) + (𝐸𝑠𝑝𝑒𝑟𝑎10̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 7)
8. 𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 =′ 0000′ 𝐶𝑜𝑛𝑡𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛)
𝐶𝑜𝑛𝑡𝐹𝑖𝑙𝑡𝑟𝑜 = ′0000000′
𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛 ← 𝑑𝑒𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐼𝑚𝑎𝑔𝑒𝑛)
→ 9
9. 𝐶𝑜𝑛𝑡𝐹𝑖𝑙𝑡𝑟𝑜 ← ′0000000′ 𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛 ← 𝑑𝑒𝑐(𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛)
→ 10
10. 𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛 ← 𝑑𝑒𝑐(𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛)
→ 2
11. 𝐶𝑜𝑛𝑡𝐹𝑖𝑙𝑡𝑟𝑜 = ′0000000′ 𝐶𝑜𝑛𝑡𝐼𝑚𝑎𝑔𝑒𝑛 =′ 0000000′
𝐶𝑜𝑛𝑡𝑆𝑡𝑟𝑖𝑑𝑒 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑆𝑡𝑟𝑖𝑑𝑒)
→ 12
12.
→ (𝑀𝑎𝑥𝑆𝑡𝑟𝑖𝑑𝑒 × 12) + (𝑀𝑎𝑥𝑆𝑡𝑟𝑖𝑑𝑒 × 2)
c) AHPL Capa Maxpooling
1. 𝐶𝑜𝑛𝑡𝑆𝑡𝑟𝑖𝑑𝑒 = ′000000′
𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 =′ 00′
𝐶𝑜𝑛𝑡𝑇𝑖𝑒𝑚𝑝𝑜 = ′0000000′
𝐶𝑜𝑛𝑡𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 = ′00000000000000′
𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟1 = ′0000000000000000′
𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟2 = ′0000000000000000′
𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟3 = ′0000000000000000′
𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟4 = ′0000000000000000′ 𝑀𝑒𝑚𝑜𝑟𝑖𝑎𝑀𝑎𝑥𝑃𝑜𝑜𝑙𝑖𝑛𝑔 = ′0′
→ (𝐼𝑛𝑖𝑐𝑖𝑜𝑃𝑜𝑜𝑙𝑖𝑛𝑔 × 2) + (𝐼𝑛𝑖𝑐𝑖𝑜𝑃𝑜𝑜𝑙𝑖𝑛𝑔̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 1)
2. 𝐶𝑜𝑛𝑡𝑇𝑖𝑒𝑚𝑝𝑜𝑠 = ′0000000′
→ 3
3. 𝑀𝑒𝑚𝑜𝑟𝑖𝑎𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 → 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟1
→ 4
4. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛)
→ 5
5. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟2 ← 𝑀𝑒𝑚𝑜𝑟𝑖𝑎𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛
38
→ 6
6. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛) 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑇𝑖𝑒𝑚𝑝𝑜𝑠 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑇𝑖𝑒𝑚𝑝𝑜𝑠)
→ 7
7. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑇𝑖𝑒𝑚𝑝𝑜𝑠 = ′0000000′ → (𝑀𝑎𝑥𝑇𝑖𝑒𝑚𝑝𝑜𝑠 × 8) + (𝑀𝑎𝑥𝑇𝑖𝑒𝑚𝑝𝑜𝑠 × 6)
8. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟3 ← 𝑀𝑒𝑚𝑜𝑟𝑖𝑎𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 → 9
9. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛)
→ 10
10. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟4 ← 𝑀𝑒𝑚𝑜𝑟𝑖𝑎𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑆𝑡𝑟𝑖𝑑𝑒 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑆𝑡𝑟𝑖𝑑𝑒)
→ 11
11. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐸𝑠𝑝𝑒𝑟𝑎 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐸𝑠𝑝𝑒𝑟𝑎)
→ (𝐸𝑠𝑝𝑒𝑟𝑎 × 12) + (𝐸𝑠𝑝𝑒𝑟𝑎̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 11)
12. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐸𝑠𝑝𝑒𝑟𝑎 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐸𝑠𝑝𝑒𝑟𝑎) 𝑀𝑒𝑚𝑜𝑟𝑖𝑎𝑃𝑜𝑜𝑙𝑖𝑛𝑔 ← 𝐶𝑜𝑚𝑝𝑎𝑟𝑎𝑑𝑜𝑟𝐹𝑖𝑛𝑎𝑙
→ (𝐸𝑠𝑝𝑒𝑟𝑎 × 13) + (𝐸𝑠𝑝𝑒𝑟𝑎̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 12)
13. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑃𝑜𝑜𝑙𝑖𝑛𝑔 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑃𝑜𝑜𝑙𝑖𝑛𝑔)
→ 4
14.
(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑆𝑡𝑟𝑖𝑑𝑒̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 𝑀𝑎𝑥𝑃𝑜𝑜𝑙𝑖𝑛𝑔̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 15) + (𝑀𝑎𝑥𝑆𝑡𝑟𝑖𝑑𝑒 × 𝑀𝑎𝑥𝑃𝑜𝑜𝑙𝑖𝑛𝑔̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 16)
+ (𝑀𝑎𝑥𝑆𝑡𝑟𝑖𝑑𝑒 × 𝑀𝑎𝑥𝑃𝑜𝑜𝑙𝑖𝑛𝑔 × 17)
15. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛 ← 𝑑𝑒𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖ó𝑛) 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑇𝑖𝑒𝑚𝑝𝑜𝑠 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑇𝑖𝑒𝑚𝑝𝑜𝑠)
(𝑀𝑎𝑥𝑇𝑖𝑒𝑚𝑝𝑜𝑠̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 2) + (𝑀𝑎𝑥𝑇𝑖𝑒𝑚𝑝𝑜𝑠 × 15)
16. 𝐶𝑜𝑛𝑡𝑆𝑡𝑟𝑖𝑑𝑒 = ′0000000′ 𝐶𝑜𝑛𝑡𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖𝑜𝑛𝑎𝑙 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐶𝑜𝑛𝑣𝑜𝑙𝑢𝑐𝑖𝑜𝑛)
→ 2
17.
(𝐼𝑛𝑖𝑐𝑖𝑜𝑃𝑜𝑜𝑙𝑖𝑛𝑔̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 17) + (𝐼𝑛𝑖𝑐𝑖𝑜𝑃𝑜𝑜𝑙𝑖𝑛𝑔 × 1)
d) Control capa totalmente conectada 1
1. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑆𝑎𝑙𝑖𝑑𝑎𝑃𝑜𝑜𝑙 =′ 000000000000′ 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐸𝑠𝑝𝑒𝑟𝑎 =′ 00′
39
𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐷𝑎𝑡𝑜𝑠 = ′00000′
𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑃𝑒𝑠𝑜𝑠 =′ 00000′
𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐷𝑖𝑟𝑃𝑒𝑠𝑜𝑠 =′ 0000000000000000′
→ (𝐼𝑛𝑖𝑐𝑖𝑜𝐹𝐶𝑥2) + (𝐼𝑛𝑖𝑐𝑖𝑜𝐹𝐶̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ 𝑥1)
2. 𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎)
→ 3
3. → (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝐶𝑒𝑟𝑜𝑥4) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑈𝑛𝑜 × 5) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝐷𝑜𝑠 × 6) +(𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑡𝑟𝑒𝑠 × 7) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝐶𝑢𝑎𝑡𝑟𝑜 × 8) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝐶𝑖𝑛𝑐𝑜 × 9) +(𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑆𝑒𝑖𝑠 × 10) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑆𝑖𝑒𝑡𝑒 × 11) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑂𝑐ℎ𝑜 × 12) +(𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑁𝑢𝑒𝑣𝑒 × 13) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝐶𝑒𝑟𝑜 × 14) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝑈𝑛𝑜 × 15) +(𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝐷𝑜𝑠 × 16) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝑇𝑟𝑒𝑠 × 17) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝐶𝑢𝑎𝑡𝑟𝑜 × 18) +(𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝐶𝑖𝑛𝑐𝑜 × 19) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝑆𝑒𝑖𝑠 × 20) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝑆𝑖𝑒𝑡𝑒 × 21) +(𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝑂𝑐ℎ𝑜 × 22) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑑𝑁𝑢𝑒𝑣𝑒 × 23) + (𝑈𝑛𝑜 + 𝐷𝑜𝑠 + 𝑇𝑟𝑒𝑠 +
𝐶𝑢𝑎𝑡𝑟𝑜 + 𝐶𝑖𝑛𝑐𝑜 + 𝑆𝑒𝑖𝑠 + 𝑆𝑖𝑒𝑡𝑒 + 𝑂𝑐ℎ𝑜 + 𝑁𝑢𝑒𝑣𝑒 + 𝐶𝑒𝑟𝑜 + 𝑑𝐶𝑒𝑟𝑜 + 𝑑𝑈𝑛𝑜 +
𝑑𝐷𝑜𝑠 + 𝑑𝑇𝑟𝑒𝑠 + 𝑑𝐶𝑢𝑎𝑡𝑟𝑜 + 𝑑𝐶𝑖𝑛𝑐𝑜 + 𝑑𝑆𝑒𝑖𝑠 + 𝑑𝑆𝑖𝑒𝑡𝑒 + 𝑑𝑂𝑐ℎ𝑜 + 𝑑𝑁𝑢𝑒𝑣𝑒) × 2)
4. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎0 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎0 → 24
5. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎1 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎1
→ 24
6. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎2 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎2
→ 24
7. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎3 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎3
→ 24
8. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎4 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎4 → 24
9. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎5 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎5 → 24
10. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎6 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎6
→ 24
11. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎7 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎7 → 24
12. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎8 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎8 → 24
13. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎9 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎9 → 24
40
14. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎10 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎10
→ 24
15. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎11 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎11
→ 24
16. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎12 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎12 → 24
17. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎13 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎13 → 24
18. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎14 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎14
→ 24
19. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎15 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎15
→ 24
20. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎16 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎16 → 24
21. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎17 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎17
→ 24
22. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎18 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎18
→ 24
23. 𝐴𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎19 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁𝑒𝑢𝑟𝑜𝑛𝑎19
→ 24
24. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑃𝑜𝑜𝑙𝑖𝑛𝑔 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑃𝑜𝑜𝑙𝑖𝑛𝑔)
𝐷𝑖𝑟𝑒𝑐𝑐𝑖ó𝑛𝑃𝑒𝑠𝑜𝑠 ← 𝑖𝑛𝑐(𝐷𝑖𝑟𝑒𝑐𝑐𝑖ó𝑛𝑃𝑒𝑠𝑜𝑠) → 25
25.
→ (𝐹𝑖𝑛𝐼𝑚𝑎𝑔𝑒𝑛 × 26) + (𝐹𝑖𝑛𝐼𝑚𝑎𝑔𝑒𝑛̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 2)
26. 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑃𝑜𝑜𝑙𝑖𝑛𝑔 =′ 000000000000′
𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝐷𝑎𝑡𝑜𝑠 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐷𝑎𝑡𝑜𝑠)
→ 27
27.
→ (𝐹𝑖𝑛𝑃𝑒𝑠𝑜𝑠 × 28) + (𝐹𝑖𝑛𝑃𝑒𝑠𝑜𝑠̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 2)
28. 𝐶𝑜𝑛𝑡𝑃𝑒𝑠𝑜𝑠 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟𝑃𝑒𝑠𝑜𝑠)
𝐶𝑜𝑛𝑡𝐷𝑎𝑡𝑜𝑠 = ′00000′
→ 29
41
29.
→ (𝐹𝑖𝑛𝐹𝐶 × 30) + (𝐹𝑖𝑛𝐹𝐶̅̅ ̅̅ ̅̅ ̅̅ × 2)
30.
→ (𝐼𝑛𝑖𝑐𝑖𝑜𝐹𝐶̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 30) + (𝐼𝑛𝑖𝑐𝑖𝑜 × 1)
e) Control capa de salida
1. 𝐶𝑜𝑛𝑡𝐷𝑎𝑡𝑎 = ′00000′ 𝐶𝑜𝑛𝑡𝑃𝑒𝑠𝑜𝑠 =′ 00000′
𝐷𝑖𝑟𝑒𝑐𝑐𝑖ó𝑛 = ′0000000′
→ (𝐼𝑛𝑖𝑐𝑖𝑜𝐹𝐶2 × 2) + (𝐼𝑛𝑖𝑐𝑖𝑜𝐹𝐶2̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 1)
2. 𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐸𝑠𝑝𝑒𝑟𝑎)
→ 3
3.
𝐸𝑠𝑝𝑒𝑟𝑎 × 𝐶𝑒𝑟𝑜 × 4) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑈𝑛𝑜 × 5) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝐷𝑜𝑠 × 6)
+ (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝑇𝑟𝑒𝑠 × 7) + (𝐸𝑠𝑝𝑒𝑟𝑎 × 𝐶𝑢𝑎𝑡𝑟𝑜 × 8) + (𝐸𝑠𝑝𝑒𝑟𝑎̅̅ ̅̅ ̅̅ ̅̅ ̅̅
× (𝑈𝑛𝑜 + 𝐷𝑜𝑠 + 𝐶𝑒𝑟𝑜 + 𝑇𝑟𝑒𝑠 + 𝐶𝑢𝑎𝑡𝑟𝑜) × 2)
4. 𝐴𝑙𝑚𝑁𝑒𝑢𝑟𝑜𝑛𝑎0 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁0 → 9
5. 𝐴𝑙𝑚𝑁𝑒𝑢𝑟𝑜𝑛𝑎1 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁1
→ 9
6. 𝐴𝑙𝑚𝑁𝑒𝑢𝑟𝑜𝑛𝑎2 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁2 → 9
7. 𝐴𝑙𝑚𝑁𝑒𝑢𝑟𝑜𝑛𝑎3 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁3
→ 9
8. 𝐴𝑙𝑚𝑁𝑒𝑢𝑟𝑜𝑛𝑎4 ← 𝑆𝑢𝑚𝑎𝑑𝑜𝑟𝑁4
→ 9
9. 𝐶𝑜𝑛𝑡𝐷𝑎𝑡𝑎 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝐷𝑎𝑡𝑎)
→ 10
10.
→ (𝐹𝑖𝑛𝐷𝑎𝑡𝑜𝑠 × 11) + (𝐹𝑖𝑛𝐷𝑎𝑡𝑜𝑠̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅ × 2)
11. 𝐶𝑜𝑛𝑡𝑃𝑒𝑠𝑜𝑠 ← 𝑖𝑛𝑐(𝐶𝑜𝑛𝑡𝑃𝑒𝑠𝑜𝑠)
𝐶𝑜𝑛𝑡𝐷𝑎𝑡𝑜𝑠 = ′00000′
→ 12
12.
42
→ (𝐹𝑖𝑛𝑃𝑒𝑠𝑜𝑠 × 12) + (𝐹𝑖𝑛𝑃𝑒𝑠𝑜𝑠̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ × 2)
43
Anexo 3: consentimientos informados
María Alejandra Sierra Lizarazo
Pontificia Universidad Javeriana, Bogotá
Trabajo de grado: Sistema digital de reconocimiento de patrones mediante redes neuronales
convolucionales artificiales
Bogotá, ____ de ___________ del 2017
Introducción y propósito
Yo, María Alejandra Sierra Lizarazo, estudiante de ingeniería electrónica de la Pontificia
Universidad Javeriana de Bogotá, en la realización del trabajo final del pregrado, he solicitado su
colaboración y participación voluntaria, en la toma de imágenes de su mano derecha en 5
posiciones diferentes, que indican la representación de las vocales en el Lenguaje de Señas
Colombiano. Lo anterior, con el objetivo de realizar un sistema autónomo de traducción de dichas
imágenes a símbolos escritos, que permitirá generar nuevas ideas para la mejora de la calidad de
vida de las personas con discapacidad auditiva.
Mediante este documento, yo, garantizo que no será vulnerada su integridad física ni mental y que
sus datos serán tratados confidencialmente, teniendo en cuenta que este estudio se cataloga como
investigación de riesgo mínimo según la RESOLUCIÓN N°008430 DE 1993 del Ministerio de
Salud de Colombia. Además, me responsabilizo por los riesgos o daños que se generen en
participación voluntaria de esta actividad, sin incluir a la Universidad, ni ninguna de sus
dependencias.
Procedimiento a realizar
Se le entregará al voluntario un guante negro, elaborado principalmente de nitrilo, que deberá usar
en la mano derecha. Seguido a esto, se le indicara el lugar de la toma de fotografías y se le pedirá
que se siente, además, se le mostrará cómo debe ser la posición de la mano para cada una de las
vocales, dejando claro que, al realizar la toma de cada imagen el voluntario deberá descansar y
soltar la mano para luego ubicarla de nuevo en la posición que se le mostró anteriormente.
Se tomarán 150 imágenes, 30 imágenes por vocal. Finalizada cada vocal, el voluntario podrá
descansar su extremidad por unos minutos. Finalmente, cabe aclarar, que el procedimiento dura en
promedio hora y media no continua, el voluntario es libre de decidir si las todas las tomas se
realizan el mismo día o preferiblemente diferentes días.
Consentimiento informado
Yo, ______________________________ he leído y escuchado los propósitos, objetivos y
procedimientos a realizar en el presente estudio, he tenido la oportunidad de preguntar sobre este
y me ha sido brindada una respuesta óptima. Decido participar voluntariamente en la toma de las
imágenes necesarias y tengo claridad de que mis datos serán tratos de manera confidencial y con
fines académicos. Además, soy consciente de que me puedo retirar del estudio en el momento que
lo desee y que el procedimiento planteado no afecta mi integridad física ni mental.
___________________________________
Firma
Fecha:
Documento de identidad:
44
Anexo 4: Topología de la red LeNet5 para transferencia de conocimiento a la CNN de topología implementada para
clasificación de señales de vocales del lenguaje de señas.
45
Anexo 4: Archivos
Link general:
https://www.dropbox.com/sh/71wgzefksbupasp/AAA2fsn3-cJr432STh5tEyDfa?dl=0
a) Base de datos:
https://www.dropbox.com/sh/tcvnjvy3u9ottru/AACZWevGC8yLeco2C-
obQXbua?dl=0
b) Consentimiento informado:
https://www.dropbox.com/s/4ep3r5vp0ptszxw/Consentimientos%20informados.pd
f?dl=0
c) Arquitectura y diseño hardware, programación de la FPGA:
https://www.dropbox.com/sh/lvn72qro0u49rnq/AAByjA06Hw3GkvDYJvtqexwEa
?dl=0