Clasificación de imágenes en sistemas embebidos usando...

UNIVERSIDAD DE BUENOS AIRES

FACULTAD DE INGENIERÍA

CARRERA DE ESPECIALIZACIÓN EN SISTEMAS

EMBEBIDOS

MEMORIA DEL TRABAJO FINAL

Clasificación de imágenes en sistemasembebidos usando redes neuronales

Autor:Ing. Julio Gastón Coccé

Director:Ing. Juan Manuel Cruz (FIUBA, UTN-FRBA)

Codirector:Esp. Ing. Alejandro Celery (FIUBA)

Jurados:Esp. Ing. Patricio Bos (FIUBA)

Esp. Ing. Franco Bucafusco (FIUBA)Esp. Ing. Nicolás Dassieu Blanchet (FIUBA)

Este trabajo fue realizado en la Ciudad Autónoma de Buenos Aires entre mayo ydiciembre de 2017.

III

Resumen

En este trabajo se estudió la posibilidad de clasificar imágenes usando redesneuronales en sistemas embebidos. Se implementó una solución basada en la

librería Caffe sobre un ambiente linux lo cual se probó en una placa Orange Pi.Esto permitió definir criterios con respecto a la viabilidad, los tiempos de

ejecución y las condiciones necesarias para realizar la clasificación.

Para realizar este trabajo se aplicaron conocimientos de la especializaciónrelativos a sistemas de proposito general, arquitectura de microcontroladores,

ingeniería de software en sistemas embebidos y gestión de proyectos.

V

Agradecimientos

Al Dr. Ing. Sergio Lew por su consejo sobre las redes neuronales convolucionales.

VII

Índice general

Resumen III

1. Introducción General 11.1. Investigación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.1.1. Objeto de estudio . . . . . . . . . . . . . . . . . . . . . . . . . 11.1.2. Imágenes y modelos utilizados . . . . . . . . . . . . . . . . . 11.1.3. Sistema y herramientas . . . . . . . . . . . . . . . . . . . . . 11.1.4. Ambiente de prueba . . . . . . . . . . . . . . . . . . . . . . . 2

1.2. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3. Alcance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.4. Introducción a las redes neuronales . . . . . . . . . . . . . . . . . . . 3

1.4.1. Redes neuronales . . . . . . . . . . . . . . . . . . . . . . . . . 3Propagación hacia adelante . . . . . . . . . . . . . . . . . . . 4Capas completamente conectadas . . . . . . . . . . . . . . . 4Perceptrón . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4Entrenamiento . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2. Introducción Específica 72.1. Redes neuronales convolucionales . . . . . . . . . . . . . . . . . . . 72.2. Cálculo de la memoria ocupada . . . . . . . . . . . . . . . . . . . . . 10

2.2.1. Dimensión de la capa convolucional . . . . . . . . . . . . . . 102.2.2. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3. Diseño e Implementación 153.1. Generación de imágenes . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.1.1. Implementación . . . . . . . . . . . . . . . . . . . . . . . . . . 153.1.2. Dependencias . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.1.3. Ejecución . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3.2. Caffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.2.1. Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.2.2. Instalación del framework . . . . . . . . . . . . . . . . . . . . 17

3.3. Compilación del software del proyecto . . . . . . . . . . . . . . . . . 183.4. Sistema de entrenamiento . . . . . . . . . . . . . . . . . . . . . . . . 18

3.4.1. Uso del sistema de entrenamiento . . . . . . . . . . . . . . . 183.5. Sistema de clasificación . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.5.1. Uso del sistema de clasificación . . . . . . . . . . . . . . . . . 19

4. Ensayos y Resultados 214.1. Bancos de imágenes generados . . . . . . . . . . . . . . . . . . . . . 21

4.1.1. Trazos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.1.2. Figuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.1.3. Árboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.2. Modelo empleado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

VIII

4.2.1. Modelo inicial . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.2.2. Modelo trazos . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.2.3. Modelo figuras . . . . . . . . . . . . . . . . . . . . . . . . . . 244.2.4. Modelo árboles . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.3. Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.3.1. Modelo trazos . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.3.2. Modelo figuras . . . . . . . . . . . . . . . . . . . . . . . . . . 264.3.3. Modelo árboles . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4.4. Tiempos de clasificación . . . . . . . . . . . . . . . . . . . . . . . . . 274.4.1. Modelo trazos . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.4.2. Modelo figuras . . . . . . . . . . . . . . . . . . . . . . . . . . 284.4.3. Modelo árboles . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.5. Exactitud de la clasificación . . . . . . . . . . . . . . . . . . . . . . . 294.6. AlexNet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.6.1. Modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.6.2. Memoria ocupada . . . . . . . . . . . . . . . . . . . . . . . . 304.6.3. Tiempos de Clasificación . . . . . . . . . . . . . . . . . . . . . 31

4.7. Árboles mejorado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.7.1. Modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.7.2. Memoria ocupada . . . . . . . . . . . . . . . . . . . . . . . . 334.7.3. Tiempos de Clasificación . . . . . . . . . . . . . . . . . . . . . 344.7.4. Resultado final . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.8. Dificultades encontradas . . . . . . . . . . . . . . . . . . . . . . . . . 354.8.1. El requisito del lenguaje . . . . . . . . . . . . . . . . . . . . . 354.8.2. Las dependencias de las librerías . . . . . . . . . . . . . . . . 35

5. Conclusiones 375.1. Conclusiones generales . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.1.1. Trabajo realizado . . . . . . . . . . . . . . . . . . . . . . . . . 375.1.2. Viabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375.1.3. Tiempos y recursos . . . . . . . . . . . . . . . . . . . . . . . . 38

5.2. Próximos pasos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.2.1. Margen de mejora . . . . . . . . . . . . . . . . . . . . . . . . 385.2.2. Alternativas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395.2.3. Aplicación práctica . . . . . . . . . . . . . . . . . . . . . . . . 39

Bibliografía 41

IX

Índice de figuras

1.1. Modelo de microscopio con clasificación automática de muestrasde la empresa CytoVision. . . . . . . . . . . . . . . . . . . . . . . . . 2

1.2. Ejemplo de una red neuronal con capas completamente conectadas. 41.3. Modelo del perceptrón: El producto escalar entre los valores de las

neuronas de la capa previa y los pesos de las conexiones es proce-sado por la función de activación que determina el valor de salidapara una neurona de la capa siguiente. . . . . . . . . . . . . . . . . . 5

2.1. Un filtro recorre las distintas posiciones de la imagen aquí presen-tada como un volúmen de 32x32 pixeles x3 canales (rojo, verde yazul), y del producto escalar entre el filtro y la parte de la imagensolapada se obtiene el valor de cada punto del mapa resultante. . . 8

2.2. La forma de la siguiente capa de la red depente de la cantidad defiltros utilizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.3. Luego de una convolución suele aplicarse pooling para reducir lacantidad de información. . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.4. Reducción de los datos al hacer pooling. . . . . . . . . . . . . . . . . 92.5. Reducción de los datos al hacer pooling. . . . . . . . . . . . . . . . . 102.6. Las redes neuronales convolucionales suelen combinar un grupo

de capas convolucionales y posteriormente capas completamenteconectadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.7. Cada filtro recorre todo el volumen de la capa de entrada para ge-nerar un elemento bidimensional en la capa de salida. . . . . . . . . 11

2.8. La profundidad de la capa de salida depende de la cantidad defiltros utilizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.9. El filtro (celeste oscuro) se desplaza por la capa de entrada (celesteclaro) generando en cada posición un elemento del mapa de carac-terísticas resultante en la capa de salida (verde). . . . . . . . . . . . 12

2.10. Un filtro de 3x3 se desplaza por la capa de entrada de 5x5, rellenadacon un espacio, el mapa resultante es de 3x3. . . . . . . . . . . . . . 12

2.11. Modelo simplificado de una red neuronal con una capa convolu-cional con pooling seguida de una capa completamente conectadaa una salida de seis categorías. El filtro es de 5x5, no se usa rellenoy se desplaza de un lugar a la vez. Se aplica pooling con un filtrode 2x2 y desplazamiento de dos lugares a la vez. . . . . . . . . . . . 13

4.1. Ejemplos de las imagenes generadas para el modelo trazos . . . . . 214.2. Ejemplos de las imágenes generadas para el modelo figuras . . . . 224.3. Ejemplos de las imagenes generadas para el modelo árboles . . . . 22

X

4.4. Estructura de la red neuronal utilizada. La imágen aparece en co-lor naranja, los datos generados en azul y los parámetros en colorverde. Los procesos se representan con una flecha roja. Los proce-sos de convolución, Conv 1 y 2, usan filtros para procesar la capaprevia y producir mapas como salida: Maps 1 y 2. Los procesos depooling reducen la capa previa. Los procesos IP constituyen capascompletamente conectadas. V1 representa los datos de Maps 1 enforma de vector. Este vector constituye la entrada y W1 los pesospsinápticos que se aplican al perceptrón para obtener la salida V2.Similarmente ocurre con el siguiente proceso IP2, el cual genera elvector V3 cuya dimensión equivale al número de categorías en lasque se clasifican las imágenes. Finalmente los valores obtenidos setransforman en las probabilidades que constituyen el resultado dela calsificación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.5. Estructura de la red neuronal utilizada en el modelo AlexNet. Eneste modelo se concatenan cinco capas convolucionales seguidasde tres capas completamente conectadas. Las capas convoluciona-les son seguidas de algunos de los procesos relu, pooling y norma-lización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4.6. Estructura de la red neuronal utilizada. Se agrega una capa convo-lucional al modelo propuesto. Para la convolución inicial se usan50 filtros de 11x11x1, para la segunda y tercera se usan 50 filtros de5x5x50 respectivamente. De esta manera se logra que la matríz W1sea de 800 x 500. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

