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