Universidad de los Andes

Trabajo de grado

Aprendizaje rápido en Redes Neuronales

Convolucionales por medio de sFFT

Autor: Supervisor:
Felipe Suárez Colmenares Prof. Fernando Lozano

Trabajo de grado como requisito

para obtener el tı́tulo de Ingeniero Electrónico
Departamento de Ingenierı́a Eléctrica y Electrónica

13 de junio de 2016
 iii

Agradecimientos
Agradezco profundamente a mis padres y mi hermano por acompañarme y soportarme en todo
momento. Su compañı́a es invaluable y con ellos estaré eternamente agradecido. Agradezco a mi
asesor Fernando Lozano por su gran labor como profesor en varias ocasiones y como mentor de
este proyecto. A todos mis amigos en Ingenierı́a muchı́simas gracias por tenerme paciencia. A mis
amigos de Matemáticas les agradezco por mostrarme el valor de la amistad, por compartir conmigo
su amor por el conocimiento y por su constante ambición de superación.
 v

Índice general

Agradecimientos III

Introducción 1

1. Marco Teórico 3
1.1. Aprendizaje de Máquinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1. Enfoque de Estadı́stica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.2. Enfoque de Optimización . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2. Redes Neuronales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1. Redes Convolucionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3. Transformada de Fourier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.1. Transformada Discreta de Fourier . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.2. Transformada Dispersa de Fourier . . . . . . . . . . . . . . . . . . . . . . . 8

2. Metodologı́a 11
2.1. Algoritmo de Entrenamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1. Backpropagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.2. Convolución . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3. Evaluación Computacional 19
3.1. CUDA y Programación Paralela . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2. CUFFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3. Convolución . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.1. Discusión de resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.4. Entrenamiento de redes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.1. DTD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.2. KTH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.4.3. Kylberg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.4.4. Retinopatı́a Diabética . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.4.5. STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.4.6. Discusión de Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4. Conclusiones y trabajo futuro 33

A. Demostración de los teoremas 35

Bibliografı́a 39
 vii

Índice de figuras

1.1. Muestra X para dos clases Y = 0, 1. . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.2. Densidades marginales FX|Y =0 , FX|Y =1 . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3. Modelo de una neurona. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4. Convolución entre una Imagen a color y un banco de D filtros. . . . . . . . . . . . 7
1.5. Lena, X, y su transformada de Fourier, log10 (1 + |F(X)|). . . . . . . . . . . . . . . 8
1.6. Una imagen de lentejas, X, y su transformada de Fourier, log10 (1 + |F(X)|). . . . 8
1.7. Ilustración del funcionamiento de sfft. [6] . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1. Ilustración de dos submuestras, un en dimensión 1 y la otra en dimensión 2. . . . . 14

2.2. Ilustración de una kmódulo suma en dimensión 1. . . . . . . . . . . . . . . . . . . . 14
2.3. Ilustración de la propuesta para efectuar convolución. . . . . . . . . . . . . . . . . 16

3.1. Imágenes de ejemplo de 5 clases de la base DTD . . . . . . . . . . . . . . . . . . . 20

3.2. Imágenes de ejemplo de 5 clases de la base KTH . . . . . . . . . . . . . . . . . . . 20
3.3. Imágenes de ejemplo de 5 clases de la base Kyleberg . . . . . . . . . . . . . . . . 20
3.4. Cinco imágenes de ejemplo de la base Diabetic Retinopathy . . . . . . . . . . 20
3.5. Imágenes de ejemplo de 5 clases de la base stl . . . . . . . . . . . . . . . . . . . . 20
3.6. Breve ilustración de la arquitectura en una GPU y CPU. Gráfica de desempeño en
GFLOPs/s. [15] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.7. log10 (CP U [ms]) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.8. log10 (vl nnconv/fft conv) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.9. log10 (vl nnconv/sfft conv) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.10. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 26
3.11. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 27
3.12. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 27
3.13. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 28
3.14. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 28
3.15. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 29
3.16. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 29
3.17. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 30
3.18. Desempeño vl nnconv (izquierda) contra sfft conv (derecha). . . . . . . . . . . . 30
 ix

Índice de cuadros

3.1. Bancos de datos evaluados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.2. Tiempo en milisegundos que le tomó a Matlab (CUDA) realizar F(X). . . . . . . 22
3.3. Tiempo, en milisegundos, en realizar vl nnconv(X,F) en GPU. . . . . . . . . . . . 23
3.4. Tiempo, en milisegundos, en realizar fft conv(X,F) en GPU. . . . . . . . . . . . . 24
3.5. Tiempo, en milisegundos, en realizar sfft conv(X,F) en GPU. . . . . . . . . . . . 25
3.6. Red para el DTD en dimensión 64 × 64. . . . . . . . . . . . . . . . . . . . . . . . . 26
3.7. Red para el DTD en dimensión 128 × 128. . . . . . . . . . . . . . . . . . . . . . . . 27
3.8. Red para el DTD en dimensión 64 × 64. . . . . . . . . . . . . . . . . . . . . . . . . 27
3.9. Red para el KTH en dimensión 128 × 128. . . . . . . . . . . . . . . . . . . . . . . . 28
3.10. Red para el DTD en dimensión 64 × 64. . . . . . . . . . . . . . . . . . . . . . . . . 28
3.11. Red para el Kyleberg en dimensión 128 × 128. . . . . . . . . . . . . . . . . . . . 29
3.12. Red para el Diabetic Retinopathy en dimensión 64 × 64. . . . . . . . . . . . . . 29
3.13. Red para el Diabetic Retinopathy en dimensión 128 × 128. . . . . . . . . . . . 30
3.14. Red para el stl en dimensión 96 × 96. . . . . . . . . . . . . . . . . . . . . . . . . . 30
 1

Introducción

La historia del hombre nos ubica en una época atravesada por decenas de años de crecimiento
exponencial en capacidad de cómputo al mismo tiempo que por siglos de rigurosas construcciones
de conocimiento matemático. Esta coincidencial conjunción dio origen al estudio sobre el aprendi-
zaje de máquinas e inteligencia artificial desde hace casi cuarenta años. Desde entonces, el hombre
ha sido capaz combinar el soporte teórico pertinente con técnicas avanzadas de diseño para desa-
rrollar dispositivos con capacidades sobrehumanas que constituyen un amplio espectro habilidades
como inferencia y reconocimiento de patrones.

Entre los algoritmos de aprendizaje de máquinas más exitosos se encuentra el algoritmo de redes
neuronales [1]. El éxito de este algoritmo radica en su gran versatilidad sobre el tipo de informa-
ción que utiliza, su simple formulación, su sencillo algoritmo de aprendizaje y su gran desempeño.
Conforme crece la capacidad de almacenamiento de información, procesamiento de datos y abs-
tracción teórica; también crecen los deseos por crear máquinas más inteligentemente ambiciosas.
Es por esto que uno de los retos más grandes consiste de acelerar dichas etapas de aprendizaje.
Por lo tanto, el objetivo de este trabajo es desarrollar un algoritmo más rápido para llevar a cabo
el entrenamiento de Redes Neuronales Convolucionales.

En el capı́tulo 1 explicaremos los conceptos básicos necesarios para entender al algoritmo pro-
puesto. Estos incluyen definiciones básicas de aprendizaje estadı́stico y su versión como problema
de optimización. También introduciré los conceptos de convolución, redes neuronales y transforma-
da de Fourier explicando, en cada caso, las versiones que son más apropiadas para el entendimiento
del algoritmo y mostrando algunos ejemplos pertinentes.

El capı́tulo 2 hablaremos sobre la metodologı́a llevada a cabo para implementar el algoritmo

tomando como base las herramientas del capı́tulo 1. Mostraremos cómo funciona el aprendizaje
de máquinas para la clasificación por redes neuronales. Finalmente probaremos cómo la propuesta
ayudarı́a a disminuir el tiempo de entrenamiento, para el cual entrenaremos varias bases de datos
conocidas en la literatura en el capı́tulo 3.

Las conclusiones de este trabajo se consignan en el capı́tulo 4 junto a algunas propuestas de

mejoramiento.
 3

Capı́tulo 1

Marco Teórico

1.1. Aprendizaje de Máquinas

Suponga que tiene un conjunto de información muy grande de la cual desea obtener informa-
ción. Por ejemplo, el banco de datos de todos los exámenes en un hospital; la calificación asignada
por cada usuario en un foro de pelı́culas; la imágenes médicas de resonancia magnética de muchos
pacientes en el mundo 1 ; la variación de la contaminación del agua en distintos puntos de un rı́o 2
; o la distribución de altura y peso de distintas poblaciones en un paı́s. Es natural preguntarse por
la procedencia de los datos. ¿Están los datos relacionados de alguna forma? ¿Existen tendencias
o agrupaciones en los datos? ¿Si tengo un dato adicional incompleto podrı́a aproximarme a la
información restante con algún grado de certeza?

En casos pequeños una opción válida podrı́a ser graficar los datos en un plano y tratar de
responder estas preguntas empı́ricamente. Normalmente, sin embargo, todas las aplicaciones son
solo tratables por medio de implementaciones computacionales. Ası́, en el aprendizaje de máquinas
el objetivo es diseñar un algoritmo que aprenda por sı́ solo a partir de datos preexistentes algún
tipo de fenómeno, algún patrón. Los problemas clásicos se pueden categorizar en Clasificar, Inferir,
Ordenar y validar dependencia.

1.1.1. Enfoque de Estadı́stica

El enfoque usual en estadı́stica para el problema de clasificación consiste en suponer que existe
una noción de dependencia probabilı́stica entre el espacio de los objetos que queremos clasificar, y
el conjunto de clases posible. Supongamos que tenemos un conjunto de datos {X1 , X2 , . . . , Xn } que
pertenecen al espacio X, cada uno de los cuales tiene una etiqueta {Y1 , Y2 , . . . , Yn } en un conjunto
de clases Y . Supongamos que los datos provienen de una distribución desconocida FX y las clases de
otra distribución FY . El problema de clasificación consiste de encontrar una función c : X → Y , es
decir, una clasificación de los en X en las clases en Y . La idea es encontrar una clasificación c buena.

En el fondo, nos estamos preguntando por la distribución conjunta (X, Y ). Entonces, sur-
gen varias preguntas pertinentes como: ¿Cómo encontrar una función c a partir de los datos
{(X1 , Y1 ), . . . , (Xn , Yn )} con el menor error de clasificación E = P(c(X) 6= Y )? ¿Qué tan rápi-
do puedo encontrar esta función c si tengo n datos? ¿Para una clasificación c fija, cómo se puede
calcular o estimar dicho error E?

El teorema Bayes nos garantiza que lo mejor que se podrı́a clasificar a X en Y está dictado
por las distribuciones condicionales de Y . Suponiendo que las variables admiten una función de
densidad f(X,Y ) , el clasificador de Bayes se define:

c : X → Y, c(x) = arg max f(Y |X=x) (y). (1.1)

y∈Y

Teorema 1.1.1. (Teorema de clasificación de Bayes) Sean {(Xi , Yi )}i≤n ⊆ X × Y realizaciones