XI

Índice de Tablas

2.1. Memoria ocupada por un modelo simplificado de red neuronalconvolucional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.1. Memoria ocupada por los datos del modelo trazos . . . . . . . . . . 254.2. Memoria ocupada por los parámetros del modelo trazos . . . . . . 264.3. Memoria ocupada por los datos del modelo figuras . . . . . . . . . 264.4. Memoria ocupada por los parámetros del modelo figuras . . . . . . 264.5. Memoria ocupada por los datos del modelo árboles . . . . . . . . . 274.6. Memoria ocupada por los parámetros del modelo árboles . . . . . . 274.7. Distribución de tiempos del modelo trazos . . . . . . . . . . . . . . 284.8. Distribución de tiempos del modelo figuras . . . . . . . . . . . . . . 284.9. Distribución de tiempos del modelo árboles . . . . . . . . . . . . . . 294.10. Exactitud de la clasificación lograda por cada modelo . . . . . . . . 294.11. Memoria ocupada por los parámetros del modelo AlexNet . . . . . 314.12. Distribución de tiempos del modelo AlexNet . . . . . . . . . . . . . 324.13. Memoria necesaria para los datos del modelo árboles mejorado . . 334.14. Memoria ocupada por los parámetros del modelo árboles mejorado 344.15. Distribución de tiempos del modelo árboles fractales mejorado . . 34

5.1. Comparación de modelos . . . . . . . . . . . . . . . . . . . . . . . . 38

1

Capítulo 1

Introducción General

En este capítulo se presenta una introducción a la investigación encarada en estetrabajo, su motivación, el alcance del trabajo realizado y una breve introduccióna las redes neuronales.

1.1. Investigación

1.1.1. Objeto de estudio

En este trabajo se estudió la posibilidad de clasificar imágenes usando redes neu-ronales en sistemas embebidos. Se buscó establecer una idea de los recursos ne-cesarios en términos de memoria RAM y los tiempos alcanzables.

1.1.2. Imágenes y modelos utilizados

En primer lugar se generaron conjuntos de imágenes en escala de grises clasi-ficables en dos categorías con el objeto de evaluar la factibilidad y los tiempospartiendo de un problema sencillo. Se generaron tres conjuntos de imágenes dis-tintos, un primer conjunto con un patrón muy sencillo y luego se fue aumentandola dificultad de los patrones y el tamaño de las imágenes. Para cada caso hubo queimplementar una red neuronal convolucional diferente y evaluar los resultados.

Posteriormente se utilizó un modelo de red neuronal ya entrenado y conocido enel ámbito de la clasificación de imágenes para evaluar resultados adicionales: unavariante de AlexNet[18] propuesta por Krizhevsky para el concurso de reconoci-miento de imágenes de gran escala de ImageNet en el año 2012.

1.1.3. Sistema y herramientas

Se implementó una solución basada en la librería CAFFE[16], desarrollada por launiversidad de Berkeley, tanto para entrenar las redes neuronales convoluciona-les como para validar y establecer los tiempos de clasificación.

2 Capítulo 1. Introducción General

1.1.4. Ambiente de prueba

El sistema que permitió validar la clasificación y evaluar los tiempos se probóen una placa Orange Pi Plus 2E1 sobre un sistema operativo linux armbian y enalgún caso también en una Raspberry Pi 3 B2 sobre un raspbian. El entrenamientode las redes neuronales por su parte se llevó a cabo en una computadora personalcon linux ubuntu.

1.2. Motivación

La clasificación de imágenes es de suma importancia para la medicina y la agroin-dustria. Además la clasificación de patrones es aplicable a muchos problemas quepueden resolverse en sistemas embebidos con redes neuronales.

La principal motivación radica en el hecho de que en el exterior se producendispositivos que utilizan redes neuronales para la solución de diversos proble-mas, algunos de ellos de un alto valor económico y otros de alto valor humano.La posibilidad de avanzar con herramientas que incorporen algoritmos de redesneuronales en sistemas embebidos permite pensar en soluciones en el marco dela industria local.

Un ejemplo es el caso de los microscopios como el de la figura 1.1 que incorporanclasificación automática. A partir de una muestra estos microscopios se puedenconfigurar para que la recorran tomando pequeñas imágenes y luego de clasi-ficar dichas imágenes automáticamente registran con mayor resolución aquellasporciones de la muestra donde se encuentran los elementos que se buscan. Haymuchos laboratorios de análisis en Argentina y son pocos los que cuentan conesta tecnología.

FIGURA 1.1: Modelo de microscopio con clasificación automáticade muestras de la empresa CytoVision.

El objetivo de este trabajo es de orden académico dada la complejidad del pro-blema, ya que los algoritmos que usan redes neuronales para clasificar imágenesademás de consumir recursos constituyen en sí mismos un desafío.

1http://www.orangepi.org/orangepiplus2e/2https://www.raspberrypi.org/products/raspberry-pi-3-model-b/

http://www.orangepi.org/orangepiplus2e/

https://www.raspberrypi.org/products/raspberry-pi-3-model-b/

1.3. Alcance 3

Se busca establecer condiciones mínimas necesarias en términos de capacidadcomputacional y memoria para lograr resultados aceptables y por otro lado de-terminar los tiempos de respuesta para determinar si se puede o no aplicar aalgún problema específico.

1.3. Alcance

El alcance propuesto para este proyecto incluyó:

Utilizar bibliotecas existentes usadas para clasificar imágenes con redes neu-ronales.

Desarrollo de un software que permita cargar la configuración de la redneuronal, la imagen, y que procese dichos datos y produzca una respuesta.

Producir un set de imágenes clasificable en dos categorías que permita en-trenar y testear el funcionamiento del sistema.

Determinar la factibilidad de implementar una red neuronal que permitaclasificar un patrón para el set de imágenes planteado.

Determinar la factibilidad de lograr resultados con un porcentaje de aciertopromedio mayor al 80 por ciento.

Determinar el tamaño máximo que podría tener una red neuronal con unaestructura dada en la plataforma probada si este es aceptable para el trabajoen cuestión.

Determinar el tiempo necesario para que la red neuronal pueda emitir unresultado de clasificación.

Quedó fuera del alcance de este proyecto:

Desarrollar una biblioteca nueva para resolver cálculos con redes neurona-les.

1.4. Introducción a las redes neuronales

Esta sección contiene una breve introducción a las redes neuronales.

1.4.1. Redes neuronales

Las redes neuronales están inspiradas en un modelo muy simplista del funciona-miento del cerebro, de allí su nombre. Consiste sencillamente en una red interco-nectada de neuronas cada una de las cuales puede activarse o inhibirse a partirdel estado de sus conexiones.

4 Capítulo 1. Introducción General

Propagación hacia adelante

En el caso de un modelo de propagación[21] hacia adelante la activación dependede las conexiónes con la capa anterior. Los datos que ingresan a la capa de entra-da son procesados considerando el parámetro de cada conexión y los resultadospasan a una segunda capa, la siguiente capa es luego procesada de forma similary los resultados son propagados hacia adelante y así sucesivamente hasta la capade salida como puede observarse en la figura 1.2. En los problemas de clasifica-ción la capa de salida contiene tantas neuronas como categorías de clasificaciónhaya para los datos de entrada.

Capas completamente conectadas

Una capa completamente conectada es aquella en la que cada neurona está co-nectada con todas las neuronas de la capa siguiente tal como se muestra a conti-nuación:

FIGURA 1.2: Ejemplo de una red neuronal con capas completa-mente conectadas.

Perceptrón

El perceptrón[25], que se representa en la figura 1.3, es la únidad básica de infe-rencia en forma de discriminador lineal que determina para cada neurona si estase activa o no a partir de los parámetros que contienen las conexiones con la capaanterior.

1.4. Introducción a las redes neuronales 5

FIGURA 1.3: Modelo del perceptrón: El producto escalar entre losvalores de las neuronas de la capa previa y los pesos de las cone-xiones es procesado por la función de activación que determina el

valor de salida para una neurona de la capa siguiente.

La ecuación 1.1 resume el cálculo de los valores asignados a las neuronas de ca-da capa de la red. El producto escalar entre los parámetros y los valores de lacapa anterior más un parámetro adicional usualmente denomidado bias son pro-cesados por una función no lineal que en realidad puede ser una combinación defunciones.

Y i = σ(W i ∗ Y i−1 +Bi) (1.1)

A la última capa de la red normalmente se le suele aplicar la función SoftMaxque ejemplificamos en la ecuación 1.2 para transformar los valores en probabili-dades que constituyen el resultado final. Esta función básicamente transforma losvalores de la última capa al rango entre 0 y 1.

S(Yi) =eYi∑nj e

Yj(1.2)

Entrenamiento

Los parámetros (pesos sinápticos) existentes en las distintas conexiones de la redse determinan a partir de un proceso de aprendizaje durante el cual se entrena ala red neuronal usando un conjunto de datos previamente clasificado. Es por estoque a este tipo de aprendizaje se lo denomina aprendizaje supervisado.

El entrenamiento básicamente busca minimizar una función de costo que se basaen la diferencia entre el resultado esperado y el obtenido para un modelo con unconjunto determinado de parámetros.

El método conocido como backpropagation[22] es el que se emplea durante elentrenamiento para determinar los parámetros de la red neuronal.

7

Capítulo 2

Introducción Específica

En este capítulo se explica como funciona una red neuronal convolucional y sepresentan ecuaciones que luego se utilizarán para calcular el espacio de memoriaocupado por las distintas capas de las redes neuronales utilizadas.

2.1. Redes neuronales convolucionales

En el caso del procesamiento de imágenes el modelo presentado en la sección1.4.1 ha sido ampliamente superado por las redes neuronales convolucionales[17].Este modelo se inspiró en los descubrimientos de biología[14] relacionados con elprocesamiento de las imágenes en el cerebro de algunos animales. Posteriormen-te Yann LeCun[19] planteó un modelo en estructura de capas convolucionalesinspirado en esos descubrimientos y desde entonces las redes neuronales convo-lucionales han revolucionado la clasificación de imágenes.

En este modelo se aprovecha la localización espacial de la información dado queen una imagen la relación existente entre pixeles próximos entre sí es mucho másimportante que la relación existente entre pixeles que están alejados espacialmen-te.

En una capa convolucional se utilizan filtros para procesar los datos de entraday generar lo que se denomina un mapa de características que luego puede a suvez ser procesado por otra capa convolucional o una capa de neuronas completa-mente conectada. Los filtros constituyen los parámetros de este tipo de capas.

El filtro se desplaza por todos los datos de entrada y en cada posición se realizaun producto escalar entre los puntos del filtro y los puntos de la capa de entradacuyo resultado determina el valor de cada punto o neurona en el mapa de carac-terísticas resultante. Cada filtro genera un mapa de características diferente y elconjunto de mapas constituye la capa siguiente.

Esto tiene dos ventajas importantes, en primer lugar los parámetros son reutili-zados dado que el mismo filtro se utiliza en distintas posiciones de la capa deentrada, en segundo lugar el número de parámetros necesarios es mucho menorque el requerido por una capa completamente conectada. En la figura 2.1 paracada filtro hacen falta 3x5x5 = 125 parámetros mientras que si se tratara de unacapa completamente conectada serían necesarios 3x32x32 = 3072.

La reutilización de los parámetros tiene como consecuencia a su vez que la detec-ción de un elemento operada por un filtro tenga la misma incidencia sin importarla región sobre la que se aplica.

8 Capítulo 2. Introducción Específica

FIGURA 2.1: Un filtro recorre las distintas posiciones de la imagenaquí presentada como un volúmen de 32x32 pixeles x3 canales (ro-jo, verde y azul), y del producto escalar entre el filtro y la parte dela imagen solapada se obtiene el valor de cada punto del mapa

resultante.

La cantidad de filtros utilizados en una capa determina la cantidad de mapas decaracterísticas generados en la capa siguiente. Como puede verse en la figura 2.26 filtros de 5x5x3 generan un conjunto de 6 mapas de características de 28x28x1 enla capa siguiente. Los filtros son los parámetros de esta red neuronal y los mapasde características las neuronas.

FIGURA 2.2: La forma de la siguiente capa de la red depente de lacantidad de filtros utilizados.

Las sucesivas capas convolucionales de estos modelos permiten detectar sucesi-vamente con un nivel de abstracción creciente: pixeles, bordes, partes, y finalmen-te objetos.

Luego de una capa convolucional se suele aplicar en algunos casos un muestreoque permite reducir la cantidad de información generada y por otra parte paraque la capa siguiente requiera menos parámetros. El muestreo que se aplica se

2.1. Redes neuronales convolucionales 9

denomina usualmente pooling y puede hacerse promediando el valor de neuro-nas adyacentes (average pooling) u obteniendo el máximo y descartando los otros(max pooling) tal como se puestran en la figura 2.3.

FIGURA 2.3: Luego de una convolución suele aplicarse poolingpara reducir la cantidad de información.

De esta forma el conjunto de datos generado por la capa convolucional se reducedrásticamente como puede verse en la figura 2.4. Una consecuencia importantede esto que que se ahorra capacidad computacional en las capas sucesivas.

FIGURA 2.4: Reducción de los datos al hacer pooling.

Es muy común aplicar posteriormente ReLu (rectified linear unit, unidad de recti-ficación lineal), que no modifica la cantidad de neuronas pero sí el valor final deestas. Suele aplicarse una función como la que se muestra en la figura 2.5.


FIGURA 2.5: Reducción de los datos al hacer pooling.

Esto suele facilitar el entrenamiento de la red neuronal. Es una forma de activarlas neuronas que tienen un valor que supera cierto umbral y desactivar las otras.

Las redes neuronales convolucionales suelen tener varias capas convolucionalesconsecutivas como se sugiere en la figura 2.6 y finalizan con capas completamenteconectadas antes de aplicar una función del estilo soft-max que permite obtenerla probabilidad de que una imagen pertenezca a una determinada categoría.

FIGURA 2.6: Las redes neuronales convolucionales suelen combi-nar un grupo de capas convolucionales y posteriormente capas

completamente conectadas.

2.2. Cálculo de la memoria ocupada

En esta sección se plantea la forma de calcular la memoria utilizada por una redneuronal convolucional.

2.2.1. Dimensión de la capa convolucional

La convolución de un filtro por la capa de entrada puede hacerse aplicando re-lleno en los bordes. En estos casos los espacios se rellenan con ceros, y desplazan-do más de una posición a la vez el filtro. La dimensión del espacio de salida varíasegún estos parámetros.

2.2. Cálculo de la memoria ocupada 11

La profundidad de la capa de salida está dada por la cantidad de filtros. Cuandoun filtro se desplaza por toda la capa de entrada da como resultado una rebanadade la capa de salida como se muestra en la figura 2.7.

FIGURA 2.7: Cada filtro recorre todo el volumen de la capa de en-trada para generar un elemento bidimensional en la capa de sali-

da.

Por lo tanto si en una capa convolucional se utiliza una cantidad H de filtros, ladimensión en profundidad de la salida será H como se muestra en la figura 2.8.

FIGURA 2.8: La profundidad de la capa de salida depende de lacantidad de filtros utilizados.

Las dimensiones laterales son las que resultan del desplazamiento del filtro y delrelleno que se aplique.

Simplificando la aritmética propuesta por Dumoulin y Visin[26] y teniendo encuenta las siguientes denominaciones:

N: dimensión lateral de la capa de entrada.

k: dimensión lateral del filtro.

O: dimensión lateral de la capa de salida.

s: desplazamiento del filtro.

r: relleno.

la dimensión lateral de la capa de salida puede expresarse con la fórmula 2.1 sino se aplica relleno y con la fórmula 2.2 si se aplica relleno.

O =

⌊N − k

s

⌋+ 1 (2.1)


O =

⌊N + 2r − k

s

⌋+ 1 (2.2)

La dimensión del volúmen de la capa de salida será O x O x H.

En las figuras 2.9 y 2.10 se muestra el resultado de una convolución sobre unainstancia de la capa de entrada dando como resultado una instancia de la capade salida pero se debe tener en cuenta que en realidad la capa de entrada es tridi-mensional, también el filtro y lo mismo la capa de salida.

En la figura 2.9 se aplica un filtro de 3x3 a una entrada de 4x4 sin relleno en losbordes y desplazando el filtro un lugar a la vez.

O =

⌊4− 3

1

⌋+ 1 = 2 (2.3)

FIGURA 2.9: El filtro (celeste oscuro) se desplaza por la capa deentrada (celeste claro) generando en cada posición un elementodel mapa de características resultante en la capa de salida (verde).

En la figura 2.10 se aplica un filtro de 3x3 a una entrada de 5x5 con un espacio derelleno en los bordes y desplazando el filtro dos lugares a la vez.

O =

⌊5 + 2− 3

2

⌋+ 1 = 3 (2.4)

FIGURA 2.10: Un filtro de 3x3 se desplaza por la capa de entradade 5x5, rellenada con un espacio, el mapa resultante es de 3x3.

En caso de aplicar pooling vale la ecuación 2.1.

2.2.2. Ejemplo

A continuación se ejemplifica como calcular la memoria ocupada para un modelosimple como el de la figura 2.11.

2.2. Cálculo de la memoria ocupada 13

FIGURA 2.11: Modelo simplificado de una red neuronal con unacapa convolucional con pooling seguida de una capa completa-mente conectada a una salida de seis categorías. El filtro es de 5x5,no se usa relleno y se desplaza de un lugar a la vez. Se aplica poo-ling con un filtro de 2x2 y desplazamiento de dos lugares a la vez.

Este modelo tiene como entrada una imagen de 50x50 en colores y por lo tan-to 3 de profundidad. La primer capa convolucional tiene 10 filtros de 5x5x3, nose aplica relleno y el filtro se desplaza un lugar a la vez. Por lo tanto según laecuación 2.1 la dimensión lateral de la salida es:

O =

⌊50− 5

1

⌋+ 1 = 46 (2.5)

Y por lo tanto la salida será de 46x46x10. Posteriormente se aplica pooling conun filtro de 2x2 y con un desplazamiento de dos lugares a la vez por lo que ladimensión lateral resultante según la ecuación 2.1 es:

O =

⌊46− 2

2