de una variable aleatoria con distribución FX,Y . Si (X, Y ) admite una densidad fX,Y , entonces la
1 https://www.kaggle.com/c/mlsp-2014-mri/data
2 http://www.sersc.org/journals/IJSEIA/vol9_no6_2015/5.pdf
4 Capı́tulo 1. Marco Teórico

función de clasificación c : X → Y con el menor error de clasificación E = P(C(X) 6= Y ) es el

clasificador dado por,
c(x) = arg max f(Y |X=x) (y).
y∈Y

El teorema de Bayes dio lugar a que los estadı́sticos se enfocaran en formas de estimar dicho
clasificador. El concepto general del teorema es intuitivo, si pensamos a fY |X=x (y) como la proba-
bilidad relativa de que la clasificación sea y dado que x es la realización, entonces la clasificación es
el valor de la clase que maximiza esta probabilidad. No obstante, el teorema también nos dice que
hay un lı́mite para el error de clasificación; y este está dado por el error del clasificador de Bayes.
Considere el siguiente ejemplo,
Ejemplo 1.1.1. Suponga que hay dos clases, Y = {0, 1}, y la variable aleatoria X es tal que
X|Y =0 ∼ N (1, 1), y X|Y =1 ∼ N (−1, 1). Suponiendo que la cantidad de elementos en cada clase
es la misma (fy (y) = 0,5δ0 + 0,5δ1 ), entonces, fY |X=x (y) = fX|Y =y (x) ffX
Y (y) 1
(x) = fX|Y =y (x) 2fX (x) .
Por lo tanto, ( (
1, si fX|Y =1 (x) > fX|Y =0 (x), 1, si x < 0,
c(x) = =
0, si fX|Y =1 (x) < fX|Y =0 (x). 0, si x > 0.
1.0

Y=0
Y=1
0.0

x x xx x xx xox xxxx xxxxxx xxxoxxoxxxxxxooxoxxooo

x oxxooooooooooxoo
ox ooooooooooo oo
−1.0

−3 −2 −1 0 1 2 3

X
Figura 1.1: Muestra X para dos clases Y = 0, 1.

F_0
F_1
0.10
0.00

−3 −2 −1 0 1 2 3

t
Figura 1.2: Densidades marginales FX|Y =0 , FX|Y =1 .

1.1.2. Enfoque de Optimización

En el mismo contexto anterior, suponga que tenemos un conjunto de datos {(Xi , Yi )}. El pro-
blema de encontrar una función c : X → Y buena, requiere de formalizar el concepto de ser o no
buena. Para abordar esta disyuntiva, se plantean los errores empı́ricos y error cuadrático como la
frecuencia de error en la muestra y el promedio del cuadrado de la diferencia entre la clasificación
y el valor real respectivamente:
n
1X
Ê(c) = 1(c(Xi ) 6= Yi ), (1.2)
n i=1
1.2. Redes Neuronales 5

n
1X
M SE(c) = (c(Xi ) − Yi )2 . (1.3)
n i=1
Ahora bien, es útil restringir el clasificador c a una familia de posibles clasificadores F. De este
modo, el problema de encontrar un buen clasificador se puede reescribir formalmente de la manera
siguiente:
Dados {(Xi , Yi )}i=1,...,n , c = arg min E(f ). (1.4)
f ∈F

Para que estos problemas sean matemáticamente tratables, es necesario imponer condiciones
sobre los datos, la familia de clasificadores y la formulación de los errores. Naturalmente, estamos
interesados en encontrar una solución óptima en un tiempo razonable. Normalmente se utiliza el
MSE para resolver este problema por sus propiedades de diferenciabilidad. Sin embargo, a veces es
mejor utilizar otras funciones, también diferenciables, como n1 i ||c(Xi ) − Yi ||p . Por estas razones,
P
a la familia de funciones F se le exige que se sea diferenciable con respecto a algún parámetro
de modo que el problema original, c = arg minf ∈F E(f ), se pueda representar como un problema
de optimización que se haya estudiado y su solución —o sus métodos para encontrar soluciones
aproximadas— sea conocida. Por ejemplo, es deseable poder obtener una representación Lineal,
Cuadrática, Semidefinida o Convexa en general. Cada uno de los cuatro tipos de problemas men-
cionados anteriormente ha sido ampliamente estudiados y son áreas activas de investigación en
optimización. Algunos de los métodos más famosos para resolverlos son Simplex, SMO, Goemans-
Williamson, Lagrange-KKT, entre otros. [2]

Dichos enfoques —de estadı́stica y de optimización— enriquecieron la formulación del proble-

ma de clasificación hasta el punto en que se logró formalizar, y en cierto sentido unificar, la teorı́a
de aprendizaje y aprendibildiad. Veamos brevemente uno de los hechos que constituyeron la base
de esta teorı́a. Asumiendo las mismas hipótesis mencionadas anteriormente, el teorema de apren-
dibilidad de Vapnik-Chervonenkis demuestra que es posible, para una familia de clasificadores F
no muy general, estimar correctamente el error P(c(X) 6= Y ) por medio del error empı́rico Ê.
Un hecho asombroso como este, a pesar de que merece una lectura más cuidadosa y detenida, no
se demostrará formalmente en este proyecto, pues se sale de los objetivos planteados. El lector
interesado debe remitirse a [3].

1.2. Redes Neuronales

Las redes neuronales son un tipo de clasificador inspirado en la idea de que una acción está
determinada por distintos tipos de excitación de sus entradas. Considere el bloque Σ, cuya sali-
da depende de una transformación lineal a fin de sus entradas X1 , . . . , Xn . Para representar la
excitación se aplica sucesivamente una función f no lineal a Σ,

Σ = w0 + w1 X1 + · · · + wn Xn , Y = f (Σ)3 .

Figura 1.3: Modelo de una neurona.

En suma, tenemos que Y = f (w0 + w1 X1 + · · · + wn Xn ) donde w1 , . . . , wn . Ası́, el problema

se reduce a encontrar los valores wi que mejor aproximen a Y conociendo Xi . Cuando f (t) = t el
3 Imagen obtenida del material del curso de Machine Learning del Prof. Fernando Lozano.
6 Capı́tulo 1. Marco Teórico

problema original se vuelve equivalente un problema de regresión lineal, pero cuando Y toma va-
lores en un conjunto discreto, las aproximaciones usuales para resolver el problema de regresión no
sirven. Cuando, por ejemplo, f (t) = 1(t ≥ 0), entonces, considerados (1, X1 , . . . , Xn ) como puntos
en Rn , la clasificación c representará la pertenencia del vector (1, X1 , . . . , Xn ) al lado positivo del
semiplano con normal (w0 , w1 , . . . , wn ).

Intuitivamente, aumentar la cantidad de neuronas hasta formar una red puede mejorar la
capacidad del algoritmo para clasificar acertadamente. De ahı́, una red neuronal —también llamada
perceptrón multicapa en el contexto particular clasificación binaria— consiste de utilizar varias
neuronas para generar múltiples activaciones Σ1 , . . . , Σm , de las cuales se extraen también múltiples
excitaciones f1 , . . . , fm . Aunque fi puede ser una función arbitraria, para el problema especı́fico de
clasificación es recomendable utilizar funciones que tomen valores en [0, 1]. Utilizar varias capas de
neuronas para formar una red neuronal nos conlleva a mejorar la resolución al discernir los datos
en sus clases correspondientes. De hecho, cualquier función es aproximable por medio de funciones
de activación. Este es un hecho importante que vale la pena tener en cuenta y se le llama por
Teorema de Aproximación Universal.
Teorema 1.2.1. (Teorema de Aproximación Universal [4]) Sea φ : R → R una función monótona
creciente y continua. Sea I ⊆ Rm un conjunto compacto. Entonces, para toda toda función continua
sobre I, f ∈ C(I), y  > 0 existen N ∈ N, α1 , . . . , αN , b1 , . . . , bN ∈ R, w1 , . . . , wN ∈ Rm tales que,
X
fˆ(x) := αi φ(wiT x + bi ), sup |fˆ(x) − f (x)| = ||fˆ − f ||∞ < .
i x∈I

Si juntamos el teorema de aproximación universal y el teorema de Bayes podemos pensar que, en

el caso ideal, resolver el problema de clasificación para una red neuronal suficientemente grande nos
llevará a una solución que se aproxima, en el lı́mite, al clasificador de Bayes. A pesar de las buenas
intenciones al aumentar el tamaño de la red, surgen consecuentemente muchas más preguntas
tales como ¿Cuántas capas son suficientes? ¿Qué funciones de activación son mejores? ¿Cómo
implementar una red grande computacionalmente? ¿Cómo entrenar la red? Estas preguntas aún
no tienen soluciones exactas y en la práctica se recurre a pruebas heurı́sticas sobre estos parámetros.
Las funciones de activación más comunes son la sigmoidal φ(t) = 1+e1 −t ; la arcontangente φ(t) =
2
π arctan(t); la función de escalón de Heaviside φ(t) = 1(t ≥ 0); y la rectificadora lineal φ(t) =
máx(0, t).

1.2.1. Redes Convolucionales

Las redes convolucionales son un tipo de red neuronal artificial en la que existen capas de
activación en las que se utiliza convoluciones en lugar de producto punto. Es decir, se reemplaza
φ(wT x + b) por φ(w ∗ x + b). Esta idea sugiere varias ventajas: primero, la cantidad de parámetros
de entrenamiento aumenta, lo que podrı́a traducirse a una mejor resolución en la captura de atri-
butos relevantes para la clasificación. También resulta ser conveniente utilizar convolución porque,
gracias al teorema de convolución, podemos representar cualquier tipo de filtro de respuesta finita
al impulso (FIR) por medio de una convolución. Por lo tanto, podrı́a pensarse que las capas con-
volucionales actúan como filtros que, a medida que se entrena la red, se van adaptando al tipo de
problema especı́fico en el que se quiere clasificar.

Recordemos que la convolución entre dos señales X ∈ Rn y Y ∈ Rm nos forma otra señal en
m+n
R dada por X X
(X ∗ Y )i = Xk Yi−k = Xr Ys . (1.5)
k r+s=i

Para matrices tenemos la siguiente definición para la convolución entre una imagen X y un filtro
F . Considere una imagen X ∈ RM ×N y un filtro F ∈ Rm×n , entonces Y := X ∗ F es la matriz en
en R(M +m)×(N +n) en donde,
X X X
Yij = Xk,l Fi−k,j−l = Xk,r Fl,s . (1.6)
k,l k+l=i r+s=j
1.3. Transformada de Fourier 7

Ejemplo 1.2.1. Se calcula el resultado de la convolución entre una imagen de 512×512 y un filtro
de 3×3.

 
−1 −2 1
∗ 3 2 −1 =
1 1 −2

Una capa de la red convolucional está conformada, entonces, por varias secciones de covolución.
Para generalizar esta idea a imágenes representadas por tres canales —RGB— se consideran tam-
bién tres canales de filtros y el resultado final se suma. Esto es, si XRGB ∈ RM ×N ×3 , F ∈ Rm×n×3

XRGB ∗ FRGB := XR ∗ FR + XG ∗ FG + XB ∗ FB . (1.7)

Ahora bien, el resultado de aplicar la convolución a un conjunto de filtros F1 , . . . , FD ∈ Rm×n×3

será F = (F1 , . . . , FD ) ∈ Rm×n×3×D .

XRGB ∗ F := (XRGB ∗ F1 , . . . , XRGB ∗ FD ).

Figura 1.4: Convolución entre una Imagen a color y un banco de D filtros.

1.3. Transformada de Fourier

La transformada de Fourier es una transformación entre espacios de Hilbert que, aplicado a la
caso de L2 (C)[0, 2π] o l2 (C), se traduce en captura de información frecuencial de la función a la
que se le aplica. La definición es,

f ∈ (H, h·, ·i) con base ortonormal (ex )x∈I , F(f )(x) := hf, ex i. (1.8)

Ejemplo 1.3.1. Se consideran los casos particulares L2 (C)[0, 2π], l2 (C), que son conocidos como
CTFT y DTFT respectivamente.
Z 2π
f ∈ L2 (C)[0, 2π], F(f )(x) := f (t)e−2πixt dt. (1.9)
0

∞
X
f ∈ l2 (C), F(f )[n] := f [k]e−2πink . (1.10)
k=−∞
8 Capı́tulo 1. Marco Teórico

1.3.1. Transformada Discreta de Fourier

La transformada discreta de Fourier es una implementación numérica de la transformada de
una señal que se asume es una submuestra de una señal periódica. La definición de esta es, dado
un vector X ∈ Rn ,
n−1
X √
X̂(i) = X(j)ωnij , donde ωn := e2 −1π/n . (1.11)
j=0

El algoritmo de Cooley-Tukey permite calcular esta transformación en tiempo O(n log n). La
versión d dimensional de esta transformada es natural:
d i i0 +···+id i0d
X
X ∈ Rn×···×n = Rn , X 7→ X̂, X̂(i1 ,...,id ) = X(i01 ,...,i0d ) ωn1 1 . (1.12)
(i01 ,...,i0d )∈[n]d

En particular para una imagen, la transformada se reescribe como una transformada primero
por filas(o columnas) y luego por columnas(o filas).
M X
N
X 0 0
ii jj
X ∈ RM ×N , F(X)(i, j) = X(i0 , j 0 )ωM ωN . (1.13)
i0 =1 j 0 =1

Ejemplo 1.3.2. Se consideran las transformadas de Fourier para dos imágenes4

F
−→

Figura 1.5: Lena, X, y su transformada de Fourier, log10 (1 + |F(X)|).

F
−→

Figura 1.6: Una imagen de lentejas, X, y su transformada de Fourier, log10 (1 +

|F(X)|).

1.3.2. Transformada Dispersa de Fourier

Los autores en [6] crearon un algoritmo muy eficiente para calcular esta transformación pa-
ra señales que son dispersas en frecuencia. Una señal x ∈ Rn es k-dispersa en frecuencia cuando
|{supp(x̂)}| ≤ k, es decir, cuando x tiene a lo más k componentes frecuenciales no nulas. Si tuviéra-
mos que calcular la transformada de Fourier discreta sobre un conjunto de señales {x1 , . . . , xn }
que sabemos a prior es disperso, esperarı́amos que exista una implementación más eficiente para
calcularla. El algoritmo diseñado en el laboratorio de inteligencia artificial del MIT aprovecha al
4 La segunda imagen es tomada [5].
1.3. Transformada de Fourier 9

máximo la propiedad de dispersión para utilizar métodos estocásticos de estimación. Dicho algorit-
mo es capaz de encontrar con alta probabilidad la transformada en señales exactamente k dispersas
en tiempo O(k log n). Para señales aproximadamente k-dispersas el tiempo que le toma algoritmo
es O(k log n log(n/k)). La idea del algoritmo es simple: estimar las posiciones de los coeficientes
grandes InnerLoop locate; estimar el espectro en estas posiciones InnerLoop estimate; repetir
la localización hasta tener una estimación casi exacta, y recuperar el valor del espectro en estas
posiciones.

Algorithm 1 Sparse one-dimensional Fast Fourier Transform

1: procedure InnerLoop
2: procedure InnerLoop locate(X, σ, G, d)
3: Yi ← Xσi+τ .
4: Yi ← G
Pi Xσi+τ .
5: Zi ← j≡B i Yj .
P ij
6: Ẑi ← j∈[B] Zj ωB .
7: Hashed Index ← Seleccionar los d ı́ndices más altos en {|Ẑi |}.
8: Index ← σ −1 (Hashed Index).
9: return Index
10: end procedure
11: procedure InnerLoop estimate(Index, G)
12: EstimateIndex = ẐHashed Index /GHashed Index .
13: V alueIndex = EstimateIndex .
14: V alue[n]−Index = 0.
15: return V alue.
16: end procedure
17: end procedure

Algorithm 2 Sparse one-dimensional Fast Fourier Transform

1: procedure OuterLoop(X, G, d)
2: for i ∈ {1, . . . , O(log n)} do
3: σ ← k, such that (n, k) = 1.
4: Indexi ← InnerLoop locate(X, σ, G, d)
5: end for
6: I ← {j ∈ ∪i Indexi : |{i : j ∈ Indexi }| ≥ n2 }.
7: V alue ← InnerLoop estimate(I, G).
8: Return Values.
9: end procedure

Una imagen de ejemplo del funcionamiento se muestra a continuación.

Figura 1.7: Ilustración del funcionamiento de sfft. [6]

 11

Capı́tulo 2

Metodologı́a

Para abordar el problema de clasificación de imágenes, proponemos utilizar redes neuronales

convolucionales. El clasificador c consistirá de una sucesión de capas c = (c1 , c2 , . . . , cn ) que se
aplican serialmente de modo la clasificación de una imagen A ∈ Rm×n×3 se efectuará al aplicar la
primera capa, c1 , e iterativamente aplicar el resultado de la capa actual a la siguiente,
c
1 2 c n c
A−→ c1 (A)−→ . . . −→ c(A).

Los parámetros que se aprenden durante el proceso de aprendizaje son entonces los paráme-
tros wi de cada capa ci . Consiguientemente nuestro clasificador, c, está parametrizado por w :=
(w1 , . . . , xn ). Para ello, se propone el siguiente esquema de solución:

1. Obtener un conjunto de imágenes previamente clasificadas: {(Xi , Yi )}i≤n .

2. Particionar este conjunto en dos subconjuntos: train, val, donde |val|
n = k %.
3. Para el conjunto train, resolver —o aproximar— la solución del problema de optimzación,

w∗ = arg min M SE(c(w)).

w∈W

4. Estimar el error de clasifcación en el conjunto val,

|val|
X
Ê(w∗ ) = 1
|val| 1(c(Xi ) 6= Yi ).
i=1

El paso clave de este esquema es la aproximación a la solución del problema de optimiza-

ción. Dado que las exitaciones son no lineales, utilizaremos un técnica conocida como descenso
de gradiente con tasa de aprendizaje η; regularización tipo weight decay λ; y momentum α. Las
descripciones de estos conceptos se muestran en la siguiente sección.

2.1. Algoritmo de Entrenamiento

2.1.1. Backpropagation
El aprendizaje es perfecto cuando P(c(X) 6= Y ) = 0. Ya vimos que no siempre es posible alcan-
zar aprendizaje perfecto y además la mejor clasificación está siempre dominada por la clasificación
intrı́nseca de Bayes. De esta forma, el proceso de entrenamiento consiste de encontrar el c que
minimice Ec = P(c(X) 6= Y ). Como es usual, estos problema no son siempre convexos, y por ende
no existe un método general de resolverlo. Ası́, toca recurrir a métodos iterativos aproximados,
acá consideramos el caso de descenso de gradiente con tasa de aprendizaje η, regularización λ, y
momentum α.
1 X λ
Dados{(Xi , Yi )}i∈train , w∗ = arg min ||cw (Xi ) − Yi ||22 + ||w||22 . (2.1)
w 2 i∈train 2
12 Capı́tulo 2. Metodologı́a

Algorithm 3 Gradient Descent

1: procedure Gradient Descent({(Xi , Yi )}i∈train , Ep, η, λ, α, w0 )
2: w ← w0 .
3: for i ∈ {1, . . . , Ep} do
4: w ← w − η(∇w M SE(cw ) + λw) + α∆(w).
5: end for
6: Return w.
7: end procedure

Dependiendo de las condiciones de la red, calcular ∇w M SE(cw ) puede ser muy complicado si se
utiliza
P la fórmula entera de todas las capas para el error. Sin embargo, es claro que ∇w M SE(cw ) =
i (c w (X i )−Yi )(∇w (cw )). Ası́ que el problema se transforma en calcular ∂cw /∂wi . Ahora, el hecho
de que la red esté divida en capas una tras otra, c = cn ◦ cn−1 ◦ · · · ◦ c1 , nos permite calcular esta
derivada de manera iterativa utilizando la regla de la cadena. A este proceso se le conoce como
BackPropagation. El concepto general de BackPropagation se basa en:

∂cw ∂(cn (cn1 ◦ · · · ◦ c1 )) ∂cn ∂(cn1 ◦ · · · ◦ c1 )

= = ((cn1 ◦ · · · ◦ c1 )) . (2.2)
∂wi ∂wi ∂wi ∂wi
En este orden de ideas, para entrenar la red es necesario saber cómo calcular las derivadas
en cada una de las capas ∂cj /∂wi . En la práctica existen muchas propuestas para las capas. En
este trabajo nos limitaremos a utilizar solamente las capas de convolución, y las capas no lineales
correspondientes a ReLu,Max y SoftMax. La capa SoftMax es una versión diferenciable del máximo
y se define como:
 
X k2
k1 X
X ∈ Rk1 ×k2 , SoftMax(X) = log  eX(i,j)  . (2.3)
i=1 j=1

Ahora bien, cada uno de los términos ∂M SE(cw )/∂wi en el algoritmo de descenso de gradiente
incluye toda la muestra de entrenamiento train. Esto no solo puede hacer el proceso más lento y
más pesado computacionalmente, sino que puede resultar en soluciones que no son óptimas [7]. Por
esta razón se ha pensado en que es mejor realizar cada paso durante Backpropagation utilizando
submuestras de train denominadas batches. Al algoritmo basado en entrenamiento por batches
se le conoce como Stochastic Gradient Descent.

Algorithm 4 Stochastic Gradient Descent

1: procedure SGD({(Xi , Yi )}i∈train , Ep, η, λ, α, w0 , B)
2: train = T1 ∪ · · · ∪ Tk , tales que |Ti | ≤ B.
3: w ← w0 .
4: for i ∈ {1, . . . , k} do
5: w ← Gradient Descent({(Xj , Yj )}j∈Ti , Ep, η, λ, α, w).
6: end for
7: Return w.
8: end procedure

2.1.2. Convolución
Las redes convolucionales revolucionaron las máquinas de clasificación en cuanto los compu-
tadores fueron mejorados, pues, aunque la teorı́a de BackPropagation para redes convolucionales
fue creada desde hace más de treinta años, no fue posible implementarla eficientemente sino hasta
hace menos de diez. Desde entonces, se han creado áreas en las que se busca cómo aplicar estas
redes en otras ramas de las ciencias y al mismo tiempo se han concentrado muchos esfuerzos por
tratar de mejorar su desempeño y disminuir el costo computacional y temporal. Veamos breve-
mente por qué es pesado computacionalmente.
2.1. Algoritmo de Entrenamiento 13

Si tenemos un batch de tamaño BX de imágenes XRGB de tres canales de tamaño RM ×N ,

en total tendremos un arreglo de tamaño X ∈ RM ×N ×3×BX . De la misma manera, tenemos un
conjunto de D filtros de tres canales de tamaño Rm×n , ası́ que F ∈ Rm×n×3×D . Entonces, por cada
una de las BX imágenes en el batch hay que realizar la operación de convolución para obtener un
arreglo en R(M −m+1)×(N −n+1)×D . En cada convolución estamos realizando un producto-suma que
requiere de O(m × n) operaciones, que se deben repetir a lo largo de toda la imagen (M − m +
1) × (N − n + 1) veces. Ası́ que al final, una sola convolución con un solo filtro tiene complejidad
en tiempo de,
O ((m × n)((M − m + 1) × (N − n + 1))) .
Por lo tanto la complejidad de la operación completa X ∗ F es,

O((m × n)((M − m + 1) × (N − n + 1))(3)(D)(BX )).1

Para facilitar los cálculos asumiremos de aquı́ en adelante que la imagánes y los filtros serán
cuadrados, M = N , m = n. Ası́, la expresión para la complejidad de la convolución por batch es,

O(m2 (M − m + 1)2 (3)(D)(BX )). (2.4)

La convolución es, por lo tanto, la operación que domina el tiempo de ejecución del algoritmo
de aprendizaje. La propuesta de este trabajo es optimizar dicho proceso combinando las ideas de
transformada dispersa de Fourier, convolución y procesamiento paralelo en tarjetas gráficas. Va-
rios autores [8, 9] ya han explorado la viabilidad de utilizar transformadas de Fourier para facilitar
labor extensiva y repetida de la convolución.

La propuesta, siguiendo las ideas de los autores en [9], es transformar las imágenes X → F(X),
F → F(F), para que las convoluciones se puedan hacer más rápidamente apelando al teorema que
relaciona la transformada de Fourier y las convoluciones.
Teorema 2.1.1. (Teorema uni-dimensional Convolución Fourier) Sean X ∈ RN , F ∈ Rn . Defina
N −n+1
P
X ∗ F =: Y ∈ R , como Yi = j Xi+j Fn−j . Si FN denota la FFT N -dimensional, entonces,

∀i = n + 1, . . . , N : FN (X)i FN (F )i = FN (X ∗ F )i−n .

Ası́ que para efectuar la convolución entre X y F, solo tenemos que hacer 3(D)(BX ) productos
directo de F(X) y F(F) que requieren M 2 operaciones. Transformar cada imagen (filtro) toma
O(2M 2 log M ), ası́ que en total la complejidad de transformar, hacer producto directo y posterior-
mente hacer la transformación inversa es,

O(2M 2 log(M )(3DBX ) + M 2 (3DBX ) + 2M 2 log(M )(DBX )). (2.5)

Entonces, se puede notar que la complejidad está dominada por el tiempo que toma la primera
transformación de X y F. Ası́ que nos enfocaremos en optimizar este proceso en particular. Para
tal fin vamos a construir una transformada más rápida, sfft, basada en la idea de la transformada
dispersa de [6] y el hecho que las imágenes grandes son dispersas en frecuencia. Vea, por ejemplo,
las figuras 1.4 y 1.5. Para construir el algoritmo tendremos en cuenta las siguientes definiciones.
Definición 2.1.1. Para n := (n1 , . . . , nd ) ∈ Nd definimos, n-transformada discreta de Fourier
como:
Fn : Cn1 ×···×nd → Cn1 ×···×nd ,
X
X 7→ X̂, X̂(i1 , . . . , id ) = X(j1 , . . . , jd )ωni11j1 . . . ωniddjd .
(j1 ,...,jd )∈[n1 ]×···×[nd ]
√
2π −1
Donde ωa = e a .
Definición 2.1.2. ara K := (k1 , . . . , kd ) ∈ Nd definimos, k-submuestra como:

SK : Cn1 ×···×nd → Ck1 ×···×kd ,

1 En esta notación de complejidad conservo la constante 3 para hacer las comparaciones con otras implementa-

ciones más detalladamente.

14 Capı́tulo 2. Metodologı́a

X 7→ Y, Y(i1 , . . . , id ) = X(i1 b nk11 c, . . . , , id b nkdd c).

Ejemplo 2.1.1. Se muestran ejemplos de Sk y S(n/2,n/2) .

Figura 2.1: Ilustración de dos submuestras, un en dimensión 1 y la otra en

dimensión 2.

Definición 2.1.3. Para K := (k1 , . . . , kd ) ∈ Nd definimos, k-móduloSuma como:

ΣK : Cn1 ×···×nd → Ck1 ×···×kd ,

X
X 7→ Y, Y(i1 , . . . , id ) = X(j1 , . . . , jd ).
jl ≡kl il

Ejemplo 2.1.2. Se muestra un ejemplo de Σk .

Figura 2.2: Ilustración de una kmódulo suma en dimensión 1.

Definición 2.1.4. Para σ := (σ1 , . . . , σd ) ∈ Nd definimos, σ-permutación como:

Pσ : Cn1 ×···×nd → Cn1 ×···×nd ,

X 7→ Y, Y(j1 , . . . , jd ) = X(σ1 j1 , . . . , σd jd ).
Con estas definiciones ya podemos construir el algoritmo. Antes de esto, consideremos los
siguientes dos teoremas que relacionan la transformada de Fourier n dimensional Fn con la trans-
formada k dimensional Fk ; la k submuestra Sk ; la k módulo suma Σk ; y la σ permutación Pσ .
Teorema 2.1.2. Sean k, n, con ki |ni . Sean Fn , Sk , Σk , Fk como en las definiciones 2.1.1-2.1.4.
Entonces, el siguiente diagrama es conmutativo:
Fn
Cn Cn Q
Sk αΣk , donde α = Qk.
n
Fk
Ck Ck
La conclusión de este teorema es que si, en lugar de calcular transformada de Fourier completa,
calculamos la transformada de una submuestra, entonces es lo mismo que hacer una módulo suma
de la transformada completa. O sea que, si quisiéramos reconstruir la transformada de Fourier de
una señal grande, podemos solo calcular la transformada de una submuestra y luego mapear los
coeficientes a las posiciones reales —escalando apropiadamente por α−1 — sabiendo que provienen
de una suma módulo.
2.1. Algoritmo de Entrenamiento 15

Teorema 2.1.3. Sean k, n, con ki |ni . Sean Fn , Sk , Σk , Fk , Pσ como en las definiciones 2.1.1-2.1.4,
siendo (σ, n) = 1. Sea G ∈ Cn . Entonces, el siguiente diagrama conmuta:
Fn
Cn Cn
Pσ Pσ−1
Fn
Cn Cn
Q
nG· Ĝ∗
n Fn n
C C
ΣK SK
Fk
Ck Ck
Este teorema es esencialmente el corazón del algoritmo de la transformada dispersa del MIT.
El primer diagrama captura el hecho que permutar en espacio y luego transformar es equivalente
a transformar y luego efectuar la permutación inversa. Este paso es el que se repite O(log n) veces.
En el siguiente diagrama se resume el hecho que filtrar en espacio —multiplicar punto a punto—
y luego transformar es equivalente a transformar y luego hacer convolución con la transformada
del filtro. En este paso del algoritmo la señal, que está permutada en frecuencia, se le aplica la
convolución con un filtro cuya función es visibilizar las frecuencias altas. Para esto se escoge un filtro
lo más parecido a una ventana exacta para que cuando se efectúe la convolución cada frecuencia se
repita uniformemente sobre un intervalo de dimensión k —también llamado bucket por los autores
originales. Finalmente, en el último diagrama se captura el hecho inverso al teorema 2.1.2, a saber,
sumar módulo y luego transformar es equivalente a transformar y luego submuestrear. En este
paso, ya que hemos “agrandado” cada coeficiente grande en el paso previo al filtrar, vamos ahora
a submuestrear de tal forma que, con alta probabilidad recuperemos los coeficientes agrandados.
En resumen podemos resumir que el algoritmo disperso, descrito en el teorema 2.1.3 realiza lo
siguiente:

1. Permutar los coeficientes.

2. Replicar estos coeficientes a lo largo de una ventana k.
3. Escoger una muestra de cada ventana y ası́ recuperar cada coeficiente.

Se describen los dos algoritmos propuestos que denominaré sfft1 y sfft2. El primer algoritmo
asume que todos los coeficientes se encuentran, posiblemente aproximadamente, concentrados sobre
la ventana de tamaño k y por lo tanto al k-submuestrear en frecuencia se suman módulo k, pero
solo el término de la ventana es no nulo.

Algorithm 5 sparse Fourier Transform 1

1: procedure
Q
sfft1(X, k)
2: α ← Q nk .
3: Y ← Sk X.
4: Ŷ ← Fk (Y ).
5: X̂ ← α−1 hash(Ŷ ). . hash retorna las posiciones de la kventana centrada en 0.
6: Return X̂.
7: end procedure

Para la construcción de sfft2 vamos a asumir que la señal X está espectralmente concentrada
en una kventana centrada en 0, y los coeficientes que no están dentro de la ventana son pocos
—dispersos. Entonces, primero se estiman dichos coeficientes que están por fuera de la ventana
utilizando la transformada dispersa original [6], pero adaptada para dos dimensiones. Luego se
efectúa sfft1 para reconstruir la ventana.
16 Capı́tulo 2. Metodologı́a

Algorithm 6 sparse Fourier Transform 2

1: procedure sfft1(X, k, G, d)
2: outside ← OuterLoop(X, G, d).
3: inside ← sfft1(X, k).
4: X̂ ← outside ∪ inside.
5: Return X̂.
6: end procedure

Ası́, podremos cambiar la transformación de los BX batches de XRGB en tiempo O(k log k)
con sfft1 y en tiempo O(k log k + k log n) con sfft2. Además, el filtro G que se utilizará será la
ventana exacta de tamaño k, pues la multiplicación punto a punto en GPU toma solamente O(1).
A continuación se muestra la complejidad temporal teórica de cada proceso de estos dos diagramas.
La demostración de estos hechos la puede encontrar en el apéndice.
Fn O(n log n) n
Cn Cn Cn C
GP U
Sk αΣk
−→ O(1) O(log k)
Fk kO(k log k) k
Ck Ck C C
Fn O(n log n) n
Cn Cn Cn C
Pσ Pσ−1 O(1) O(1)
n Fn n nO(n log n) n
C C GP U C C
−→
Q
nG· Ĝ∗ O(1) O(1)
n Fn n nO(n log n) n
C C C C
ΣK SK O(log k) O(1)

k Fk k kO(k log k) k
C C C C
En conclusión, se implementará la convolución utilizando el siguiente diagrama,

Figura 2.3: Ilustración de la propuesta para efectuar convolución.

En suma, queremos resolver el problema de optimización 4 utilizando descenso de gradiente

para lo cual necesitamos calcular ∂L/∂wi , que, a su vez, se puede reducir a calcular ∂cj /∂wi (2.2).
2.1. Algoritmo de Entrenamiento 17

Para las capas diferentes a convolución – y por lo tanto no lineales– la derivada se puede calcular
fácilmente y la implementación ya viene dada para Matlab por [10]. Nos enfocaremos en el análi-
sis de ∂c/∂wi cuando c es una convolución y veremos cómo se traduce esta derivada a su versión
frecuencial.

Sea X ∈ RM ×M ×3×BX , F ∈ Rm×m×3×BF y Y ∈ R(M −m+1)×(M −m+1)×BF ×BX tales que,

Y = X ∗ F.
∂L ∂L ∂L
Por 2.2, tenemos que ∂X y ∂F se pueden calcular conociendo ∂Y . De hecho, dado que la
operación ∗ es lineal, para cada i ∈ [BX ],

∂L X ∂L ∂Yf i X ∂L
= ∗ = ∗ Ff .
∂Xi ∂Yf i ∂Xi ∂Yf i
f ∈[BF ] f ∈[BF ]

Análogamente, para cada f ∈ [Bf ],

∂L X ∂L ∂Yf i X ∂L
= ∗ = ∗ Xi .
∂Ff ∂Yf i ∂Ff ∂Yf i
i∈[BX ] i∈[BX ]

Ahora bien, la transformada de Fourier también es lineal y también podemos utilizar el dominio
frecuencial para calcular las derivadas. Las versiones frecuenciales de ∂L/∂wi son por consiguiente:
   
∂L X ∂L
Fn = Fn Fn (Ff )l . (2.6)
∂Xi l ∂Yf i l
f ∈[BF ]
   
∂L X ∂L
Fn = Fn Fn (Xi )l . (2.7)
∂Ff l ∂Yf i l
i∈[BX ]
 19

Capı́tulo 3

Evaluación Computacional

En esta sección vamos evaluar los algoritmos descritos en la sección anterior. La implementación
de estos algoritmos se llevó a cabo en una máquina con sistema operativo Windows con una CPU
que consiste de 8 procesadores AMD FX-8350, con 8Gb de memoria RAM y GPU GeForce GTX
750 con capacidad de cómputo 5.0. Se utilizó el toolbox de versión libre MatConvNet [10], sobre
Matlab R 2015a. Para la implementación de los algoritmos dispersos nos basamos en el algoritmo
implementado sobre C++ [6] transferido a CUDA y Matlab. Las bases de datos utilizadas para
demostrar la efectividad del algoritmo las puede encontrar en [5, 11, 12, 13, 14].

El primer banco de imágenes, DTD , fue recopilado por Cimpoi et al. [11]. Este consiste de 47
clases de texturas diversas presentes en la naturaleza. Las imágenes están a color y cada clase con-
tiene 120 instancias de imágenes de distintos tamaños, lo que equivale a un total de 5640 imágenes
de entrenamiento.

En el segundo banco de imágenes, KTH , hay una pequeña colección de imágenes con texturas
de ambientes de hogar [13]. Las imágenes están escala de grises y tienen dimensión 640 × 480
pixeles. Hay un total de 15 clases y 40 instancias por clase. La cantidad total de instancias en la
base de datos es, por lo tanto, 600.

La tercera base de datos evaluada es la colección de imágenes, Kyleberg , consistente de

19 clases de texturas variadas [5]. Las imágenes se encuentran en escalas de grises en dimensión
576 × 576. En cada clase hay 160 instancias para el entrenamiento.

La cuarta base de datos, Diabetic Retinopathy , fue obtenida del desafı́o de detección de
Diabetes realizado por Kaggle [14]. Esta base de datos contiene las fotografı́as a color de la retina
de alrededor de 9000 pacientes. Cada paciente está clasificado en una de 5 clases dependiendo del
estado de su Diabetes Retinopática. Las clases son Sin DR, DR Dócil, DR Moderada, DR Severa y
DR proliferativa. El tamaño original de 2496 × 1664, pero acá utilizamos una reducción a 256 × 256.

Finalmente evaluamos la base de datos construida inicialmente por la universidad de Stanford y

posteriormente procesada por Ng et al. stl [12]. En esta tenemos 10 clases de objetos y/o animales
a color en dimensión 96 × 96. En las siguientes figuras se ilustran imágenes de algunas de las clases
en cada banco de datos. Puede encontrar el resumen de esta información en la siguiente tabla.

Base de datos Clases Instancias Instancias/clase Dimensión Color

DTD 47 5640 120 200–400 Sı́
KTH 15 600 40 640 × 480 No
Kyleberg 19 3040 160 576 × 576 No
Diabetic Retinopathy 5 18307 (13410,1312,2754,449,382) 256 × 256 Sı́
stl 10 13000 1300 96 × 96 Sı́

Cuadro 3.1: Bancos de datos evaluados.

20 Capı́tulo 3. Evaluación Computacional

Banded Cracked HoneyCombed Pasiley Swirly

Figura 3.1: Imágenes de ejemplo de 5 clases de la base DTD .

Brick Carpet Fur Knit Uphosltery

Figura 3.2: Imágenes de ejemplo de 5 clases de la base KTH .

Blanket Ceiling Floor Rice Stone

Figura 3.3: Imágenes de ejemplo de 5 clases de la base Kyleberg .

Figura 3.4: Cinco imágenes de ejemplo de la base Diabetic Retinopathy .

Dog Cat Bird Airplane Car

Figura 3.5: Imágenes de ejemplo de 5 clases de la base stl .

3.1. CUDA y Programación Paralela

Se implementarán los algoritmos en la versión basada en C de la plataforma de programación
en tarjetas gráficas CUDA. La programación sobre este lenguaje requiere un estudio detallado de
la arquitectura particular de cada tarjeta gráfica y de descripciones más precisas sobre el hardware
especı́fico que se emplea durante la ejecución de cada comando. Por lo tanto no se comentarán
muchos detalles sobre cómo está conformada esta tarjeta de procesamiento. A grandes rasgos, la
tarjeta de procesamiento gráfico, GPU, puede realizar muchas más operaciones en paralelo que un
procesador central, CPU, debido a que su arquitectura enfoca más transistores en más submódulos
de procesamiento (ALU, CONTROL y CACHE). Por lo tanto en la GPU tenemos capacidad de
realizar más operaciones en las unidades Aritmético-Lógicas (ALU) de manera independiente a
3.2. CUFFT 21

cambio de tener menos registros por Unidad y unidades menos rápidas.

Figura 3.6: Breve ilustración de la arquitectura en una GPU y CPU. Gráfica de

desempeño en GFLOPs/s. [15]

En muchos casos resulta mejor tener pocos procesadores con más velocidad de operación por
segundo y con gran capacidad de memoria que tener muchos procesadores no tan rápido. Para
algoritmos que necesiten operar muchos procesos de forma serial es recomendable utilizar im-
plementaciones en CPU. Si, por el contrario, necesitemos hacer operaciones sencillas sobre cada
elemento de un arreglo y las operaciones entre arreglos son todas independientes entonces podrı́a
explorarse qué tan eficiente serı́a la implementación sobre GPU. Cabe notar que para realizar ope-
raciones sobre la GPU es necesario primer transferir los datos a la memoria global de la GPU,
efectuar las operaciones y luego trasferir los datos procesados de la GPU a la CPU. De aquı́ en
adelante llamaremos a las memorias del CPU y GPU como host y device respectivamente como es
común en literatura.

3.2. CUFFT
Nuestra propuesta para la optimización del algoritmo está centrada en la capacidad de realizar
rápidamente la trasformada de Fourier. Dado que en los algoritmos sFFT1 y sFFT2 realizamos
Fk (X), donde k|n y ki  ni , debemos tener presente la complejidad intrı́nseca de Fk . Tanto
Matlab como CUDA tienen versiones ya implementadas basadas en la versión original del algo-
ritmo de Cooley-Tukey. Vale la pena tener en cuenta las siguientes consideraciones sobre cada una
de las dos implementaciones:
1. Matlab utiliza versiones optimizadas del algoritmo de Cooley-Tukey para inputs con di-
mensiones que son potencias de primos pequeños: {2a , 3b , 5c }.
2. Matlab precompila implementaciones apropiadas de FFTW en CPU. En CPU utiliza ver-
siones de CUFFT.
3. CUDA por sı́ solo no contiene comandos para realizar esta operación por lo cual necesita
incluir la librerı́a cufft.
4. CUDA necesita crear un planificador para la transformada en cada operación y para esto es
necesario realizar lo siguiente:
Instanciar un planificador plan de tipo cufftHandle.
Inicializar el planificador definido previamente por medio de cufftPlanMany. Acá se
definen todos los parámetros de la transformada (Dimensión, muestreo, batches).
Liberar el espacio de memoria para el plan por medio de cufftDestroy.
5. CUDA permite realizar transformadas C → R (transformada directa) y R → C (transformada
inversa) aprovechando las simetrı́as de cada una.
6. Matlab y CUDA permiten arreglos de tipo single y double solamente.
22 Capı́tulo 3. Evaluación Computacional

Naturalmente, queremos utilizar la implementación más rápida y que utilice eficientemente el

uso de memoria. Para esto se decidió, por un lado, convertir cada base de datos a escala de grises
y uniformizar todos los tamaños a {642 , 1282 , 2562 }. Por otro lado, pondremos a prueba ambas
implementaciones variando el tamaño de los batches. Veremos cuál implementación utiliza más
eficiente la memoria utilizando el NVIDIA visual profiler y evaluaremos los tiempos de corrida de
ambos con los comandos de matlab gputimeit.

Dimensión
64 128 256
4 0.15(1.49) 0.15(2.03) 0.34(2.61)
16 0.29(2.01) 0.38(2.61) 1.11(6.12)
Batch 64 0.72(2.60) 1.27(7.79) 3.57(21.20)
256 2.99(7.68) 4.61(21.32) 78.19(76.98)
512 10.38(15.61) 8.98(39.05) 153.43(152.19)

Cuadro 3.2: Tiempo en milisegundos que le tomó a Matlab (CUDA) realizar

F(X).

Se puede notar que es el para dimensiones inferiores a 256 y bathces de tamaño menores que 512,
el tiempo que le toma a Matlab llevar a cabo la fft es menor. Matlab optimiza los llamados de
FFT en dimensiones pequeñas y a eso se debe esta discrepancia. Sin embargo, cuando la cantidad
de batches aumenta y en imágenes más grandes ambos procesos toman el mismo tiempo. Veamos
qué ocurre en profiler cuando (Batch, Dimension) = (64, 256), (512, 256).
El comando utilizado en el NVIDIA visual profiler es

-nojvm -nosplash -r test

El resultado demuestra que ambas transformadas realizan exactamente la misma operación

(llamado a CUFFT con la misma cantidad de threads y blocks). Sin embargo Matlab realiza
múltiples operaciones para redimensionar el arreglo en RM ×M ×1×Bch y luego sı́ efectúa la trans-
formada. Por otro lado el llamado del kernel que realiza CUFFT directamente es más eficiente en
cuanto a que el kernel realiza la copia de X a dX más rápido pero desalocar la memoria le toma
más tiempo. Por tanto se decide utilizar la implementación fft de Matlab .

3.3. Convolución
En esta sección pondremos a prueba la diferentes versiones para realizar la operación X ∗ F, en
el que X ∈ RM ×M ×1×BX , F ∈ Rk×k×1×Bf sobre el rango

(M, k, BX , BF ) ∈ {26 , 27 , 28 } × {4, 8, 12, 16} × {25 , 26 , 27 } × {2, 4, 6, 8, 10}.

A continuación vamos a contrastar los tiempos de los algoritmos vl nnconv [10], fftconv, y
sfftconv 5. La primera tabla muestra el tiempo de ejecución de vl nnconv y en la imagen si-
guiente se muestran un mapa de color con la relación de este tiempo con los de vl nnconv y
fftconv sfftconv respectivamente.
3.3. Convolución 23

M 64 128 256
k 4 8 12 16 4 8 12 16 4 8 12 16
BF BX
32 1.30 2.06 3.58 5.52 2.44 6.40 11.58 17.68 7.32 20.12 41.63 71.15
2 64 2.44 3.85 6.80 9.76 4.19 11.56 21.04 35.09 13.89 39.95 83.02 141.92
128 4.66 7.52 11.67 18.96 8.10 22.09 41.65 69.91 27.83 79.62 165.70 283.78
32 1.29 2.08 3.57 5.55 2.51 6.44 12.05 17.66 7.47 20.19 41.68 71.13
4 64 2.37 3.86 6.77 10.73 4.27 11.27 21.93 35.03 14.14 40.07 83.09 142.10
128 4.57 7.41 13.24 21.28 7.97 22.20 41.76 69.77 28.99 79.77 165.72 283.88
32 1.28 2.08 3.55 5.54 2.30 5.85 10.71 17.76 7.63 21.03 41.76 71.20
6 64 2.38 3.86 6.72 10.77 4.28 11.38 21.10 35.05 16.27 49.36 83.31 142.09
128 4.04 7.15 12.28 19.11 9.39 23.23 41.92 69.87 29.53 80.35 165.88 283.89
32 1.28 2.09 3.53 3.20 2.55 6.16 10.79 17.73 9.00 20.49 41.85 71.31
8 64 2.40 3.91 6.83 10.71 4.61 11.71 21.28 35.15 15.65 40.79 83.40 142.23
128 4.24 6.65 11.77 21.35 8.99 22.94 42.21 70.05 31.84 81.13 166.53 284.29
32 1.29 2.13 3.57 5.59 2.81 6.16 10.83 18.53 9.28 21.21 42.10 71.37
10 64 2.42 3.74 6.95 10.21 5.83 12.40 22.27 35.24 17.69 41.64 83.84 142.55
128 4.15 6.80 11.69 19.20 10.00 23.62 42.49 70.29 131.28 175.80 258.90 372.11

Cuadro 3.3: Tiempo, en milisegundos, en realizar vl nnconv(X,F) en GPU.

M, k

64 128 256
4 8 12 16 | 4 8 12 16 | 4 8 12 16
---------
32 2.5

2 64

128
---------
32 2

4 64

128
---------
32 1.5
BF, B X

6 64

128
---------
32 1

8 64

128
---------
32 0.5

10 64

128
---------

Figura 3.7: log10 (CP U [ms]) .

24 Capı́tulo 3. Evaluación Computacional

M 64 128 256
k 4 8 12 16 4 8 12 16 4 8 12 16
BF BX
32 1.16 1.13 1.14 1.13 3.498 3.43 3.38 3.24 12.91 12.11 12.11 12.66
2 64 1.93 1.97 1.96 1.87 6.42 6.12 6.39 6.03 23.61 23.46 23.48 23.92
128 3.55 3.43 3.26 3.22 12.24 11.51 11.54 11.53 - - - -
32 1.87 1.88 1.89 1.91 6.09 6.1 6.1 5.78 23.79 22.78 22.28 22.35
4 64 3.28 3.29 3.29 3.26 11.36 11.12 10.95 11.23 108.64 108.1 109.29 107.69
128 6.1 6.07 6.06 6.05 21.71 21.62 22.53 21.24 - - - -
32 2.54 2.52 2.53 2.56 8.17 8.17 8.72 8.7 81.35 81.79 80.72 81.65
6 64 4.59 4.59 4.62 4.61 16.05 15.74 15.65 15.73 222.2 221.15 220.26 223.66
128 8.1321 8.64 8.66 8.08 82.35 79.44 78.79 80.67 - - - -
32 3.23 3.16 3.24 5.55 11.27 11.3 10.84 10.61 112 109.17 107.55 112.39
8 64 5.89 6 5.9 5.89 21.45 21.66 20.55 20.61 - - - -
128 11.27 10.56 10.99 11.32 105.76 105.57 106.18 107.18 - - - -
32 3.89 3.9 3.88 3.89 13.98 13.3 13.08 13.91 135.97 136.9 134.62 134.72
10 64 7.27 7.25 6.41 6.92 66.96 67.55 67.32 65.05 - - - -
128 13.44 13.01 12.99 12.97 133.33 130.64 129.44 125.76 - - - -

Cuadro 3.4: Tiempo, en milisegundos, en realizar fft conv(X,F) en GPU.

M, k
64 128 256
4 8 12 16 | 4 8 12 16 | 4 8 12 16
--------
32

2 64 0.6

128
-------- 0.4
32

4 64 0.2

128
-------- 0
32
BF B X

6 64 -0.2

128
-------- -0.4
32

8 64 -0.6

128
--------
-0.8
32

10 64
-1

128
--------

Figura 3.8: log10 (vl nnconv/fft conv)

3.3. Convolución 25

M 64 128 256
k 4 8 12 16 4 8 12 16 4 8 12 16
BF BX
32 0.63 0.63 0.63 0.63 1.31 1.31 1.31 1.31 4.07 4.07 4.07 4.07
2 64 0.924 0.924 0.924 0.924 2.22 2.22 2.22 2.22 7.54 7.54 7.54 7.54
128 1.43 1.43 1.43 1.43 3.99 3.99 3.99 3.99 80 80 80 80
32 0.93 0.93 0.93 0.93 2.22 2.22 2.22 2.22 7.62 7.62 7.62 7.62
4 64 1.4 1.4 1.4 1.4 3.97 3.97 3.97 3.97 79.43 79.43 79.43 79.43
128 2.36 2.36 2.36 2.36 7.42 7.42 7.42 7.42 - - - -
32 1.19 1.19 1.19 1.19 3.12 3.1215 3.12 3.13 74 74 74 74
6 64 1.92 1.92 1.92 1.92 5.7 5.7 5.7 5.7 143 143 143 143
128 3.28 3.28 3.28 3.28 60.69 60.69 60.69 60.69 - - - -
32 1.52 1.52 1.52 1.52 3.96 3.96 3.96 3.96 81.37 81.37 81.37 81.37
8 64 2.36 2.36 2.36 2.36 7.4 7.4 7.4 7.4 - - - -
128 4.13 4.13 4.13 4.13 78.8 78.8 78.8 78.8 - - - -
32 1.74 1.74 1.74 1.74 4.86 4.86 4.86 4.86 101.98 101.98 101.98 101.98
10 64 2.88 2.88 2.88 2.88 50.99 50.99 50.99 50.99 - - - -
128 5.19 5.19 5.19 5.19 99.43 99.43 99.43 99.43 - - - -

Cuadro 3.5: Tiempo, en milisegundos, en realizar sfft conv(X,F) en GPU.

M, k
64 128 256
4 8 12 16 | 4 8 12 16 | 4 8 12 16
-------
32

2 64
1

128
-------
32

4 64
0.5
128
-------
32
BF, B X

6 64
0
128
-------
32

8 64

128 -0.5
-------
32

10 64

128
-1
-------

Figura 3.9: log10 (vl nnconv/sfft conv)

3.3.1. Discusión de resultados

La tabla nos muestra resultados importantes acerca de los tiempos de cada uno de los algorit-
mos propuestos frente a la implementación directa de convolución por MatConvNet. El tiempo de
ejecución para una convolución por medio vl nnconv incrementa conforme aumentan la dimensión
de las imágenes M , la dimensión del filtro k, el tamaño del batch de las imágenes BX , y el tamaño
del batch BF . Este incremento es un resultado coherente, pues hay más entradas sobre las que toca
hacer operaciones. También se puede ver que, entre todas las variables que influyen sobre el entre-
namiento, la dimensión de las imágenes, M , es la que más incrementa el tiempo de ejecución. Esto
sugiere que, el entrenar una banco de imágenes por redes convolucionales, hay que dar atención
especial a la dimensión en el que se encuentran las imágenes. El primer mapa de colores resalta este
26 Capı́tulo 3. Evaluación Computacional

hecho mostrando los tiempos más grandes (colores claros) a medida que aumenta M, k, BX , BF y
tiempos relativamente cortos (colores oscuros) en el caso contrario.

La implementación de vl nnconv sobre las GPU y CPU descritas al comienzo de esta sección
favorecen al tiempo consumido por la GPU. Este hecho es plausible y obedece a la naturaleza
lineal de la convolución que es aprovechada al máximo por implementaciones rápidas lineales en
paralelo. El lector interesado puede mirar la documentación de CUBLAS. Una de las consecuencias
de realizar la convolución en el dominio frecuencial es que la complejidad permanece inalterada a
variaciones de k (ver 2.4). Esto se hace evidente en el segundo mapa de colores y la segunda tabla.
De esta manera, aunque para tamaños de kernel k pequeños sea más rápido hacer la convolución
directa, la FFT nos da la posibilidad de utilizar kerneles más grandes sin sacrificar más tiempo. En
la mayorı́a de casos, resulta ser más conveniente utilizar fft conv que vl nnconv, puede observarse
los cuadros que están en azul en el segundo y tercer mapa. Sin embargo, este umbral depende
también de M, BX y BF . Esta dependencia se atenúa con la implementación de sfft, pues en
principio, las imágenes más grandes resultarán ser más dispersas y por lo tanto no será necesario
calcular Fn (X) sino Fk (Sk (X)).

3.4. Entrenamiento de redes

Luego de analizar el comportamiento de las capas convolucionales, procederemos a entrenar
varias arquitecturas de redes convolucionales sobre todas los bancos de datos. Para tal fin, pro-
cedimos a entrenar cada uno de la escogencias de (M, k, BX , BF ) que se utilizaron en la sección
de convolución y aquı́ reportamos los resultados de la mejor implementación. Se compararán los
tiempos y frecuencia de error para la mejor red entrenada con: la versión en GPU de vl nnconv,
fft conv, y sfft conv.

3.4.1. DTD
La red que mejor dio resultados fue:

Capa Conv bnorm max Conv Bnorm max Conv ReLu SoftMax
64 8 1 3 4 1 3 5 1 1
Batch 2 2 2 16 16 16 16 47 1

Cuadro 3.6: Red para el DTD en dimensión 64 × 64.

Velocidad de vl nnconv:759 Hz
Velocidad de sfft conv:977 Hz

objective error
0.95 objective error
0.96
train traintop1err
3.76 train traintop1err
val traintop5err
0.9 val traintop5err
4 valtop1err 0.94
valtop1err
valtop5err
valtop5err
0.85 3.74
0.92

3.8
0.8
3.72 0.9

0.75
0.88
3.6
3.7
energy

energy
error

error

0.7
0.86

0.65 3.68
3.4 0.84

0.6 0.82
3.66

3.2 0.55 0.8

3.64
0.5 0.78

3 3.62
0.45 0.76
0 10 20 30 40 50 0 10 20 30 40 50 0 20 40 60 80 100 0 20 40 60 80 100
training epoch training epoch training epoch training epoch

Figura 3.10: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

3.4. Entrenamiento de redes 27

Capa Conv bnorm max Conv Bnorm max Conv ReLu SoftMax
128 12 1 6 4 1 4 4 1 1
Batch 2 2 2 16 16 16 16 47 1

Cuadro 3.7: Red para el DTD en dimensión 128 × 128.

Velocidad de vl nnconv: 34 Hz
Velocidad de sfft conv: 95 Hz

objective error objective error

1 1
3.8
train traintop1err 3.7 train traintop1err
val traintop5err val traintop5err
3.7
valtop1err valtop1err
3.6
0.9 valtop5err 0.9 valtop5err
3.6
3.5
3.5
0.8 0.8
3.4
3.4
energy

energy
3.3 3.3
error

error
0.7 0.7

3.2 3.2

3.1 0.6 0.6

3.1

3
3
0.5 0.5

2.9
2.9

0.4 0.4
0 10 20 30 40 50 0 10 20 30 40 50 0 10 20 30 40 50 0 10 20 30 40 50
training epoch training epoch training epoch training epoch

Figura 3.11: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

3.4.2. KTH
La red que mejor dio resultados fue:

Capa Conv bnorm max Conv ReLu SoftMax

64 8 1 5 11 1 1
Batch 2 2 2 15 15 1

Cuadro 3.8: Red para el DTD en dimensión 64 × 64.

Velocidad de vl nnconv:500 Hz
Velocidad de sfft conv: 3 kHz

objective error objective error

0.9 0.9
3 train traintop1err 2.5 train traintop1err
val traintop5err val traintop5err
0.8 valtop1err 0.8 valtop1err
2.8 valtop5err 2.4 valtop5err

0.7 0.7
2.6 2.3

0.6 0.6
2.2
2.4
energy

energy
error

error

0.5 0.5
2.1
2.2

0.4 0.4
2
2
0.3 0.3
1.9

1.8 0.2 0.2

1.8

0.1 0.1
0 20 40 60 80 100 0 20 40 60 80 100 0 20 40 60 80 100 0 20 40 60 80 100
training epoch training epoch training epoch training epoch

Figura 3.12: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

28 Capı́tulo 3. Evaluación Computacional

Capa Conv bnorm max Conv Bnorm max Conv Bnorm max Conv ReLu SoftMax
128 16 1 3 4 1 3 4 1 3 2 1 1
Batch 2 2 2 2 2 2 2 2 2 15 15 1

Cuadro 3.9: Red para el KTH en dimensión 128 × 128.

Velocidad de vl nnconv:60 Hz
Velocidad de sfft conv:711 Hz

objective error objective error

10 2 0.9 10 2 0.9
train traintop1err train traintop1err
val traintop5err val traintop5err
valtop1err valtop1err
0.8
0.8 valtop5err valtop5err

0.7
0.7 10 1

0.6
energy

energy
error

error
10 1 0.6

0.5

0.5 10 0
0.4

0.4
0.3

10 0 0.3 10 -1 0.2
0 20 40 60 80 100 0 20 40 60 80 100 0 50 100 150 200 0 50 100 150 200
training epoch training epoch training epoch training epoch

Figura 3.13: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

3.4.3. Kylberg
La red que mejor dio resultados fue:

Capa Conv bnorm max Conv ReLu SoftMax

64 12 1 4 13 1 1
Batch 2 2 2 15 15 1

Cuadro 3.10: Red para el DTD en dimensión 64 × 64.

Velocidad de vl nnconv:227 Hz
Velocidad de sfft conv:657 Hz

objective error objective error

10 2 0.9 1
train traintop1err train traintop1err
val traintop5err val traintop5err
0.8 0.9
valtop1err valtop1err
valtop5err valtop5err
10 1 0.8
0.7

0.7
0.6
10 0
0 0.6
10
0.5
energy

energy
error

error

0.5

0.4
10 -1 0.4

0.3
0.3

0.2
10 -2 0.2

0.1 0.1

10 -3 0 0
0 50 100 150 0 50 100 150 0 20 40 60 80 100 120 0 20 40 60 80 100 120
training epoch training epoch training epoch training epoch

Figura 3.14: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

3.4. Entrenamiento de redes 29

Capa Conv bnorm max Conv Bnorm max Conv Bnorm max Conv ReLu SoftMax
128 12 1 3 4 1 3 4 1 3 3 1 1
Batch 2 2 2 20 20 20 20 20 20 19 19 1

Cuadro 3.11: Red para el Kyleberg en dimensión 128 × 128.

Velocidad de vl nnconv: 88 Hz
Velocidad de sfft conv: 462 Hz

objective error
objective error 0.9
0.9 2.6
2.4 train traintop1err
train traintop1err
val traintop5err
val traintop5err 2.2 0.8 valtop1err
0.8 valtop1err 2 valtop5err
valtop5err
1.8 0.7
0.7 1.6

1.4 0.6

0.6
1.2
0.5

energy

error
energy

error

0.5 1
0.4

0.4 0.8
0.3

10 0 0.3
0.6 0.2

0.2 0.1

0
0.1 0 20 40 60 80 100 0 20 40 60 80 100
0 20 40 60 80 100 0 20 40 60 80 100
training epoch training epoch
training epoch training epoch

Figura 3.15: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

3.4.4. Retinopatı́a Diabética

La red que mejor dio resultados fue:

Capa Conv bnorm max Conv SoftMax

64 8 1 10 5 1
Batch 2 2 2 15 1

Cuadro 3.12: Red para el Diabetic Retinopathy en dimensión 64 × 64.

Velocidad de vl nnconv:932 Hz
Velocidad de sfft conv:2.3 kHz

objective error objective error

0.8 0.6
2.1 train traintop1err 3.5 train traintop1err
val traintop5err val traintop5err
2 0.7 valtop1err valtop1err
valtop5err 3 valtop5err
0.5
1.9

0.6 2.5
1.8

1.7 0.4
0.5
2
1.6
energy

energy
error

error

0.4 0.3
1.5

1.5
1.4 0.3
0.2

1.3
0.2

1.2 0.1
1
0.1

1.1
0 0
0 20 40 60 80 100 0 20 40 60 80 100 0 20 40 60 80 100 0 20 40 60 80 100
training epoch training epoch training epoch training epoch

Figura 3.16: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

30 Capı́tulo 3. Evaluación Computacional

Capa Conv bnorm max Conv Bnorm max Conv max Conv SoftMax
128 8 1 3 4 1 3 4 3 3 1
Batch 2 2 2 4 4 4 8 8 15 1

Cuadro 3.13: Red para el Diabetic Retinopathy en dimensión 128 × 128.

Velocidad de vl nnconv:168 Hz
Velocidad de sfft conv:697 Hz

objective error objective error

0.7 0.7
train traintop1err train traintop1err
val traintop5err 2 val traintop5err
2
valtop1err valtop1err
0.6 0.6
valtop5err valtop5err

1.8 1.8

0.5 0.5

1.6 1.6

0.4 0.4
energy

energy
error

error
1.4 1.4

0.3 0.3

1.2
1.2
0.2 0.2

0.1 0.1
1
1

0 0
0 20 40 60 80 100 0 20 40 60 80 100 0 20 40 60 80 100 0 20 40 60 80 100
training epoch training epoch training epoch training epoch

Figura 3.17: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

3.4.5. STL
La red que mejor dio resultados fue:

Capa Conv bnorm max Conv Bnorm max Conv SoftMax

64 12 1 3 12 1 3 5 1
Batch 2 2 2 4 4 4 10 1

Cuadro 3.14: Red para el stl en dimensión 96 × 96.

Velocidad de vl nnconv:170 Hz
Velocidad de sfft conv:787 Hz

objective error objective error

0.8 0.8
train traintop1err train traintop1err
val traintop5err val traintop5err
1.9 1.9
0.7 valtop1err 0.7 valtop1err
valtop5err valtop5err

1.8 1.8
0.6 0.6

1.7 0.5 1.7 0.5

energy

energy
error

error

0.4 1.6 0.4

1.6

0.3 0.3
1.5 1.5

0.2 0.2

1.4
1.4
0.1 0.1

0 0
0 10 20 30 40 50 0 10 20 30 40 50 0 20 40 60 80 100 0 20 40 60 80 100
training epoch training epoch training epoch training epoch

Figura 3.18: Desempeño vl nnconv (izquierda) contra sfft conv (derecha).

3.4. Entrenamiento de redes 31

3.4.6. Discusión de Resultados

Mientras que la velocidad de entrenamiento fue notoriamente mayor para el entrenamiento de
las redes en todos los casos, los errores de generalización obtenidos del entrenamiento de las redes
en tanto vl nnconv como sfft conv fueron parecidos. Ası́ mismo, los errores de entrenamiento
de las redes fueron semejantes entre sı́ en todos los casos salvo por una excepciones. Por ejemplo,
para la base DTD la implementación dispersa obtuvo un error de entrenamiento más acorde al
error de generalización y por lo tanto no se presentó overfitting a diferencia de la implementación
directa. En otros casos –como la base KTH en dimensión 128 y la base Diabetic Retinopathy
en dimensión 64, – ocurrió el fenómeno inverso: el error de entrenamiento no se diferenció del error
de generalización.

El error cuadrático medio también fue similar para ambas formas de entrenar la red, pero el
mismo error, para el conjunto de validación, fue notoriamente mejor en el caso disperso. Esto nos
sugiere que la red en el caso disperso tiene un comportamiento más robusto en términos de con-
vergencia. Probablemente, esto es consecuencia de que, por una lado, entrenar por medio de la red
dispersa es equivalente a realizar un filtro sobre la imagen que elimina frecuencias pequeñas que
ayuda para la clasificación y, por otro lado, la capa dispersa no es completamente lineal (al no ser
la transformada completa) y por ende puede pensarse que hace el papel de capa lineal y capa no
lineal al mismo tiempo.

Las gráficas demuestran que el aprendizaje basado en redes convolucionales por medio una
transformada dispersa es posible y además tiene consecuencias favorables. Dado que el tiempo de
entrenamiento es mucho menor y el error de generalización, en muchos casos, es similar o menor al
error de generalización usual, entonces una posible utilidad de esta red es utilizarla para estimar
el error real de generalización al entrenar una red con la convolución directa, en un tiempo mucho
menor. Otra posible aplicación es reemplazar del todo la primera capa convolucional por la capa
dispersa y enfocarse en tratar de sintonizar esta red para obtener mejores resultados.
 33

Capı́tulo 4

Conclusiones y trabajo futuro

El conjunto de objetivos que se trazaron al comienzo, y que dieron nacimiento a este proyecto,
se cumplieron enteramente en forma satisfactoria. En este proyecto logramos entrenar una red
convolucional para clasificar imágenes en Matlab utilizando los procesadores principal y gráfico.
También logramos utilizar la transformada de Fourier para acelerar las etapas que involucran con-
voluciones en ciertos casos. Finalmente, conseguimos diseñar una versión de la transformada de
Fourier, basada en el algoritmo original por Katabi et al. [6], para calcular el espectro en imágenes
espectralmente dispersas más rápidamente que los algoritmos del estado del arte.

La clausura de este proyecto deja abierta varias preguntas interesantes que valen la pena con-
siderar y al mismo tiempo pueden constituir el inicio en proyectos nuevos. La reducción en tiempo
y memoria al utilizar transformadas dispersas hace que la complejidad por hacer convolución por
métodos espectrales recaiga sobre la capacidad de hacer la transformada inversa. La transformada
inversa debe aplicarse a un arreglo que proviene del producto entre el filtro y la imagen dis-
persa, y por consiguiente también es dispersa. Ası́, una posible alternativa de mejora serı́a pensar
en algoritmos más rápidos para calcular la transformada sobre señales que son dispersas en espacio.

La naturaleza del algoritmo disperso basada en calcular múltiples transformadas pequeñas su-
giere crear circuitos integrados especı́ficamente diseñados para operar sobre dicha transformada.
Otra alternativa de mejora es diseñar bloques optimizados de hardware que efectúen FFT, sub-
muestreo, y suma módulo, por ejemplo, en una ASIC o FPGA. Con esto, no solo mejorarı́amos el
rendimiento y utilización de recursos, sino que se disminuirı́a el costo del procesador y la energı́a
consumida por operación.

Dado que algoritmo propuesto para calcular el espectro sobre imágenes espectralmente exac-
tamente dispersas tuvo tan buen desempeño, otra propuesta de trabajo futuro es enfocarse en
métodos que generalicen dicho algoritmo para señales en dimensiones mayores. El algoritmo ac-
tual no es determinı́stico, pero la probabilidad con la que falla es exponencialmente pequeña si
se asume una señal uniforme sobre cada coordenada. Podrı́a pensarse en heurı́sticas más robustas
para garantizar probabilidad de error aún más pequeña. Por ejemplo, gracias el teorema Chino del
Residuo, se podrı́an utilizar más subtransformadas para mejorar la sesgo en la estimación de la
localización a expensas de lograr menos reducción en tiempo.

La comparación entre las transformadas – la precompilada por Matlab y la repetidamente

creada y planifica en CUDA– (Sección 3.2) suscita investigar sobre cómo utilizar mejor las capaci-
dades de CUDA y de esta forma no tener que lidiar con los overheads que necesita Matlab para
comunicarse con variables del host y device. (i.e. mxGPUArray, mxGPUDestroyGPUArray, etc.) Tener
que alocar y desaolcar memoria cada vez que se crea un plan para la transformada es ineficiente.
En este orden de ideas, dos futuros proyectos son: transferir toda la arquitectura creada en la me-
moria – tanto en CPU como GPU– de Matlab a CUDA; y mejorar la comunicación entre CUDA
y Matlab .
 35

Apéndice A

Demostración de los teoremas

Los teoremas enunciados en la sección sobre metodologı́a para la construcción de los algoritmos
se demuestran en este apéndice.
Teorema 2.1.1
Demostración. Sean X ∈ RN , F ∈ Rn . Defina X ∗ F =: Y ∈ RN −n+1 , como Yi = j Xi+j Fn−j .
P

Defina ωN = e2iπ/N y i ∈ [N ], entonces

  ! N  !
XN Xn X Xn
ji ki j k
FN (X)i FN (F )i =  Xj ωN  Fk ωN =  Xj z  Fk z ,
j=1 k=1 j=1 k=1

i
PN
donde z = ωN . Visto de esta forma, es fácil darse cuenta que el coeficiente de z i en ( j=1 Xj z j )·
Pn k
P
( k=1 Fk z ) es j+k=i Xj Fk . Por ende,
  ! N +n  
XN n
X X X
 Xj z j  Fk z k =  Xj Fk  z i ,
j=1 k=1 i=1 j+k=i
N
X +n
= Yi−n z i ,
i=1
N
X
= Yi z i−n = FN (Y )i−n .
i=1

Como i fue arbitrario, entonces se cumple para todo i = n + 1, . . . , N .

Teorema 2.1.2
Demostración. Sean k, n, con ki |ni . Sean Fn , Sk , Σk , Fk como en las definiciones 2.1.1-2.1.4. Sea
Y = Sk (X), entonces Y (j) = X(j nk ). Por la definición,

k k
X X n
Fk (Y )i = Y (j)ωkij = X(j )ωkij ,
j=1 j=1
k

n/k n
X X X
Σk (Fn (X))i = Fn (X)l = X(j)ωnj(i+kl) ,
l≡k i l=1 j=1
n/k
n X
X
= X(j)ωnj(i+kl) ,
j=1 l=1
n n/k
X X
= X(j)ωnij ωnjkl .
j=1 l=1
36 Apéndice A. Demostración de los teoremas

Pn/k n/k
Ahora bien, l=1 ωnjkl = z + z 2 + · · · + z n/k = z z z−1−1 , donde z = ωnjk siempre que z 6= 1,
Pn/k Pn/k
es decir, cuando nk 6 |j. En tal caso z n/k − 1, por tanto l=1 ωnjkl = 0. Cuando nk |j, l=1 ωnjkl =
1 + · · · + 1 = nk . Entonces,
n/k
(
X
jkl 0, nk 6 |j,
ωn = n n
l=1 k, k |j.

Por tanto,
k k
X n nX n ij n nX n n
Σk (Fn (X))i = X(j)ωnij = X(j )ωn k = X(j )ωkij = Fk (S(X))i .
n k k j=1 k k j=1 k k
k |j

n
Σk (Fn (X))i = Fk (S(X))i .
k
El caso en varias dimensiones n, k es análogo.
Teorema 2.1.3
Demostración. Sean k, n, con ki |ni . Sean Fn , Sk , Σk , Fk , Pσ como en las definiciones 2.1.1-2.1.4,
siendo (σ, n) = 1. Sea G ∈ Cn . Para ver que el primer diagrama es conmutativo nótese que,
n n n
X X X −1
Fn (Pσ (X))i = Pσ (X)j ωnij = Xσj ωnij = Xj ωniσ j
= Pσ−1 (Fn (X))i .
j=1 j=1 j=1

Para ver que se cumple el hecho en el segundo diagrama, recordemos que para convolución
entre señales, X
(G ∗ X)i = Gj Xk .
j+k=i

Entonces,
  !
n n
1 X 1 X
Fn−1 (G)i · Fn−1 (X)i =  Gj ωn−ij  Xk ωn−ik ,
n j=1 n
k=1
  !
n n
1 X X
= 2 Gj z j  Xk z k ,
n j=1 k=1
 
2n
1 X X
= 2 Gj Xk  z i ,
n i=1
j+k=i
2n
1 X 1 −1
= (G ∗ X)i z i = F (G ∗ X)i .
n2 i=1
n n

Finalmente, para la última propiedad tenemos que,

k n/k
k X
X X
Fk (Σk (X))i = Σk (X)j ωkij = Xlk+j ωkij . (A.1)
j=1 j=1 l=1

i(j+lk)
Nótese que ωklk = 1, de manera que ωkij = ωk . Si reemplazamos esto en A.1,

n/k
k X n
i(lk+j)
X X
Fk (Σk (X))i = Xlk+j ωk = Xj ωkij ,
j=1 l=1 j=1
n
n
ij
X
= Xj ωn k
= Sk (Fn (X))i .
j=1
Apéndice A. Demostración de los teoremas 37

Esto completa la prueba.

Cabe notar que estas demostraciones se pueden generalizar fácilmente para cualquier dimensión
d. Para mostrar, por ejemplo, la conmutatividad del segundo diagrama del teorema 2.1.3, para
n = (n1 , . . . , nd ), i = (i1 , . . . , id ), definimos ωnij := ωni11j1 · · · · · ωniddjd , I := [n1 ] × · · · × [nd ].

  !
1 X t 1 X t
Fn−1 (G)i · Fn−1 (X)i =  Q Gj ωn−ij  Q Xk ωn−kj ,
n n
j∈I k∈I
 2 X
1 X
= Q Gj zj X k zk ,
n
j∈I k∈I
 
 2 X
1 X
= Q  Gj Xk  zi ,
n
i∈2I j+k=i
 
1
= Q Fn−1 (G ∗ X)i .
n
 39

Bibliografı́a

[1] Christopher M Bishop. Neural networks for pattern recognition. Oxford university press.
[2] Bernhard Korte y col. Combinatorial optimization. Springer.
[3] Richard O Duda, Peter E Hart y David G Stork. Pattern classification. John Wiley & Sons.
[4] George Cybenko. ((Approximation by superpositions of a sigmoidal function)). En: Mathema-
tics of control, signals and systems 2.4 (1989), págs. 303-314.
[5] Gustaf Kylberg. The Kylberg Texture Dataset v. 1.0. External report (Blue series) 35. 2011.
url: http://www.cb.uu.se/~gustaf/texture/.
[6] Haitham Hassanieh y col. ((Simple and practical algorithm for sparse Fourier transform)).
En: Proceedings of the twenty-third annual ACM-SIAM symposium on Discrete Algorithms.
SIAM, págs. 1183-1194.
[7] Yann A LeCun y col. ((Efficient backprop)). En: Neural networks: Tricks of the trade. Springer,
págs. 9-48.
[8] Nicolas Vasilache y col. ((Fast convolutional nets with fbfft: A GPU performance evaluation)).
En: arXiv preprint arXiv:1412.7580 (2014).
[9] Michael Mathieu, Mikael Henaff y Yann LeCun. ((Fast training of convolutional networks
through FFTs)). En: arXiv preprint arXiv:1312.5851 (2013).
[10] Andrea Vedaldi y Karel Lenc. ((MatConvNet: Convolutional neural networks for matlab)).
En: Proceedings of the 23rd Annual ACM Conference on Multimedia Conference. ACM,
págs. 689-692.
[11] M. Cimpoi y col. Describing Textures in the Wild. 2014.
[12] Adam Coates, Andrew Y Ng y Honglak Lee. ((An analysis of single-layer networks in unsuper-
vised feature learning)). En: International conference on artificial intelligence and statistics.
2011, págs. 215-223.
[13] Mario Fritz y col. The kth-tips database. 2004.
[14] Diabetic Retinopathy Detection. 2015. url: https : / / www . kaggle . com / c / diabetic -
retinopathy-detection.
[15] CUDA NVIDIA. C Programming Guide, version 7.5. 2015.