⌋+ 1 = 23 (2.6)

El vector V1 de la figura 2.11 representa los elementos de la capa anterior en formade vector por lo que contiene 23x23x10 elementos, esto es 5290. Los parámetrosde una capa completamente conectadas representados por W dependen de la di-mensión de las capas que conectan, en este caso V1 y V2 tienen dimensión 5290 y6 respectivamente con lo que la dimensión de W es 5290x6, esto es 31740.

Finalmente considerando que cada elemento requiere 4 bytes, se representa lamemoria ocupada por toda la red en la tabla 2.1.


TABLA 2.1: Memoria ocupada por un modelo simplificado de redneuronal convolucional

Componente Elementos Memoria

Entrada 50x50x3 29 kbytesFiltros 10x5x5x3 3 kbytesSalida 46x46x10 83 kbytesPooling 23x23x10 21 kbytesV1 5290 21 kbytesV2 6 24 bytesW 31740 124 kbytes

Total 305 kbytes

Nótese que los parámetros de este modelo están constituidos por la suma de losfiltros y W. Por otra parte según se implemente el vector V1 puede o no ocupar elmismo espacio de memoria que la salida producida por el proceso de pooling.

15

Capítulo 3

Diseño e Implementación

En este capítulo se detallan los métodos y herramientas utilizadas y el modo deempleo de las mismas para reproducir los resultados obtenidos durante este tra-bajo.

3.1. Generación de imágenes

En esta sección se explica el proceso de generación de los bancos de imágenesusados en este trabajo.

3.1.1. Implementación

Se crearon tres proyectos similares para generar los bancos de imágenes usadospara este trabajo. Estos proyectos se encuentran dentro de la carpeta /images enun repositiorio de github[10].

Se buscó que las imágenes sean en escala de grises y que las imágenes de los tresbancos tengan distinto tamaño y complejidad. Las imágenes del primer bancocontienen trazos, las del segundo figuras y las del tercero una combinación delíneas, esferas y árboles fractales. En todos los casos los parámetros de los ele-mentos que componen las imágenes se generan al azar.

Trazos: Imágenes de 100x100 unas con curvas, otras con líneas rectas. Sepueden clasificar según si contienen curvas o líneas.

Figuras: Imágenes de 200x200 con círculos o rectángulos. Se pueden clasifi-car según la figura que contienen.

Árboles: Imágenes de 300x300 con pequeñas líneas dispersas, esferas y ár-boles fractales. Se pueden clasificar según si tienen o no árboles fractales.

En los tres casos se usó la librería cairo[5] para generar las imágenes.

3.1.2. Dependencias

Es necesario que el sistema operativo Linux que se utilice para generar las imá-genes contenga las herramientas básicas de compilación, la librería gtk+-3.0 y losincludes de cairo en el path del sistema.

16 Capítulo 3. Diseño e Implementación

El archivo Makefile que se incluye en cada proyecto se encarga de generar losparámetros para la compilación.

3.1.3. Ejecución

Una vez descargado el repositorio solo hace falta usar la línea de comandos paraposicionarse en los tres proyectos mencionados en la sección 3.1.1, compilar, ygenerar las imágenes.

Al ejecutar make se genera un ejecutable en la carpeta build:

$ make

Luego se generan las imágenes (el proceso puede demorar algunos minutos):

$ ./ bui ld/create_images

Esto genera tres directorios:

project/img: imágenes para el proceso de entrenamiento.

project/test: imágenes para el proceso de testing.

project/validate: imágenes de validación.

Y al mismo tiempo se generan tres archivos de texto:

train_file.txt: listado de las imágenes de entrenamiento.

test_file.txt: listado de las imagenes de testing.

validate_file.txt: listado de las imágenes de validación.

Cada lista contiene una línea por cada imagen generada, cada línea contiene elnombre del archivo y un número que indica a que categoría pertenece.

3.2. Caffe

En esta sección se explica la elección de la librería Caffe[16], su instalación y modode uso en términos generales.

3.2.1. Framework

Caffe es un framework para deep learning desarrollado por el depto de investi-gación de inteligencia artificial de la universidad de Berkeley.

Se eligió usar este framework luego de evaluar la documentación disponible, losresultados en términos de desempeño y el hecho de que se puede utilizar en len-guaje C++ lo cual se considera necesario en principio para lograr el mejor rendi-miento posible. A su vez el framework es activamente utilizado por una comu-nidad científico universitaria que en cierta forma garantiza que se cuenta con losúltimos avances en la materia.

Las clases más importantes del framework son:

3.2. Caffe 17

Solver: se encarga de gestionar el aprendizaje de la red y generar los pará-metros.

Net: representa la estructura de una red neuronal.

Layer: cada una de las capas de la red, se puede customizar implementandolas funciones forward, backward y setup.

Blob: envoltorio de los datos que pasan de una capa a otra de la red.

Caffe facilita su uso a partir de algunos archivos:

1. solver.prototxt

2. train.prototxt

3. deploy.prototxt

El primero define los parámetros para el entrenamiento de la red, el tipo de gra-diente utilizado para actualizar los parámetros y mejorar el error. El segundo de-fine la estructura de la red durante el entrenamiento y el testing. Y el tercero laestructura de la red para realizar la clasificación. La diferencia fundamental entrelos dos últimos es que durante el entrenamiento para cada layer se puede espe-cificar como se inician los parámetros y una serie de constantes que hacen a laevolución de los mismos durante el aprendizaje.

Una vez que se cuenta con un sistema funcional el trabajo radica en la modifica-ción de estos archivos.

3.2.2. Instalación del framework

La instalación puede ser fácil en la última versión de ubuntu pero en versionesanteriores y en otras versiones de linux requiere instalar las dependencias indivi-dualmente y en algún caso compilarlas localmente.

Las dependencias más notables son:

Protobuf: para serializar los parámetros de la red neuronal.

Blas: rutinas para realizar operacines de álgebra lineal, elegimos OpenBlas.

OpenCV: interviene en diferentes procesos relacionados con preprocesa-miento de imagenes, manejo de memoria y acceso a recursos del sistemaoperativo.

El sitio web de Caffe cuenta con una guía completa para instalar la mayoría delas dependencias[2].

En el caso de OpenBlas[23] compilarla localmente asegura que se utiliza la abiapropiada para aprovechar la arquitectura del procesador. En este caso se utilizóla configuración disponible para ARMV7.

En el caso de OpenCV resulta conveniente seguir la guía oficial[24].


3.3. Compilación del software del proyecto

Luego de haber compilado Caffe para lo cual puede seguirse la guía oficial[3] sepueden compilar los archivos del proyecto.

El archivo Makefile que está en el repositorio es el original de Caffe pero tienealgunas modificaciones para que se pueda compilar fácilmente proyecto.

Para compilar el proyecto ejecutar el siguiente comando:

$ make p r o j e c tCXX p r o j e c t /herramientas/entrenador . cppCXX/LD −o . b u i l d _ r e l e a s e / p r o j e c t /herramientas/entrenador . binCXX p r o j e c t /herramientas/ c l a s i f i c a d o r . cppCXX/LD −o . b u i l d _ r e l e a s e / p r o j e c t /herramientas/ c l a s i f i c a d o r . bin

3.4. Sistema de entrenamiento

Este sistema está basado en las principales clases de Caffe mencionadas anterior-mente, la mayor parte del programa está dedicado a cargar los archivos necesa-rios e inicializar las clases con sus respectivos parámetros.

El sistema implementado en clasificador.cpp permite resolver el entrenamientode la red neuronal y obtener las estadísticas relativas a los tiempos que demandaprocesar la estructura de la red.

En caso del entrenamiento se encarga de todo el método Solve() de la clase Solver(solver->Solve()). El trabajo radica en editar el archivo solver.prototxt con la con-figuración del Solver lo cual puede tener como consecuencia que se llegue o no aun resultado positivo.

Para generar las estadísticas en cambio hubo que iterar por las capas de la redneuronal y ejecutar el método Forward() de cada capa para determinar cuantotiempo tarda cada usando un Timer.

3.4.1. Uso del sistema de entrenamiento

Antes de entrenar la red neuronal es necesario crear bases de datos con las imá-genes de entrenamiento y testing. Esto mejora la velocidad del proceso de en-trenamiento. Además también hace falta generar un archivo con la media de lasimágenes del banco de entrenamiento. Se creó un script para realizar estas tareaspreviamente.

El sistema entrenador requiere una serie de parámetros, el modelo de la red parael entrenamiento, que ya está en el repositorio, una constante que indica si se vaa entrenar una red o a generar las estadísticas, la configuración del solver en casode entrenamiento, y los parámetros generados durante el entrenamiento en casode generar las estadísticas.

. . / . . / bui ld/ p r o j e c t /herramientas/entrenador . bin t r a i n \−−s o l v e r= s o l v e r . p r o t o t x t $@

3.5. Sistema de clasificación 19

Dado que algunos de estos archivos ya están en el repositorio se creó un conjuntode scripts para facilitar el uso del sistema.

Estos scripts requieren posicionarse en el directorio del modelo (ej: /project/ar-boles).

Para incorporar las imágenes generadas en bases de datos y generar un archivocon la media de toda las imágenes:

./ preprocess . sh

Para iniciar el proceso de entrenamiento de la red neuronal:

./ t r a i n . sh

Para obtener los tiempos de clasificación, en este caso hace falta el archivo .caffe-model generado durante el entrenamiento:

./ benchmark . sh t r a i n . caffemodel

3.5. Sistema de clasificación

El desarrollo del sistema de clasificación resultó bastante simple pues para rea-lizar una inferencia es posible hacerlo a partir de cargar el modelo de la red, losparámetros generados durante el entrenamiento, una imágen, y ejecutar el méto-do Forward() implementado por la clase Net.

Un detalle importante que demandó trabajo y generó algunos problemas es quelas imágenes deben ser preprocesadas de la misma manera que durante el en-trenamiento. Y durante el entrenamiento las imágenes son preprocesadas segúncomo se configura el primer layer de la red en el archivo train.prototxt.

En nuestro caso las imágenes se preprocesan usando el archivo con la media delas imágenes de entrenamiento generado inicialmente.

3.5.1. Uso del sistema de clasificación

La herramienta que se desarrolló para la clasificación (clasificador.cpp) puedeusarse de dos maneras: para clasificar una imagen o para validar la red neuro-nal contra las imágenes de validación.

Para clasificar una imágen y obtener la categoría a la que pertenece hace faltaademás de lo mencionado un listado con los nombres de las categorías de clasifi-cación.

Para clasificar una imágen se inicia el proceso de la siguiente forma:

. . / . . / bui ld/ p r o j e c t /herramientas/ c l a s i f i c a d o r . bin deploy . p r o t o t x t \t r a i n . caffemodel mean . binaryproto l a b e l s . t x t imagen . png

Para realizar la validación hace falta el listado de las imágenes de validación.

Para validar el modelo se inicia el proceso de la siguiente forma:


. . / . . / bui ld/ p r o j e c t /herramientas/ c l a s i f i c a d o r . bin deploy . p r o t o t x t \t r a i n . caffemodel mean . binaryproto l a b e l s . t x t v a l i d a t e _ f i l e . t x t

Dado que tanto el modelo como el listado con las etiquetas ya están en el repo-sitorio y el archivo con la media es generado inicialmente, para facilitar el usose creó un script que puede recibir solo dos parámetros: el archivo con los pa-rámetros cuyo nombre puede variar según el número de iteraciones realizadasdurante el entrenamiento y otro archivo que puede ser una imágen o el listadopara la validación.

El script para clasificar o validar es el siguiente:

./ v a l i d a t e . sh t r a i n . caffemodel [ imagen o archivo con l i s t a d o ]

21

Capítulo 4

Ensayos y Resultados

En este capítulo se presentan las imágenes generadas, las pruebas de clasificaciónrealizadas y los resultados obtenidos.

4.1. Bancos de imágenes generados

A continuación se muestran ejemplos de las imágenes de los bancos de imágenesgenerados para este trabajo. Teniendo en cuenta el contenido de las imágenescomo se explicó en la sección 3.1.1 se denominó a los tres modelos de la siguienteforma: trazos, figuras, y árboles.

4.1.1. Trazos

En primer lugar se generaron imágenes de 100x100 con curvas y líneas con pará-metros al azar cuyos ejemplos pueden observarse en la figura 4.1

FIGURA 4.1: Ejemplos de las imagenes generadas para el modelotrazos

Para este modelo se creó:

Un conjunto de 20000 imágenes de entrenamiento.

Un conjunto de 4000 imágenes de testing.

Un conjunto de 200 imágenes de validación.

4.1.2. Figuras

En segundo lugar se generaron imágenes de 200x200 con círculos y rectángulostodos con posiciones y parámetros al azar cuyos ejemplos se pueden observar enla firgura 4.2

22 Capítulo 4. Ensayos y Resultados

FIGURA 4.2: Ejemplos de las imágenes generadas para el modelofiguras





4.1.3. Árboles

Por último y con la intención de simular una posible muestra analizable por unmicroscopio se generaron imágenes todas con pequeñas líneas y esferas al azar ya la mitad de estas imágenes se les agregó un árbol fractal con parámetros al azar.Los ejemplos pueden observarse en la figura 4.3

FIGURA 4.3: Ejemplos de las imagenes generadas para el modeloárboles





4.2. Modelo empleado 23

4.2. Modelo empleado

En esta sección se explica la estructura de la red neuronal convolucional utilizadainicialmente para clasificar cada uno de los bancos de imágenes generados.

4.2.1. Modelo inicial

El primer modelo se basó en LeNet-5[20], la estructura usada por Yann LeCun[19]para clasificar imágenes en blanco y negro de 32x32 pixeles. Se partió de este mo-delo porque el contenido de las imágenes clasificadas por LeNet-5 contiene ca-racteres, esto es trazos que conforman figuras, y porque están en blanco y negro.

Se utilizó un modelo similar al representado en la figura 4.4 aumentando la can-tidad de filtros de la primer capa o su tamaño hasta lograr superar el 80 % deacierto. Aumentar la cantidad de filtros o su tamaño tiene como consecuenciaque aumenta el número de parámetros de la red y cuanto mayor es el númerode parámetros de una red neuronal mejores resultados se obtienen. Como contra-parte esto también tiene como consecuencia un mayor uso de memoria RAM ymás cálculos para obtener un resultado.

Las estructuras de datos de cada modelo difieren como consecuencia de la dife-rencia de tamaño de la imagen de entrada. La variación de la dimensión de laimágen propaga cambios en las dimensiones de las estructuras resultantes salvoen la parte final de la red neuronal dado que la dimensión del vector V2 siemprees de 500 y la de v3 es 2. Es por esta razón que la matríz W2 siempre es de 500x2.En todos los casos se aplicó max pooling a los features maps generados por lasconvoluciones y se usaron matrices de 2x2 con un desplazamiento de dos pasos,lo cual reduce la capa previa a la mitad. La dimensión del vector V1, de aquí enmás D1, depende siempre de la capa anterior dado que V1 contiene tantos ele-mentos como elementos hay distribuidos en los distintos sub mapas de la capaanterior. La dimensión de V2 es 500 por lo cual W1 es una matriz de D1x500. Acontinuación se analiza que ocurre con los filtros y los datos generados por cadaproceso en cada una de las variantes empleadas.


FIGURA 4.4: Estructura de la red neuronal utilizada. La imágenaparece en color naranja, los datos generados en azul y los pará-metros en color verde. Los procesos se representan con una flecharoja. Los procesos de convolución, Conv 1 y 2, usan filtros paraprocesar la capa previa y producir mapas como salida: Maps 1 y2. Los procesos de pooling reducen la capa previa. Los procesos IPconstituyen capas completamente conectadas. V1 representa losdatos de Maps 1 en forma de vector. Este vector constituye la en-trada y W1 los pesos psinápticos que se aplican al perceptrón paraobtener la salida V2. Similarmente ocurre con el siguiente procesoIP2, el cual genera el vector V3 cuya dimensión equivale al núme-ro de categorías en las que se clasifican las imágenes. Finalmen-te los valores obtenidos se transforman en las probabilidades que

constituyen el resultado de la calsificación.

4.2.2. Modelo trazos

En este caso se usaron 30 filtros de 5x5x1 para Conv1, esto es 10 más que la versiónoriginal de LeNet, y 50 filtros de 5x5x30 para Conv2. En ambos casos el desplaza-miento fue de un paso a la vez.

4.2.3. Modelo figuras

En este caso hubo que agregar otros 10 filtros más que en el modelo anterior y asu vez hubo que aumentar el tamaño de los mismos para lograr que el modelosupere un acierto del 80 %. Por lo tanto se usaron 40 filtros de 7x7x1 para Conv1y 50 filtros de 5x5x40 para Conv2. En ambos casos el desplazamiento fue de unpaso a la vez.

4.3. Memoria 25

4.2.4. Modelo árboles

En este caso no se realizaron cambios dado que el modelo anterior superó holga-damente el 80 % de acierto. Se usaron 40 filtros de 7x7x1 para Conv1 y 50 filtrosde 5x5x40 para Conv2. En ambos casos el desplazamiento fue de un paso a la vez.

4.3. Memoria

En esta sección se analiza la memoria necesaria en cada caso tanto para los datoscomo para los parámetros de la red neuronal. En todos los casos se considera quecada elemento ocupa 32bits.


En las tablas 4.1 y 4.2 se representan los valores para el modelo empleado paraclasificar las imágenes con curvas y líneas. En la primer tabla se presentan losdatos y en la segunda los parámetros.

Dado que las imágenes son de 100x100 al aplicar 30 filtros de 5x5x1 se obtienecomo salida un conjunto de 30 mapas de 96x96. Esto se reduce con max pooling a30 mapas de 48x48. Luego al aplicar 50 filtros de 5x5x30 se obtiene un conjunto de50 mapas de 44x44. Luego esto se reduce con max pooling a 50 mapas de 22x22.El vector V1 contine la misma cantidad de elementos de la capa anterior, esto es22x22x50. Finalmente el vector V2 contiene 500 elementos.

TABLA 4.1: Memoria necesaria para los datos del modelo trazos

Capa Elementos Memoria

Data 100x100 39 kbytesMaps1 96x96x30 1080 kbytesSub1 48x48x30 270 kbytesMaps2 44x44x50 378 kbytesSub2 22x22x50 95 kbytesV1 24200 95 kbytesV2 500 2 kbytes

Total 2 Mbytes

El tamaño total que figura en la tabla 4.2 coincide con el tamaño del archivo quegenera el proceso de entrenamiento.


TABLA 4.2: Memoria necesaria para los parámetros del modelotrazos


Filtros Conv1 30x5x5x1 3 kbytesFiltros Conv2 50x5x5x30 147 kbytesW1 24200x500 47265 kbytesW2 500x2 4 kbytes

Total 47 Mbytes


En las tablas 4.3 y 4.4 se representan los valores para el modelo empleado paraclasificar las imágenes con círculos y rectángulos. En la primer tabla se presentanlos datos y en la segunda los parámetros.

Dado que las imágenes son de 200x200 al aplicar 40 filtros de 7x7x1 se obtienecomo salida un conjunto de 40 mapas de 194x194. Esto se reduce con max poolinga 40 mapas de 97x97. Luego al aplicar 50 filtros de 5x5x40 se obtiene un conjuntode 50 mapas de 93x93. Luego esto se reduce con max pooling a 50 mapas de 47x47.El vector V1 contine la misma cantidad de elementos de la capa anterior, esto es47x47x50. Finalmente el vector V2 contiene 500 elementos.

TABLA 4.3: Memoria necesaria para los datos del modelo figuras



Total 7,8 Mbytes


TABLA 4.4: Memoria necesaria para los parámetros del modelofiguras



Total 202 Mbytes

4.4. Tiempos de clasificación 27


En las tablas 4.5 y 4.6 se representan los valores para el modelo empleado paraclasificar las imágenes con árboles fractales. En la primer tabla se presentan losdatos y en la segunda los parámetros.

Dado que las imágenes son de 300x300 al aplicar 40 filtros de 7x7x1 se obtiene co-mo salida un conjunto de 40 mapas de 294x294. Esto se reduce con max pooling a40 mapas de 147x147. Luego al aplicar 50 filtros de 5x5x40 se obtiene un conjuntode 50 mapas de 143x143. Luego esto se reduce con max pooling a 50 mapas de72x72. El vector V1 contine la misma cantidad de elementos de la capa anterior,esto es 72x72x50. Finalmente el vector V2 contiene 500 elementos.

TABLA 4.5: Memoria necesaria para los datos del modelo árboles



Total 21,8 Mbytes


TABLA 4.6: Memoria necesaria para los parámetros del modeloárboles



Total 494,6 Mbytes

Se puede observar en las tablas con los parámetros de cada modelo que W1 escalade forma problemática.

4.4. Tiempos de clasificación

En esta sección se presentan los tiempos de clasificación obtenidos para cada unode los modelos trabajados en la Orange Pi Plus 2E. Esta placa cuenta con un proce-saror quad-core ARM Cortex-A7[13] que funciona a 1.296GHz y 2GB de memoriaRAM DDR3 y el sistema operativo utilizado es armbian.



TABLA 4.7: Distribución de tiempos del modelo trazos

Capa Tiempo de clasificación

Data 0,01 msConv1 7,32 msPool1 9,86 msConv2 52,76 msPool2 3,27 msIp1 65,10 msRelu1 0,02 msIp2 0,05 msProb 0,03 ms

Total 138,42 ms


En la tabla 4.8 puede apreciarse que ya en la aplicación de este modelo las capasConv2 e Ip1 afectan el tiempo de clasificación total.

TABLA 4.8: Distribución de tiempos del modelo figuras



Total 737,46 ms


En la tabla 4.9 puede observarse como la cantidad de datos de la estructura afectalos tiempos de clasificación siendo las capas Conv1 e Ip2 las que mayor tiempoinsumen.

4.5. Exactitud de la clasificación 29

TABLA 4.9: Distribución de tiempos del modelo árboles



Total 1724,57 ms

4.5. Exactitud de la clasificación

En la tabla 4.10 se resumen los datos anteriores junto con la exactitud lograda porlos distintos modelos al validar contra las imágenes del set de validación. Puedededucirse que la exactitud de los resultados aumenta ligeramente con un costoen recursos y tiempo excesivo.

TABLA 4.10: Exactitud de la clasificación lograda por cada modelo

Modelo Exactitud Memoria Tiempo

Trazos 82 % 49 Mbytes 138 msFiguras 85 % 202 Mbytes 737 msÁrboles 95 % 494 Mbytes 1725 ms

Esto se intentó mejorar en términos de tiempo y recursos luego de analizar elmodelo que se presenta en la sección 4.6.

4.6. AlexNet

En esta sección se muestran los resultados obtenidos probando el modelo Alex-Net ya entrenado. El modelo que Alex Krizhevsky utilizó para el concurso deImageNet de 2012 [18] logró una tasa de validación cercana al 85 %.

En este caso además se realizaron pruebas adicionales sobre una placa RaspberryPi 3 B para tener resultados con los que comparar los obtenidos en la Orange Pi.La Raspberry cuenta con un procesaror 64 bits quad-core ARM Cortex-A53[12]que funciona a 1.2GHz, 1GB de memoria RAM DDR2, y en este caso se utilizó elsistema operativo raspbian.


4.6.1. Modelo

El modelo AlexNet que se muestra en la figura 4.5 tiene una primer capa convo-lucional con desplazamiento de cuatro unidades lo cual reduce notablemente lacantidad de datos de la siguiente capa. Lo mismo ocurre cuando se aplica poolingsiempre con un desplazamiento de dos unidades. Esto a su vez reduce el númerode parámetros y por lo tanto los cálculos necesarios para clasificar una imágen.

FIGURA 4.5: Estructura de la red neuronal utilizada en el modeloAlexNet. En este modelo se concatenan cinco capas convolucio-nales seguidas de tres capas completamente conectadas. Las ca-pas convolucionales son seguidas de algunos de los procesos relu,

pooling y normalización.

4.6.2. Memoria ocupada

En la tabla 4.11 se resume la memoria ocupada por los parámetros del modeloAlexNet lo cual coincide con el archivo que se puede descargar de internet[4]. Sepuede observar que los parámetros se reducen notablemente antes de llegar a lascapas completamente conectadas lo cual influye en la mejora de los tiempos declasificación.

4.6. AlexNet 31

TABLA 4.11: Memoria necesaria para los parámetros del modeloAlexNet


Filtros Conv1 96x11x11x3 132 kbytesFiltros Conv2 256x5x5x96 2400 kbytesFiltros Conv3 384x3x3x256 3456 kbytesFiltros Conv4 384x3x3x384 5184 kbytesFiltros Conv5 256x3x3x384 3456 kbytesW1 9216x4096 147456 kbytesW2 4096x4096 65536 kbytesW3 4096x1000 16000 kbytes

Total 238 Mbytes

La cantidad de parámetros es considerablemente menor que en el modelo quese planteó inicialmente en este trabajo. La primer capa convolucional aplica undesplazamiento de los filtros de cuatro posiciones, pero esto lejos de implicar unapérdidad de información más bien logra abstraer en los parámetros las carácte-rísticas necesarias para lograr una clasificación eficaz.

4.6.3. Tiempos de Clasificación

En la tabla 4.12 se muestran los tiempo insumidos por cada proceso durante laclasificación con el modelo AlexNet. En la misma se observa que la segunda capaconvolucional y la primera completamente conectada son las que insumen mayortiempo.

La diferencia de tiempos obtenidos entre las dos placas utilizadas se debe fun-damentalmente a que la Raspberry utiliza un procesaror Cortex A-53 que tienealgunas mejoras con respecto al Cortex A-7 de la Orange Pi. Si bien el CortexA-53 es de 64 bits el sitema operativo de la Raspberry es de 32 bits y la libreríaOpenBlas se compiló de forma similar para ambas placas, por lo que la diferen-cia fundamental está relacionada con las mejoras de desempeño del Cortex A-53referidas por ARM[12] en lo que respecta al manejo de la cache, el pipeline y launidad de punto flotante.


TABLA 4.12: Distribución de tiempos del modelo AlexNet

Capa Orange Pi Raspberry Pi

Conv1 60,79 ms 39,88 msRelu1 5,45 ms 4,24 msPool1 16,10 ms 12,57 msNorm1 27,78 ms 7,14 msConv2 109,53 ms 79,52 msRelu2 3,47 ms 2,72 msPool2 9,77 ms 8,14 msNorm2 17,52 ms 5,11 msConv3 64,15 ms 47,99 msRelu3 1,12 ms 0,94 msConv4 58,18 ms 38,43 msRelu4 1,11 ms 0,93 msConv5 37,29 ms 27,08 msRelu5 0,75 ms 0,62 msPool5 2,48 ms 2,06 msFc6 213,63 ms 187,00 msRelu6 0,08 ms 0,07 msFc7 80,22 ms 67,30 msRelu7 0,08 ms 0,07 msFc8 21,63 ms 17,14 msProb 0,25 ms 0,25 ms

Promedio 732,15 ms 549,20 ms

4.7. Árboles mejorado

En esta sección se muestran los cambios realizados al modelo de los árboles frac-tales para lograr un mejor tiempo de clasificación y menor uso de recursos.

4.7.1. Modelo

En el caso del modelo AlexNet dada la cantidad de categorías de clasificación esentendible que los parámetros de la red neuronal ocupen un espacio de memo-ria consierable. Pero en el caso del modelo planteado inicialmente para el bancode imágenes de los árboles fractales no es razonable que ocupe más del dobleque el modelo AlexNet dado que en el caso de los árboles fractales solo hay doscategorías.

A partir de considerar las capas más críticas de la red neuronal se cambió el mo-delo usado inicialmente para reducir al máximo los parámetros necesarios. Paralograrlo se utilizó mayor desplazamiento de los filtros para que las capas convo-lucionales reduzcan inicialmente la dimensión de los datos y se agregó una capaconvolucional más para lograr un mayor aprendizaje de la red en profundidad.Si bien lo primero implica pérdida de información lo segundo ayuda a que la redsea más efectiva abstrayendo durante el aprendizaje las características más im-portantes para la clasificación. Además se aplicó la función ReLu a los resultados

4.7. Árboles mejorado 33

de las capas convolucionales para que mejoren los tiempos de entrenamiento. Seprobó de diversas maneras buscando que la exactitud de la validación no bajaradel ochenta por ciento. El modelo logrado se puede apreciar en la figura 4.6

FIGURA 4.6: Estructura de la red neuronal utilizada. Se agrega unacapa convolucional al modelo propuesto. Para la convolución ini-cial se usan 50 filtros de 11x11x1, para la segunda y tercera se usan50 filtros de 5x5x50 respectivamente. De esta manera se logra que

la matríz W1 sea de 800 x 500.

4.7.2. Memoria ocupada

Este modelo permitió reducir drásticamente la memoria teórica requerida comopuede apreciarse en las tablaa 4.13 y 4.14

TABLA 4.13: Memoria necesaria para los datos del modelo árbolesmejorado


Data 300x300 351 kbytesFMaps1 145x145x50 4107 kbytesSMaps1 73x73x50 1041 kbytesFMaps2 35x35x50 240 kbytesSMaps2 18x18x50 64 kbytesFMaps3 7x7x50 10 kbytesSMaps3 4x4x50 3 kbytesV1 800 3 kbytesV2 500 2 kbytes

Total 5,4 Mbytes



TABLA 4.14: Memoria necesaria para los parámetros del modeloárboles mejorado


Filtros Conv1 50x11x11x1 24 kbytesFiltros Conv2 50x5x5x30 244 kbytesFiltros Conv3 50x5x5x30 244 kbytesW1 800x500 1563 kbytesW2 500x2 4 kbytes

Total 2 Mbytes

4.7.3. Tiempos de Clasificación

Al mismo tiempo se lograron tiempos de clasificación mucho mejores tal comopuede apreciarse en la tabla 4.15 en la que se muestran los tiempos logrados tantoen la Orange Pi como en la Raspberry.

TABLA 4.15: Distribución de tiempos del modelo árboles fractalesmejorado

Capa Orange Pi Raspberry Pi

Data 0,01 ms 0,01 msConv1 93,99 ms 71,53 msRelu1 19,35 ms 15,50 msPool1 39,03 ms 28,63 msConv2 57,81 ms 42,90 msRelu2 1,01 ms 0,90 msPool2 2,02 ms 1,62 msConv3 2,52 ms 2,00 msPool3 0,23 ms 0,19 msIp1 5,01 ms 2,53 msRelu3 0,02 ms 0,02 msIp2 0,04 ms 0,03 msProb 0,03 ms 0,02 ms

Promedio 221,07 ms 165,88 ms

4.7.4. Resultado final

Los tiempos logrados son considerablemente mejores que los iniciales para elmismo banco de imágenes. Pero indudablemente lo más importante es la reduc-ción drástica del espacio de memoria RAM requerido por el modelo. Esto se logrócon la desventaja de que la exactitud de la validación bajó del 95 a 84 %, por enci-ma, de todas formas, del objetivo planteado inicialmente.

4.8. Dificultades encontradas 35

4.8. Dificultades encontradas

En esta sección se resumen algunos de los inconvenientes con los que nos encon-tramos durante el desarrollo y las pruebas realizadas.

4.8.1. El requisito del lenguaje

Se propuso utilizar el lenguaje C o C++ con la intención de lograr los mejorestiempos de clasificación posibles y si bien Caffe, la librería seleccionada, permi-te trabajar en C++, usualmente es utilizada a partir de wrappers de python porlo que la inexistencia de un ejemplo completo en C++ generó un problema ini-cial. Se encontraron ejemplos por un lado para realizar el entrenamiento y otrosincompatibles para clasificar pero no ambas cosas al mismo tiempo.

Esto demoró inicialmente la obtención de resultados hasta que se obtuvo un pri-mer sistema funcional. Una vez logrado esto el software en sí dejó de ser un pro-blema y se concentró el esfuerzo en la configuración de las redes neuronales y enla forma de mejorar los resultados.

4.8.2. Las dependencias de las librerías

Inicialmente se había planeado utilizar una librería en lenguaje C[11] que permi-te realizar inferencias con redes neuronales con capas completamente conectadas.Pero al arrancar con este trabajo y descubrir que era necesario usar redes neuro-nales convolucionales hubo que seleccionar otra librería.

También se había planeado utilizar la librería seleccionada inicialmente en unaplaca como la EDU-CIAA[8] o la CIAA-NXP[7] para poder establecer una com-paración con los resultados obtenidos en la Orange Pi. Pero al cambiar de libreríay avanzar en la problemática de las redes neuronales convolucionales pronto fueclaro que por varias razones no era posible utilizar las placas mencionadas. Enprimer lugar, y excluyente por sí mismo, porque la memoria necesaria para resol-ver este tipo de problemas es mayor a la que disponen dichas placas. En segundolugar porque las librerías existentes para este tipo de tareas usualmente se ba-san en otras librerías como OpenCV en el caso de Caffe que tienen requisitos desistema que no se pueden resolver en este tipo de placas.[9]

Es por esto que se decidió incluir una Raspberry Pi para complementar los resul-tados finales con una comparación de los tiempos logrados en la Orange Pi.

37

Capítulo 5

Conclusiones

En este capítulo se resumen los criterios alcanzados durante el desarrollo de estetrabajo y las consideraciones realizadas sobre las posibles líneas de trabajo tantopara continuar profundizandolos como para aplicarlos a una solución.

5.1. Conclusiones generales

En esta sección se resumen los criterios y los resultados alcanzados.

5.1.1. Trabajo realizado

Los problemas resueltos durante este trabajo, sumado a los criterios adquiridosdurante la especialización, permiten tomar decisiones pensando en una soluciónpráctica que involucre clasificar imágenes en un sistema embebido.

5.1.2. Viabilidad

La clasificación de imágenes depende sin duda del tipo de imágen, su tamaño, yde la cantidad de clases en las que haya que clasificarlas. Todo esto está relacio-nado con la cantidad de información existente en el conjunto de imágenes.

A partir del trabajo realizado se puede concluir que es posible prototipar disposi-tivos capaces de clasificar imágenes con placas de bajo costo que hay actualmenteen el mercado. Los tiempos de clasificación y la exactitud obtenidos son los quedeterminan si es viable o no según los requerimientos de una solución particular.En este trabajo se logró:

Un tiempo de clasificación entre 166 y 221 milisegundos usando un modelopropio empleado para clasificar imágenes en escala de grises de 300x300con dos categorías de clasificación y con una validación del 84 %.

Un tiempo de clasificación entre 549 y 732 milisegundos usando una réplicadel modelo AlexNet entrenado con más de un millón de imágenes[15] encolores de 256x256, con mil categorías de clasificación y con una validacióncercana al 85 %

38 Capítulo 5. Conclusiones

5.1.3. Tiempos y recursos

La cantidad de memoria requerida para los parámetros influye directamente enlos tiempos de clasificación logrados. Y la cantidad de parámetros depende deltamaño de las imágenes, de la cantidad de categorías de clasificación, y de lo bienlogrado que esté el modelo de la red neuronal.

En la tabla 5.1 se resumen los tiempos obtenidos en la Orange Pi para dos modelosdistintos junto con el tipo de imagen, la cantidad de categorías de clasificación yel espacio ocupado por los parámetros de la red neuronal en cada caso. El primercaso podría considerarse cercano al límite que se puede lograr por el momentopara un caso semejante. El segundo modelo en cambio sin duda se puede mejorarpara lograr menores tiempos de clasificación.

TABLA 5.1: Comparación de modelos

Modelo Imágenes Categorías Parámetros Orange Pi Raspberry

AlexNet 256x256 Color 1000 238 Mbytes 732 ms 549 msÁrboles 300x300 ByN 2 2 Mbytes 221 ms 166 ms

Queda claro a partir de este trabajo que para el caso objetivo, imágenes en esca-la de grises clasificables en dos categorías, el recurso limitante no es la memoriaRAM sino el tiempo. Se logró reducir de forma drástica la memoria usada ini-cialmente. El tiempo resulta la variable más importante a considerar en caso deaplicar a una solución. Si para un determinado problema la velocidad de clasifi-cación es importante el desarrollo debería estar focalizado en reducir esa variablelo máximo posible.

5.2. Próximos pasos

En esta sección se aportan algunas consideraciones a tener en cuenta para conti-nuar este trabajo o para aplicar al desarrollo de una solución.

5.2.1. Margen de mejora

Sería oportuno explorar el margen de mejora en terminos de desempeño. Haydos caminos para mejorar la desempeño, por un lado mejorando la estructura delas redes neuronales, lo cual vale en general, y por otra parte aprovechando almáximo el procesador.

Mejorar la estrucutra de una red neuronal es accesible en la medida que la so-lución propuesta implique trabajar con las librerías en desarrollo o con cambioscompatibles con el desarrollo de las mismas. Al mismo tiempo resulta algo nece-sario dado que actualmente se están produciendo avances y descubrimientos enel campo de las redes neuronales convolucionales para clasificar imágenes y usarlas librerías en desarrollo permite mantenerse al día con estos avances.

5.2. Próximos pasos 39

Por otra parte sería necesario evaluar la posibilidad de compilar las librerías y susdependencias para que aprovechen al máximo el procesador. La librería Open-Blas, la opción de Caffe que se seleccionó para realizar las operaciones matemáti-cas de álgebra lineal, se puede compilar para que aproveche las instrucciones detipo SIMD (Single Instruction Multiple Data, Una Instrucción Muchos Datos) perono todas las arquitecturas tienen esta mejora disponible. Tanto par el Cortex-A7como para el Cortex-A53 solo es posible compilar esta librería utilizando la abide ARMV7 y utilizando los algoritmos optimizados en lenguaje C. Sería oportunodesarrollar las optimizaciones utilizando las instrucciones SIMD para aprovecharmejor el procesador. Sobre todo en el caso del Cortex-A53 dado que cuenta conun conjunto de instrucciones SIMD extendido con respecto al Cortex-A7.

5.2.2. Alternativas

Las placas de video ofrecen la posibilidad de disponer de muchos nucleos paraprocesar cálculos matriciales que son ineherentes a la inferencia realizada por unared neuronal convolucional.

Una FPGA (Field Programmable Gate Array, Matriz de puertas programables) porsu parte ofrece la posibilidad de ser programada para realizar multiplicación dematrices lo que permitiría hacer esto a medida según la red neuronal que se di-señe para un problema en particular. Además es notable la ventaja de una FPGAen términos de consumo de energía mientras que las placas de video ofrecen unasolución de menor costo[1].

Sería por lo tanto muy oportuno continuar investigando de que manera se pue-den aprovechar las placas de video existentes si se busca una solución de bajocosto o los FPGAs teniendo en cuenta el consumo de energía.

5.2.3. Aplicación práctica

Los SoC (System on Chip, Sistema en Chips) utilizados para este trabajo facilitanel prototipado y prueba de soluciones pero deben considerase sus limitaciones,la documentación existente y la posibilidad de realizar modificaciones para quecumplan con los requisitos de uso necesarios en un ambiente industrial, junto conel cumplimiento de normas.

Por lo tanto para proponer el desarrollo de un producto deben considerarse alter-nativas más seguras en términos de compatibilidad e interferencia electromagné-tica, confiabilidad, y vida útil; y por otra parte más convenientes en términos dedisponibilidad de documentación y posibilidad de reingeniería.

A partir de los resultados de este trabajo y considerando la industria argentinase puede sugerir el modelo CIAA-ACC [6] como una opción a tener en cuentadado que cuenta con mayor capacidad computacional, suficiente memoria RAMy soporta una versión de linux que habilita a trabajar con la librería utilizada eneste trabajo. Este modelo además de contar con un procesaror ARM Cortex-A9cuenta con lógica programable e interfaces de interconexión que superan los 10Gb/s.

41

Bibliografía

[1] Berten. «GPU vs FPGA Performance Comparison». En: (2016). URL:http://www.bertendsp.com/pdf/whitepaper/BWP001_GPU_vs_FPGA_Performance_Comparison_v1.0.pdf.

[2] Caffe. Instalación en Ubuntu. URL:http://caffe.berkeleyvision.org/install_apt.html.

[3] Proyecto Caffe. Compilación de Caffe. URL:http://caffe.berkeleyvision.org/installation.html#compilation.

[4] Proyecto Caffe. Configuración del Modelo Alexnet. URL:https://github.com/BVLC/caffe/tree/master/models/bvlc_alexnet.

[5] Proyecto Cairo. Cairo. URL: https://www.cairographics.org.[6] Proyecto CIAA. CIAA-ACC. URL: http://www.proyecto-

ciaa.com.ar/devwiki/doku.php?id=desarrollo:ciaa_acc:ciaa_acc_inicio.[7] Proyecto CIAA. CIAA-NXP. URL:

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:hardware:ciaa_nxp:ciaa_nxp_inicio.

[8] Proyecto CIAA. EDU-CIAA-NXP. URL: http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:edu-ciaa:edu-ciaa-nxp.

[9] Proyecto CIAA. Linux en la CIAA. URL: http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:linux.

[10] Julio Gastón Coccé. «Repositorio». En: (sep. de 2017). URL:https://github.com/gcocce/caffe.

[11] Codeplea. Genmann: Simple Neural Network in ANSI C. URL:https://github.com/codeplea/genann.

[12] ARM Developer. Cortex-A53. URL:https://developer.arm.com/products/processors/cortex-a/cortex-a53.

[13] ARM Developer. Cortex-A7. URL:https://developer.arm.com/products/processors/cortex-a/cortex-a7.

[14] David Hubel y Torsten N. Wiesel. «Receptive fields and functionalarchitecture of monkey striate cortex.» En: The Journal of physiology 195.1195.1 (1968), 215–243. URL:http://hubel.med.harvard.edu/papers/HubelWiesel1968Jphysiol.pdf.

[15] IMAGENET. Large Scale Visual Recognition Challenge 2012. 2012. URL:http://www.image-net.org/challenges/LSVRC/2012.

[16] Yangqing Jia y col. «Caffe: Convolutional Architecture for Fast FeatureEmbedding». En: arXiv preprint arXiv:1408.5093 (2014).

[17] Andrej Karpathy. Convolutional Neural Networks for Visual Recognition.Stanford University. URL:http://cs231n.github.io/convolutional-networks/#architectures.

[18] Alex Krizhevsky, Ilya Sutskever y Geoffrey E Hinton. «ImageNetClassification with Deep Convolutional Neural Networks». En: Advancesin Neural Information Processing Systems 25. Ed. por F. Pereira y col. CurranAssociates, Inc., 2012, 1097–1105. URL: http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf.

http://www.bertendsp.com/pdf/whitepaper/BWP001_GPU_vs_FPGA_Performance_Comparison_v1.0.pdf

http://www.bertendsp.com/pdf/whitepaper/BWP001_GPU_vs_FPGA_Performance_Comparison_v1.0.pdf

http://caffe.berkeleyvision.org/install_apt.html

http://caffe.berkeleyvision.org/installation.html#compilation

https://github.com/BVLC/caffe/tree/master/models/bvlc_alexnet

https://www.cairographics.org

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:ciaa_acc:ciaa_acc_inicio

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:ciaa_acc:ciaa_acc_inicio

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:hardware:ciaa_nxp:ciaa_nxp_inicio

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:hardware:ciaa_nxp:ciaa_nxp_inicio

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:edu-ciaa:edu-ciaa-nxp

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:edu-ciaa:edu-ciaa-nxp

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:linux

http://www.proyecto-ciaa.com.ar/devwiki/doku.php?id=desarrollo:linux

https://github.com/gcocce/caffe

https://github.com/codeplea/genann

https://developer.arm.com/products/processors/cortex-a/cortex-a53

https://developer.arm.com/products/processors/cortex-a/cortex-a7

http://hubel.med.harvard.edu/papers/HubelWiesel1968Jphysiol.pdf

http://www.image-net.org/challenges/LSVRC/2012

http://cs231n.github.io/convolutional-networks/#architectures

http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf

http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf

42 BIBLIOGRAFÍA

[19] Yann et al. LeCun. «Gradient-based learning applied to documentrecognition.» En: Proceedings of the IEEE 86.11 (1998), 2278–2324. URL:http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf.

[20] Yann et al. LeCun. LeNet5. URL: http://yann.lecun.com/exdb/lenet/.[21] John McGonagle. Feedforward Neural Networks. URL: https:

//brilliant.org/wiki/feedforward-neural-networks/?subtopic=machine-learning&chapter=artificial-neural-networks.

[22] John McGonagle, George Shaikouski y Andrew Hsu. Backpropagation. URL:https://brilliant.org/wiki/backpropagation.

[23] Proyecto OpenBlas. Instalación de OpenBlas. URL:https://github.com/xianyi/OpenBLAS/wiki/Installation-Guide.

[24] Proyecto OpenCV. Instalacion de OpenCV. URL:https://docs.opencv.org/trunk/d7/d9f/tutorial_linux_install.html.

[25] R. Rojas. «Weighted Networks - The Perceptron». En: (1996). URL:http://www.inf.fu-berlin.de/inst/ag-ki/rojas_home/documents/1996/NeuralNetworks/K3.pdf.

[26] Francesco Visin Vincent Dumoulin. «A guide to convolutional arithmeticfor deep learning.» En: (2016). URL: https://arxiv.org/pdf/1603.07285.pdf.

http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf

http://yann.lecun.com/exdb/lenet/

https://brilliant.org/wiki/feedforward-neural-networks/?subtopic=machine-learning&chapter=artificial-neural-networks



https://brilliant.org/wiki/backpropagation

https://github.com/xianyi/OpenBLAS/wiki/Installation-Guide

https://docs.opencv.org/trunk/d7/d9f/tutorial_linux_install.html

http://www.inf.fu-berlin.de/inst/ag-ki/rojas_home/documents/1996/NeuralNetworks/K3.pdf

http://www.inf.fu-berlin.de/inst/ag-ki/rojas_home/documents/1996/NeuralNetworks/K3.pdf

https://arxiv.org/pdf/1603.07285.pdf

Clasificación de imágenes en sistemas embebidos usando...

Documents

Transcript of Clasificación de imágenes en sistemas embebidos usando...