Implementación en GPU del algoritmo K-Means para ... - UMBC

UNIVERSIDAD DE EXTREMADURA
Escuela Politécnica
MÁSTER UNIVERSITARIO EN
COMPUTACIÓN GRID Y PARALELISMO
Trabajo Fin de Máster
Implementación en GPU del algoritmo K-Means
para procesamiento paralelo de imágenes de satélite
disponibles en la herramienta Google Maps
Sergio Bernabé García
Septiembre, 2010

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Trabajo Fin de Máster -2- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
UNIVERSIDAD DE EXTREMADURA
Escuela Politécnica
MÁSTER UNIVERSITARIO EN
COMPUTACIÓN GRID Y PARALELISMO
Trabajo Fin de Máster
Implementación en GPU del algoritmo K-Means
para procesamiento paralelo de imágenes de satélite
disponibles en la herramienta Google Maps
Autor: Sergio Bernabé García
Fdo.:
Director: Antonio Plaza Miguel
Fdo.:
CALIFICACIÓN:
FECHA:
Tribunal Calificador
Presidente:
Fdo.:
Secretario:
Fdo.:
Vocal:
Fdo.:
Trabajo Fin de Máster -3- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Trabajo Fin de Máster -4- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Si supiese qué es lo que estoy haciendo,
no le llamaría investigación, verdad?
Albert Einstein.
Trabajo Fin de Máster -5- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Trabajo Fin de Máster -6- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
AGRADECIMIENTOS
En estas líneas, quiero agradecer sinceramente todo el apoyo que me ha brindado, la gente que me
ha acompañado durante este año.
En primer lugar deseo expresar mi más sincero agradecimiento a mi director de TFM, Antonio
Plaza Miguel, por haber confiado en mí para la realización de este trabajo de investigación y por todos
sus consejos recibidos a lo largo del mismo. Asimismo agradecer a mis compañeros del grupo
HYPERCOMP: Sergio y Gabri, por las ayudas y los consejos recibidos durante la realización del trabajo,
también a mis compañeros de Máster: Josi, Kiwi, David y Álvaro por los buenos momentos pasados a lo
largo de este año.
También darle las gracias a mi familia por todo el apoyo recibido, a mis amigos y el más especial
agradecimiento a mi novia Sheila, porque siempre ha creído en mí y que más ha comprendido, que ante
todo en esta vida está el ser feliz y que a su lado he conseguido serlo. Sin ti las cosas no serían lo mismo,
TE QUIERO!!.
Trabajo Fin de Máster -7- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Resumen
En el presente trabajo desarrollamos una nueva implementación en tarjetas
gráficas programables (GPUs) del algoritmo de clustering no supervisado K-Means,
evaluando las prestaciones de dicha implementación en la tarea de clasificar (de
forma no supervisada) imágenes de satélite disponibles en la herramienta Google
Maps. Dichas imágenes son obtenidas utilizando otra herramienta desarrollada por el
doctorando autor del presente trabajo. Con vistas a validar el nuevo algoritmo
desarrollado, se ha evaluado el consenso obtenido en la clasificación con respecto a
los resultados proporcionados por la implementación del algoritmo K-Means en
software comercial (Research Systems ENVI), obteniendo resultados muy similares
a los proporcionados por dicha herramienta en diferentes casos de estudio basados en
imágenes de satélite proporcionadas a partir de la herramienta Google Maps y
obtenidas en diferentes zonas geográficas de la superficie terrestre. Dicha validación
experimental revela que el algoritmo propuesto permite obtener resultados
prácticamente idénticos a otras implementaciones disponibles de K-Means [1], pero
en un tiempo mucho más rápido (en particular, la implementación paralela del
algoritmo propuesto (desarrollada utilizando el lenguaje CUDA de NVidia) en una
GPU de la gama NVidia Tesla C1060 obtiene un speedup por encima de 30 unidades
con respecto a la correspondiente versión serie optimizada, lo cual suponen un
importante aumento de las prestaciones computacionales del algoritmo que se
preveen indispensables a la hora de procesar grandes cantidades de datos de satélite
[2-4], tales como los disponibles en la herramienta Google Maps que se ha utilizado
en el presente trabajo para validar el algoritmo paralelo desarrollado.
Palabras clave:
K-Means, imágenes de satélite, GPU, CUDA, ENVI.
Trabajo Fin de Máster -8- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Abstract
In this work, we develop a new parallel implementation of the K-Means
unsupervised clustering algorithm for commodity graphic processing units (GPUs),
and further evaluate the performance of this newly developed algorithm in the task of
classifying (in unsupervised fashion) satellite imagery available from Google Maps
engine. Those images are obtained using a companion tool developed by the author
of this research work. With the ultimate goal of evaluating the classification
precision of the newly developed algorithm, we have analyzed the consensus or
agreement in the classification achieved by our implementation and an alternative
implementation of the algorithm available in commercial software (Research
Systems ENVI). Our experimental results, conducted using satellite images obtained
from Google Maps engine over different locations around the Earth, indicate that the
classification agreement between our parallel version and the ENVI implementation
of the K-Means algorithm is very high. In addition, the parallel version (developed
using the CUDA language available from NVidia) is much faster that the serial one
(more than 30x speedup), thus indicating that our proposed implementation can
significantly improve the computational performance of this clustering algorithm and
thus allows for larger scale processing of high-dimensional image databases such as
those available in the Google Maps engine used for validating the proposed GPU
implementation.
Keywords
K-Means, satellite imagery, GPU, CUDA, ENVI.
Trabajo Fin de Máster -9- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Índice de Contenido
1. MOTIVACIONES Y OBJETIVOS ................................................................................ 14
1.1. Motivaciones ................................................................................................................... 14
1.2. Objetivos .......................................................................................................................... 15
2. INTRODUCCIÓN ...................................................................................................... 18
2.1. Concepto de imagen de satélite ................................................................................. 18
2.2. Sensores de adquisición de imágenes multiespectrales ...................................... 20
2.3. Técnicas de clasificación de datos multiespectrales y la necesidad de
paralelismo ............................................................................................................................... 21
3. TARJETAS GRÁFICAS PROGRAMABLES GPUS ....................................................... 25
3.1. Las GPUs como un dispositivo de procesamiento de datos en paralelo ....... 25
3.2. CUDA: una nueva arquitectura para el cálculo en la GPU ............................... 31
3.3. Procesamiento en la GPU ........................................................................................... 34
3.4. Implementación hardware y modelo de ejecución. ............................................. 37
4. PROCESAMIENTO EN IMÁGENES. TIPOS DE CLASIFICACIONES: CLUSTERING ..... 44
4.1. Algoritmos de clasificación no supervisados ........................................................ 45
5. PROCESAMIENTO PARALELO EN GPU .................................................................. 48
5.1. Implementación CUDA ............................................................................................... 50
5.1.1. Primera etapa ......................................................................................... 51
5.1.2. Segunda etapa........................................................................................ 53
5.1.3. Tercera etapa ......................................................................................... 54
5.2. CUDA Occupancy Calculator ................................................................................... 55
6. RESULTADOS .......................................................................................................... 61
6.1. Ejemplo de uso 1: World Trade Center de New York ........................................ 63
6.2. Ejemplo de uso 2: El río Nilo africano .................................................................... 68
6.3. Ejemplo de uso 3: Población de Guareña y sus alrededores ............................. 73
7. CONCLUSIONES Y LÍNEAS FUTURAS ....................................................................... 78
8. ANEXO I: MANUAL DE CUDA ............................................................................ 80
8.1. Introducción .................................................................................................................... 80
8.2. Configuraciones necesarias ........................................................................................ 81
Trabajo Fin de Máster -10- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
8.3. Compilación programas CUDA. ............................................................................... 85
8.4. Librerías CUDA. ........................................................................................................... 86
8.5. Arquitectura y modelo de programación ................................................................ 87
8.6. Técnicas de Optimización........................................................................................... 94
8.7. Herramientas desarrollo y depuración. ................................................................... 99
9. BIBLIOGRAFÍA ...................................................................................................... 100
10. PUBLICACIONES ................................................................................................. 104
Índice de Figuras
Figura 2.1. El espectro electromagnético. .................................................................. 19
Figura 2.2. Ejemplo ilustrativo de una imagen multi-dimensional de 4 bandas. ....... 20
Figura 2.3. Configuración típica de un cluster Beowulf. ........................................... 23
Figura 2.4. Distintos modelos de GPUs NVidia. ....................................................... 24
Figura 2.5. Ejemplo de la Virtex-6 FPGA. ................................................................ 24
Figura 3.1. Operaciones en coma flotante por segundo para CPU y GPU. ............... 25
Figura 3.2. Ancho de banda CPU y GPU. ................................................................. 26
Figura 3.3. Pipeline clásico de procesamiento en una GPU. ..................................... 28
Figura 3.4. La GPU proporciona más transistores para el procesamiento de datos. .. 29
Figura 3.5. Pipeline clásico frente a pipeline unificado. ............................................ 32
Figura 3.6. Pila de software de CUDA. ..................................................................... 33
Figura 3.7. Operaciones de memoria Gather (reunión) y Scatter (dispersión). ......... 33
Figura 3.8. Shared memory. ....................................................................................... 34
Figura 3.9. Grid, bloques e hilos. ............................................................................... 36
Figura 3.10. Acceso a diferentes espacios de memoria. ............................................ 37
Figura 3.11. Arquitectura de la GPU Tesla c1060 de NVidia. .................................. 38
Figura 3.12. Conjunto de multiprocesadores SIMD con memoria compartida
on-chip........................................................................................................................ 39
Figura 4.1. Ejemplo gráfico del algoritmo K-Means. ................................................ 47
Figura 5.1. Ejemplo de reducción en tres pasos de una suma dado un cluster de
8 elementos................................................................................................................. 50
Trabajo Fin de Máster -11- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Figura 5.2. Cuda occupancy calculator ...................................................................... 56
Figura 5.3: Cuda occupancy calculator: gráfica asociada al número de hilos por
bloque. ........................................................................................................................ 58
Figura 5.4: Cuda occupancy calculator: gráfica asociada al número de registros por
hilo. ............................................................................................................................ 59
Figura 5.5: Cuda occupancy calculator: gráfica asociada a la cantidad de memoria
compartida usada por cada bloque ............................................................................. 60
Figura 6.1. Ejemplo de construcción de una matriz de confusión. ............................ 62
Figura 6.2. Ubicación del WTC de Nueva York, situado en las coordenadas:
40.713º, -74.0135º .................................................................................................... 63
Figura 6.3. Selección de una zona urbana perteneciente al WTC de Nueva York
(Estados Unidos) ........................................................................................................ 64
Figura 6.4. Segmentación de la zona seleccionada del WTC, utilizando el algoritmo
K-Means. .................................................................................................................... 64
Figura 6.5. Segmentación de la zona seleccionada de WTC (Nueva York) utilizando
el algoritmo K-Means con la herramienta ENVI. ...................................................... 65
Figura 6.6. Ubicación del río Nilo (África), situado en las coordenadas: 29.89º,
31.28º ......................................................................................................................... 68
Figura 6.7. Selección de un tramo perteneciente al río Nilo (África) ........................ 69
Figura 6.8. Segmentación de la zona seleccionada del río Nilo (África) utilizando el
algoritmo K-Means. ................................................................................................... 69
Figura 6.9. Segmentación de la zona seleccionada del río Nilo utilizando el algoritmo
K-Means con la herramienta ENVI............................................................................ 70
Figura 6.10. Ubicación del municipio de Guareña (Badajoz), situado en las
coordenadas: 38.85º, -6.083333º. ............................................................................... 73
Figura 6.11. Selección de una zona situada cerca de la población de Guareña de la
que escogeremos las zonas con vegetación. ............................................................... 73
Figura 6.12. Segmentación de la zona seleccionada situada cerca de la población de
Guareña utilizando el algoritmo K-Means. ................................................................ 74
Figura 6.13. Segmentación de la zona seleccionada situada cerca de la población de
Guareña utilizando el algoritmo K-Means con la herramienta ENVI. ....................... 74
Figura 8.1. Arquitectura paralela Cuda. ..................................................................... 85
Figura 8.2. Arquitectura heterogénea CPU + GPU. ................................................... 87
Figura 8.3. Ejemplos de dimensiones e identificadores. ............................................ 90
Trabajo Fin de Máster -12- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Figura 8.4. Ejemplo: traspuesta de una matriz utilizando memoria global. ............... 95
Figura 8.5. Ejemplo: traspuesta de una matriz utilizando memoria compartida. ....... 96
Índice de Tablas
Tabla 3.1. Lecturas y escrituras en los diferentes tipos de memoria.......................... 36
Tabla 3.2. Especificaciones técnicas de la GPU Tesla c1060 de NVidia. ................. 39
Tabla 3.3. Recursos y limitaciones según la GPU que utilicemos para programar
CUDA. ....................................................................................................................... 41
Tabla 3.4. Capacidad de cómputo y número de multiprocesadores de cada GPU de
NVidia. ....................................................................................................................... 43
Tabla 4.1. Ventajas e inconvenientes de la utilización del algoritmo K-Means. ....... 47
Tabla 5.1. Métricas utilizadas para calcular la similitud de características. .............. 49
Tabla 5.2: Cuda occupancy calculator: parámetros introducidos .............................. 57
Tabla 5.3: Cuda occupancy calculator: resultados calculados en función de los
parámetros .................................................................................................................. 57
Tabla 6.1. Resultados estadísticos tras la ejecución paralela del algoritmo de
clasificación no supervisado K-Means con la imagen del World Trade Center. ....... 66
Tabla 6.2. Comparación de resultados CPU y GPU utilizando la imagen del World
Trade Center ajustada según la dimensión. ................................................................ 67
Tabla 6.3. Resultados estadísticos tras la ejecución paralela del algoritmo de
clasificación no supervisado K-Means con la imagen del río Nilo. ........................... 71
Tabla 6.4. Comparación de resultados CPU y GPU utilizando la imagen del río Nilo
ajustada según la dimensión. ...................................................................................... 72
Tabla 6.5. Resultados estadísticos tras la ejecución paralela del algoritmo de
clasificación no supervisado K-Means con la imagen de Guareña. ........................... 76
Tabla 6.6. Comparación de resultados GPU y GPU utilizando la imagen de Guareña
ajustada según la dimensión. ...................................................................................... 76
Trabajo Fin de Máster -13- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
1. Motivaciones y objetivos
1.1. Motivaciones
El presente trabajo se ha desarrollado dentro de las líneas de investigación
actuales del Grupo Hypercomp de la Universidad de Extremadura, y consiste en la
implementación eficiente de un algoritmo de clasificación no supervisada en
imágenes multiespectrales, haciendo uso de GPUs de NVidia, aprovechando el
paralelismo intrínseco que ofrecen dichas tarjetas en operaciones de procesamiento
de imágenes. En concreto el algoritmo implementado es: K-Means. Las aplicaciones
potenciales de este algoritmo son múltiples, en donde destacamos su uso aplicado en
sistemas CBIR [5-7] donde se podría aplicar dicho algoritmo en clasificaciones de
imágenes obtenidas de grandes repositorios como es el caso de Google Maps.
Hasta la fecha, las técnicas tradicionales en la literatura para abordar este tipo de
problemas han optado por soluciones basadas en el uso de clusters y sistemas
multiprocesador. La computación cluster, a pesar de su adaptabilidad al problema del
tratamiento de datos multiespectrales (especialmente cuando tenemos imágenes con
una gran cantidad de datos), presenta problemas en cuanto al procesamiento de los
datos en tiempo real dado el alto coste y elevados requerimientos en cuanto a
espacio, peso y consumo. Por otra parte, la instalación de un cluster suele llevar
asociada la disponibilidad de un número elevado de ordenadores interconectados
entre sí para que compartan el procesamiento de datos a través de sus procesadores,
lo cual hace incrementar la velocidad de ejecución y procesamiento de las
aplicaciones; sin embargo, cada nodo (u ordenador) lleva ligado un precio y una serie
de requerimientos en cuanto a espacio y consumo.
Para solucionar estos problemas relativos a coste, consumo y peso, y además
ofrecer además mejoras sustanciales en cuanto al tiempo de procesamiento, en el
presente TFM proponemos una alternativa basada en un nuevo modelo de
tratamiento de imágenes multiespectrales basado en la utilización de GPUs.
Conviene destacar que, con una sola GPU, pueden llegar a obtenerse mejoras
notables a la hora de procesador cálculos de tipo científico, como es el caso de los
Trabajo Fin de Máster -14- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
algoritmos de tratamiento de imágenes multiespectrales, a un coste razonable (no
más de 400 euros) y además ocupando un espacio mínimo. No obstante, no todas las
tarjetas GPU disponibles en el mercado se ajustan a nuestros requerimientos. Por ello
si aplicamos los algoritmos propuestos a través de tarjetas convencionales o de gama
baja, veremos que los resultados no sufren ningún tipo de mejorías; es más, podemos
llegar a obtener peores resultados. Finalmente, indicar que en este trabajo se ha
intentado ir un poco más allá, y para trabajar de forma totalmente innovadora se ha
utilizado la arquitectura CUDA incorporada en las tarjetas gráficas de NVidia de las
series 8 (o superiores), Quadro y Tesla, siendo algunas de las tarjetas de la primera
gama las que han sido objeto de estudio en este TFM.
Para la realización de este trabajo se han utilizado las siguientes máquinas:
1) Procesador Intel Core i7 920 con una GPU NVidia Tesla c1060 y el sistema
operativo Linux Ubuntu 9.04.
2) Procesador Intel Core 2 Duo P8700 a 2.53Ghz con una GPU NVidia GeForce
9400M y el sistema operativo Windows 7.
Por otra parte, otra de las actividades desarrolladas en el presente trabajo
consiste en la realización de un estudio cuantitativo y comparativo del algoritmo
implementado tanto en C++ para su ejecución en la CPU como en CUDA para su
ejecución en la distintas GPUs así como un análisis de precisión de los resultados
obtenidos.
1.2. Objetivos
Este trabajo pretende desarrollar sobre una GPU la implementación de un
algoritmo de clasificación no supervisada en imágenes multiespectrales y establecer
un estudio cualitativo y comparativo de los resultados obtenidos tras la ejecución.
Concretamente el algoritmo es: K-Means.
La consecución del objetivo general anteriormente mencionado se lleva a cabo
en la presente memoria abordando una serie de objetivos específicos, los cuales se
enumeran a continuación:
Trabajo Fin de Máster -15- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
1. Establecer un estudio sobre el funcionamiento del algoritmo K-Means para
extraer el grado de paralelismo inherente que presenta y utilizarlo para su
implementación.
2. Realizar un estudio sobre el lenguaje de programación CUDA para poder
implementar cualquier tipo de algoritmos.
3. Implementar el algoritmo K-Means para ejecutarlo en la GPU y optimizar el
tiempo de ejecución, para poderlo comparar con su tiempo en serie ya
implantado en una herramienta que realiza clasificaciones no supervisadas y
supervisadas en imágenes de satélite obtenidas desde Google Maps.
4. Implementar una serie de aplicaciones que nos permitan conocer la precisión
que se ha logrado en la ejecución del algoritmo con su versión serie de la
herramienta ya implementada.
5. Realizar un estudio comparativo sobre los resultados obtenidos.
Teniendo presentes los anteriores objetivos concretos, procedemos a describir la
organización del resto de esta memoria, estructurada en una serie de capítulos cuyos
contenidos se describen a continuación:
• Introducción. En este capítulo introductorio se describen los conceptos
fundamentales relacionados con las imágenes de satélite, sensores de
adquisición de este tipo de imágenes y las técnicas de clasificación de datos
multiespectrales, enfatizando la necesidad de técnicas de procesamiento
paralelo en este campo y proponiendo la utilización de las GPUs como
procesador paralelo para este tipo de técnicas.
• Tarjetas gráficas programables GPUs. Este capítulo está dedicado a la
GPU, donde se hablará de cómo han ido evolucionando las GPUs
programables, de los recursos que ofrecen y su capacidad de cómputo.
Introduciremos una serie de conceptos para lograr entender cómo se lleva a
cabo el procesamiento en una GPU mediante CUDA. Este capítulo también
describirá el hardware de la tarjeta Tesla c1060 con la que se ha realizado el
Trabajo Fin de Máster -16- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
trabajo.
• Procesamiento en imágenes. Este capítulo describe y muestra la utilidad del
algoritmo implementado para el análisis multiespectral así como su
funcionamiento y filosofía.
• Procesamiento paralelo en GPU. En este capítulo se muestra como se lleva
a cabo el procesamiento paralelo en la GPU para el caso que nos ocupa,
centrándonos en cada una de las fases del algoritmo por separado.
• Resultados. En este capítulo se describen las imágenes que se han utilizado
para probar el algoritmo, se muestran los resultados de la precisión obtenida
con la versión paralela y finalmente se comparan estos resultados con los
obtenidos por otras herramientas de referencia como es el caso de ENVI.
• Conclusiones y líneas futuras. Este capítulo está dedicado a resumir las
principales aportaciones realizadas por la presente memoria y a mostrar las
conclusiones derivadas. Además, el capítulo sugiere un conjunto de líneas de
trabajo que podrán ser abordadas en futuros trabajos.
• ANEXOS. En este capítulo se expone una guía básica para poner en marcha
una tarjeta gráfica programable, además de unas nociones básicas sobre las
técnicas que podrán ser utilizadas en una programación con CUDA. También
se comentarán una serie de técnicas de optimización y las herramientas de
desarrollo y de depuración más utilizadas. La memoria concluye con una
serie de referencias bibliográficas utilizadas en el estudio.
Trabajo Fin de Máster -17- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
2. Introducción
El presente capítulo se organiza de la siguiente forma: en primer lugar,
empezaremos por la descripción del concepto de imagen multiespectral, más
concretamente de imágenes de satélite, detallando las particularidades y
características propias de este tipo de imágenes. A continuación, describimos algunas
características genéricas de los sensores de adquisición de este tipo de datos,
destacando los utilizados por el servidor de mapas Google Maps. Seguidamente, se
muestra una visión general de las técnicas de clasificación de imágenes, destacando
la necesidad de paralelismo en este campo y mostrando el papel de las GPU para su
tratamiento.
2.1. Concepto de imagen de satélite
Una imagen de satélite 1 se puede definir como una representación visual de la
información capturada por un sensor montado en un satélite artificial [8]. Estos
sensores tienen como cometido recoger información reflejada por la superficie de la
tierra que luego será enviada a la Tierra para que en un posterior procesado, se
obtenga información sobre las características de la zona representada. Casi todas las
imágenes procedentes de satélite se adquieren digitalmente. Dada su naturaleza
digital, las imágenes satelitales se procesan, manipulan y realzan para extraer de ellas
sutiles detalles e informaciones que otras fuentes no detectarían.
La observación remota de un determinado objeto está basada en la captación, por
parte de un instrumento de medida o sensor [9], de la radiación electromagnética
proveniente de la interacción entre el objeto y la fuente de la radiación. La radiación
electromagnética recibe varios nombres dependiendo de la longitud de onda que la
caracteriza, como puede apreciarse en la figura 2.1.
Para medir la radiación emitida o reflejada por una determinada superficie es
preciso cuantificar la cantidad de flujo energético que procede de la misma. Para ello
1 http://es.wikipedia.org/wiki/Imagen_satelital
Trabajo Fin de Máster -18- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
se suele utilizar la medida de la radiancia, que dependerá de varios factores como son
la percepción de brillo, reflectancia, ángulos de observación, entre otros.
En la actualidad nos podemos encontrar con un amplio conjunto de instrumentos
o sensores, cuya disponibilidad ha facilitado una redefinición del concepto de imagen
digital a través de la extensión de la idea de píxel.
Rayos γ
Figura 2.1. El espectro electromagnético.
Recordamos que el valor asociado a cada píxel viene definido por un valor
numérico denominado nivel digital (ND). Se denomina de esta manera por tratarse de
un valor numérico, no visual. Así, en un esquema puramente espacial, un píxel estará
constituido por un único valor discreto, mientras que, en un esquema espectral, un
píxel constará de un conjunto de valores. Estos valores dependiendo del tipo de
imagen podrán ser entendidos como vectores N-dimensionales [10], siendo N el
número de bandas espectrales en las que el sensor mide información (en nuestro caso
utilizaremos 4 dimensiones).
0.4 µm 0.7 µm
Rayos X
Visible
Ultravioleta Infrarrojo
10-7 10-5 10-3 10 103 105 103 10-1 Longitud de onda (µm)
Microondas
Radar
La ampliación del concepto de píxel ha dado lugar a lo que se conoce como
imagen multidimensional, como aparece en la figura 2.2. Así dependiendo del orden
Trabajo Fin de Máster -19- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
de magnitud de N podremos realizar una distinción a la hora de hablar de imágenes
multidimensionales. De esta manera, cuando el valor de N sea reducido, es decir,
unas cuantas de bandas espectrales [11], , estaremos hablando de imágenes
multiespectrales.
Figura 2.2. Ejemplo ilustrativo de una imagen multi multi-dimensional dimensional de 4 bandas.
2.2. Sensores de adquisición de imágenes multiespectrales
En este apartado comentaremos brevemente algunos aspectos sobre los sensores
de adquisición de imágenes multiespectrales. Dentro de las características más
importantes de los sensores multiespectrales, destacamos la resolución del sensor, el
proceso de adquisición de da datos y la relación señal-ruido [8].
Dentro del concepto de resolución nos podemos encontrar con diferentes
aspectos, entre los que se encuentran la resolución espacial, y las resoluciones
espectral (número de canales espectrales en los que el sensor adquiere datos y la
anchura de las bandas espectrales correspondientes a dichos canales) y radiom radiométrica
(relacionado con la sensibilidad del sensor).
Otro aspecto importante en los sensores, es el procedimiento de adquisición de
datos, entendiendo éste como el procedimiento empleado por estos instrumentos para
recibir la radiación procedente de los ob objetos. jetos. Los sensores pueden ser clasificados
Trabajo Fin de Máster -20- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
según su funcionamiento y según el modo en que son transportados en el momento
de la toma de datos.
Por último, destacar el parámetro de relación señal/ruido o signal-to-noise ratio
(SNR), que puede entenderse, en términos globales, como la relación entre la
amplitud de la señal obtenida y la amplitud del ruido o, lo que es lo mismo, la
cantidad de señal adquirida por unidad de ruido. Este parámetro nos definirá la
calidad de un sensor multiespectral. En términos generales, las imágenes disponibles
en la herramienta Google Maps suelen obtenerse a partir de la composición de
imágenes obtenidas por diferentes sensores, predominando las composiciones
basadas en datos de Landsat 2 (moderada resolución espacial) y Quickbird 3 (alta
resolución espacial) en un contexto multiespectral limitado a 3 bandas (rojo, verde y
azul).
2.3. Técnicas de clasificación de datos multiespectrales y la necesidad de
paralelismo
La forma más simple de abordar el problema de la clasificación de píxeles en
una imagen multiespectral es considerar que los píxeles de interés están compuestos
por un solo material, utilizando las técnicas convencionales de clasificación de
patrones pero con mayor precisión, debido al elevado número de bandas espectrales
disponibles.
Existe un conjunto de técnicas de clasificación de patrones que realizan la
interpretación de una escena obtenida de forma remota en base a la asignación de una
etiqueta o clasificación individual a cada uno de los píxeles de la misma. Estas
técnicas ofrecen resultados interesantes dependiendo de la aplicación en donde se
apliquen.
Los algoritmos de clasificación de imágenes multiespectrales pueden dividirse
en dos grandes categorías [12]: algoritmos supervisados y algoritmos no
supervisados.
2 http://landsat.gsfc.nasa.gov/
3 http://www.digitalglobe.com/
Trabajo Fin de Máster -21- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Las técnicas de clasificación de píxeles de forma no supervisada en imágenes
multiespectrales se encuentran en plena fase de desarrollo. Entre las técnicas
existentes, destaca el método K-Means [13], que supone la existencia de K clases
(parámetro que debe ser determinado a priori) y realiza una agrupación de los píxeles
de la imagen en dichas clases utilizando los vectores métodos puramente estadísticos
basados en los valores RGBA promedio de dichas clases.
Por otra parte, el método ISODATA [14,15] también requiere la inicialización
de un parámetro K relativo al número de clases deseadas, de forma previa a la
ejecución del algoritmo. Además, este método necesita información relativa al
número mínimo de píxeles pertenecientes a una clase. Si el valor inicial de K es bajo,
la dispersión entre clases diferentes puede ser muy alta. Por el contario, si el valor
inicial de K es alto, la distancia entre clases puede ser muy pequeña, provocando el
particionamiento de una misma clase en varias clases similares entre sí. En general,
la literatura reciente no demuestra que los resultados obtenidos por estas dos técnicas
hayan sido demasiado satisfactorios, salvo en aplicaciones muy concretas [16,17].
Dentro de las técnicas de clasificación supervisadas, destacamos varios
clasificadores como son las técnicas nearest neighbour (vecino más cercano),
minimum distance (distancia mínima), parallelepiped o maximum likelihood (ML,
máxima probabilidad). Además también nos podría interesar la utilización de la
técnica Support Vector Machine (SVM) la cual ha demostrado excelentes
prestaciones a la hora de trabajar con datos altamente dimensionales.
No obstante, si a las técnicas descritas anteriormente les añadimos un conjunto
de datos bastante elevado, los resultados de utilizar algoritmos en serie serían
altamente costosos desde el punto de vista computacional. Por lo tanto, a
continuación mostraremos énfasis en la necesidad de técnicas paralelas para
optimizar su rendimiento computacional.
Necesidad de paralelismo
Conviene destacar que las técnicas de clasificación en imágenes multiespectrales
anteriormente descritas se basan en la realización de operaciones matriciales que
resultan muy costosas desde el punto de vista computacional. Sin embargo, el
Trabajo Fin de Máster -22- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
carácter repetitivo de estas operaciones las hace altamente susceptibles de ser
implementadas en diferentes tipos de arquitecturas paralelas, permitiendo así un
incremento significativo de su rendimiento en términos computacionales y dotando a
dichas técnicas de la capacidad de producir una respuesta rápida. Esta tarea es clave
para la explotación de dichas técnicas en aplicaciones que requieren una respuesta en
tiempo casi real.
Las técnicas de computación paralela han sido ampliamente utilizadas para
llevar a cabo tareas de procesamiento de imágenes de gran dimensionalidad,
facilitando la obtención de tiempos de repuesta muy reducidos y pudiendo utilizar
diferentes tipos de arquitecturas [18-20]. En la actualidad, es posible obtener
arquitecturas paralelas de bajo coste mediante la utilización de GPUs de última
generación que cuentan con múltiples procesadores.
El papel de las GPUs
Las técnicas de clasificación de imágenes multiespectrales, en nuestro caso, el
algoritmo de clasificación no supervisado K-Means aplicado sobre imágenes de
satélite extraídas desde Google Maps muestra desde un punto de vista computacional
un patrón de acceso a los datos regular y por tanto un paralelismo inherente a muchos
niveles, como por ejemplo, a nivel de vectores de píxeles. Como resultado se asocian
con sistemas paralelos compuestos por CPUs (por ejemplo clusters Beowulf, ver
figura 2.3). Desafortunadamente estos sistemas son caros y difíciles de adaptar a
bordo de escenarios de procesamiento de sensación remota.
Figura 2.3. Configuración típica de un cluster Beowulf.
Trabajo Fin de Máster -23- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Un nuevo desarrollo en el campo de la computación surge con los procesadores
gráficos programables (GPUs, ver figura 2.4). Guiadas por la creciente demanda de
la industria de los videojuegos, las GPUs han evolucionado como sistemas
programables altamente paralelos. Sin embargo la arquitectura de las GPUs no
encaja necesariamente con todos los tipos de computación paralela.
Figura 2.4. Distintos modelos de GPUs NVidia.
En especial, el siempre creciente requerimiento computacional introducido por
el estado actual de los algoritmos de imágenes multiespectrales pueden beneficiarse
de este hardware y tomar ventaja de su poco peso y bajo coste de sus unidades, lo
que lo hace llamativo para el procesamiento de datos a bordo por un coste mucho
más bajo del que tienen otros dispositivos hardware como las FPGAs [21] (ver figura
2.5).
Figura 2.5. Ejemplo de la Virtex-6 FPGA.
Trabajo Fin de Máster -24- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
3. Tarjetas gráficas programables GPUs
En este capítulo hablamos de cómo han ido evolucionando las GPUs
programables, de los recursos que ofrecen y de su gran capacidad de cómputo.
Introduciremos una serie de conceptos para lograr entender cómo se lleva a cabo el
procesamiento en una GPU mediante lenguaje CUDA. Describiremos el hardware de
la tarjeta Tesla c1060 1060 con la que se ha realizado el trabajo y finalmente trataremos el
lenguaje CUDA en sí dando unas nociones básicas para llevar a cabo cualquier
proyecto con este lenguaje.
3.1. Las GPUs como un dispositivo de procesamiento de datos en paralelo
Desde un tiempo o a esta parte, las GPUs programables han evolucionado como
un elemento con una carga de trabajo, como podemos apreciar en las figuras 3.1 y
3.2, donde se muestra una comparativa de la evolución de la capacidad de cómputo y
del ancho de banda de las CPUs y las GPUs. Con múltiples núcleos y con un gran
ancho de banda de memoria, hoy por hoy las GPUs ofrecen prestaciones muy
elevadas para el proce procesamiento gráfico y científico [22 – 25].
Figura 3.1. Operaciones en coma flotante por segundo para CPU y GPU.
Trabajo Fin de Máster -25- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
Antes de continuar en más detalle con la arquitectura de una GPU Tesla c1060
de NVIDIA 4 , consideramos relevante explicar cómo han funcionado las operaciones
en un pipeline de una GPU clásica a lo largo de los años. No obstante, para entender
este proceso, también debemos introducir los conceptos de vertex shaders y los p ppíxel
shaders.
Vertex rtex shaders y píxel shaders
A través de los shaders nos podemos encargar del procesamiento de v vvértices
(vertex shaders) y de píx píxeles (píxel íxel shaders), cuya principal ventaja es que pueden
ser programados por el desarrollador. Es una tecnología reciente y que ha
experimentado una gran evolución destinada a proporcionar al programador una
interacción con la GPU hasta ahora imposible. Con los shaders, se podrán conseguir
muchos de los efectos que antes eran impensables por la cantidad de carga que
conllevaba. Actualmente se utilizan para realizar transformaciones y crear efectos
especiales, como por ejemplo iluminación, fuego o niebla. Para su programación los
shaders utilizan lenguajes específicos de alto nivel que permiten la independencia del
hardware.
4 http://www.nvidia.com
Figura 3.2. Ancho de banda CPU y GPU.
Trabajo Fin de Máster -26- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Un vertex shader es una función que recibe como parámetro un vértice. Sólo
trabaja con un vértice a la vez, y no puede eliminarlo, sólo transformarlo. Para ello,
modifica propiedades del mismo para que repercutan en la geometría del objeto al
que pertenece. Con esto se pueden lograr ciertos efectos específicos, como los que
tienen que ver con la deformación en tiempo real de un elemento; por ejemplo, el
movimiento de una ola. Donde toma una gran importancia es en el tratamiento de las
superficies curvas.
En cambio, un píxel shader básicamente especifica el color de un píxel. Este
tratamiento individual de los píxeles permite que se realicen cálculos principalmente
relacionados con la iluminación del elemento del cual forman parte en la escena, y en
tiempo real.
La incorporación de los píxel shaders y vertex shaders permite a los
programadores una mayor libertad a la hora de diseñar gráficos en tres dimensiones,
ya que puede tratarse a cada píxel y cada vértice por separado. De esta manera, los
efectos especiales y de iluminación pueden crearse mucho más detalladamente,
sucediendo lo mismo con la geometría de los objetos.
Pipeline clásico de procesamiento en una GPU
Cuando revisamos las arquitecturas hardware, el flujo de datos, y las operaciones
pipeline, a menudo es bueno empezar por el nivel más alto, donde los datos llegan
desde la CPU a la GPU, y el proceso se desarrolla hacia abajo a través de múltiples
fases de procesamiento hasta que un píxel es dibujado definitivamente en la pantalla.
Para situarnos, las GPUs han utilizado diseños pipeline tradicionales, como los que
aparecen ilustrados en la figura 3.3.
Después que la GPU recibe los datos vertex (vértices) desde el host (CPU), la
fase vertex se ejecuta en primer lugar. La función de fijado transforma la imagen y el
hardware de luminosidad operado en esta fase se lleva a cabo; entonces los píxeles
shaders programables, y el control de flujo dinámico de los modelos shaders entran
en juego. El siguiente paso en el pipeline clásico es la configuración, donde los
vértices son ensamblados dentro de primitivas como triángulos, líneas o puntos. Las
primitivas son convertidas por la fase de “rasterización” en fragmentos de píxeles (o
Trabajo Fin de Máster -27- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
simplemente fragmentos), pero no son considerados píxeles completos en esta fase.
Los fragmentos están sometidos a muchas otras operaciones como sombreado,
Z-testing, la posible mezcla en el buffer frame, y el antialiasing. Los fragmentos son
finalmente considerados píxeles cuando han sido escritos en el buffer frame.
Figura 3.3. Pipeline clásico de procesamiento en una GPU.
A continuación, la siguiente fase es la de píxel shader, que debería ser
denominada técnicamente como fase fragment shader, pero utilizamos la notación
estándar en la literatura [22 – 25] debido a su aceptación. En el pasado, los
fragmentos sólo podían haber tenido valores de color aplicados de textura simple.
Hoy en día, la capacidad de sombreado de un píxel programado de la GPU permite
numerosos efectos de sombreado para ser aplicados mientras se trabaja de acuerdo
con métodos complejos de multitextura. Específicamente, los fragmentos
sombreados (con color y valores Z) desde esta fase píxel son enviados al ROP
(Raster Operations). La fase ROP es donde se chequea el buffer Z para asegurar que
sólo los fragmentos visibles son procesados rápidamente, y los fragmentos visibles,
si son parcialmente transparentes, son mezclados con el buffer de frame existente,
junto con los píxeles y aplicándoles antialiased. El píxel procesado final es enviado a
la memoria buffer para ser escaneado y visualizado en el monitor [22].
Evolución del uso de GPUs en aplicaciones científicas
La principal razón que justifica la gran popularidad de las arquitecturas GPU en
Trabajo Fin de Máster -28- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
aplicaciones científicas es el hecho de que la GPU está especializada para cómputo
intensivo, computación paralela elevada (exactamente sobre lo que trata el
renderizado de gráficos) y por tanto se designan más transistores dedicados al
procesamiento de datos, que a la recolección de datos y control de flujo como se
muestra en la figura 3.4.
Figura 3.4. La GPU proporciona más transistores para el procesamiento de datos.
Más específicamente, la GPU está especialmente pensada para direccionar
problemas que pueden ser expresados como computaciones de datos paralelos (el
mismo programa es ejecutado en muchos elementos de datos en paralelo) con gran
intensidad aritmética (el ratio de operaciones aritméticas respecto a operaciones de
memoria). Como el mismo programa es ejecutado para cada elemento de datos, hay
menos requisitos para un flujo de control sofisticado; y como es ejecutado en muchos
elementos de datos y tiene gran intensidad aritmética, la latencia de acceso a
memoria puede ser ocultada con cálculos, en vez de datos muy grandes de caché
[23].
El procesamiento de datos paralelos asocia los datos a elementos de proceso
paralelos. Muchas aplicaciones que procesan grandes conjuntos de datos como arrays
pueden usar un modelo de programación de datos paralelos para acelerar los
cálculos. En renderizado 3D los conjuntos de píxeles y vértices se asignan a hilos
paralelos. De la misma manera, aplicaciones de procesamiento de imágenes y
multimedia como postprocesado de imágenes renderizadas, codificación y
decodificación de vídeo, escalado de imágenes, visión estéreo, y patrones de
reconocimiento pueden asociar bloques de la imagen y píxeles a hilos de
Trabajo Fin de Máster -29- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
procesamiento paralelo. De hecho, muchos algoritmos fuera del campo del
renderizado como el procesamiento de señales, simulaciones físicas finanzas o
biología, se aceleran con el procesamiento de datos en paralelo.
Hasta la fecha, sin embargo, a pesar de acceder a todo el poder de computación
contenido en la GPU y usarlo eficientemente para aplicaciones científicas, seguía
siendo difícil obtener las siguientes pautas:
• La GPU solamente podía ser programada a través de la API (Application
Programming Interface) gráfica; esto provocaba que la curva de aprendizaje
para un desarrollador principiante fuese muy elevada, ya que tenía que
trabajar con una API inadecuada, que no estaba adaptada a la aplicación
científica.
• La DRAM de la GPU podía ser leída de manera general (los programas de
GPU pueden obtener elementos de datos de cualquier parte de la DRAM)
pero no se podía escribir de manera general (los programas de GPU no
pueden esparcir la información a cualquier parte de la DRAM), eliminando
mucha de la flexibilidad de programación ya disponible en la CPU.
• Algunas aplicaciones tenían en problema del “cuello de botella”, debido al
ancho de banda de la memoria DRAM, utilizando escasamente el poder
computacional de la GPU.
En este sentido, una de las principales motivaciones del presente TFM es
demostrar que dichas limitaciones en la actualidad pueden superarse mediante la
utilización de la arquitectura CUDA para procesamiento de datos científicos en la
GPU. Dicho aspecto será abordado en detalle en el siguiente subapartado del
presente capítulo de la memoria.
Trabajo Fin de Máster -30- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
3.2. CUDA: una nueva arquitectura para el cálculo en la GPU
CUDA viene del inglés Compute Unified Device Architecture y es una nueva
arquitectura hardware y software, diseñada para dar y manejar procesamientos en la
GPU como un elemento de computación de datos paralelos sin la necesidad de
mapearlos a una API de gráficos. Está disponible para las versiones GeForce 8
Series, Quadro FX 5600/4600, Tesla y Fermi. El mecanismo de multitarea del
sistema operativo es responsable de manejar el acceso a la GPU mediante CUDA, y
las aplicaciones gráficas funcionan de forma simultánea. A continuación describimos
el pipeline unificado del que disponen las actuales GPUs de NVIDIA y que puede ser
explotado de forma eficiente mediante CUDA, así como la arquitectura completa de
la Tesla C1060. El apartado finaliza describiendo los diferentes modelos de
programación en CUDA.
Pipeline unificado
A partir del modelo de pipeline clásico, con sus flujos de datos empezando en lo
más alto, donde los vértices con varios atributos, índices, comandos, y texturas son
pasados a la GPU desde la CPU. Las fases de procesamiento mayores siguen una
manera lineal segura incluyendo vertex shading, píxel shading, operaciones raster,
(que son operaciones a través de las cuales un área espacial queda dividida en celdas
regulares, en las que cada una de las cuales presentan unos atributos o valor, como
pueden ser la altitud, reflectancia, etc.) y escritura de píxeles en el buffer frame.
Con este pipeline unificado y la arquitectura “shader”, el diseño de la GPU Tesla
c1060 reduce significativamente el número de fases del pipeline y cambia el flujo
secuencial para estar más orientado a bucle. Las entradas son alimentadas en la parte
alta del núcleo shader unificado, y las salidas son escritas en registros y entonces
vuelven otra vez a la parte alta del núcleo shader para la próxima operación. Como
resultado, en el diagrama GPU unificado generalizado que se muestra en la
figura 3.5, los flujos de datos bajan secuencialmente por el pipeline a través de
diferentes tipos “shader”. La figura de la derecha representa un núcleo “shader”
unificado con uno o más procesadores “shader” unificados estandarizados.
Trabajo Fin de Máster -31- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Figura 3.5. Pipeline clásico frente a pipeline unificado.
Como puede apreciarse en la figura 3.5, los datos vienen de la parte superior
izquierda del diseño unificado (como vértices), y son llevados al núcleo shader para
su procesamiento, y los resultados son enviados de vuelta a la parte superior del
núcleo shader, donde son llevados otra vez, procesados otra vez, mandados de vuelta
a la parte superior, y así hasta que todas las operaciones shader son ejecutadas y el
fragmento de píxel se pasa al subsistema ROP [22].
Modelo de programación CUDA
Antes de profundizar en el modelo de programación empleado por CUDA,
destacamos que la pila del software de CUDA se compone de varias capas, tal y
como muestra la figura 3.6. En concreto, dichas capas son un controlador de
hardware, una API y su runtime, y dos librerías matemáticas de alto nivel para uso
común, CUFFT y CUBLAS. El hardware ha sido diseñado para soportar
controladores ligeros y capas runtime, dando como resultado una ejecución óptima.
En este sentido, la API de CUDA es una extensión del lenguaje de programación C,
lo cual hace que tenga una curva de aprendizaje mínima.
Trabajo Fin de Máster -32- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Figura 3.6. Pila de software de CUDA.
Por otra parte, CUDA ofrece un direccionamiento de carácter general para la
memoria DRAM como ilustra la figura 3.7. Este modelo de direccionamiento
permite obtener mayor flexibilidad en la programación, en el sentido de que ofrece
tanto la operación de reparto de datos como la de obtención de estos. Desde una
perspectiva de programación, esto se traduce en la habilidad de leer y escribir datos
en cualquier lugar de la DRAM, exactamente igual que en la CPU [23].
Figura 3.7. Operaciones de memoria Gather (reunión) y Scatter (dispersión).
Trabajo Fin de Máster -33- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
CUDA proporciona una memoria compartida on-chip a modo de caché de datos
que permite accesos muy rápidos de lectura y de escritura. Mediante ésta los hilos
pueden compartir datos. Como se muestra en la figura 3.8, las aplicaciones pueden
beneficiarse de esta memoria minimizando los accesos a memoria DRAM lo que les
hace menos dependientes del ancho de banda de la DRAM que es mucho menor que
el de la shared memory.
3.3. Procesamiento en la GPU
Figura 3.8. Shared memory.
En la siguiente sección presenta a la GPU como un coprocesador multihilo para
la CPU, seguidamente se exponen los diferentes mecanismos de los que se hace uso
para llevar a cabo el procesamiento en la GPU, estos son los hilos de ejecución, los
bloques en los que se organizan estos hilos y los llamados grid en los que se
estructuran estos bloques. La sección finaliza con el modelo de memoria utilizado
por CUDA.
Un coprocesador multihilo
Cuando se programa con CUDA, la GPU se ve como un dispositivo de cálculo
(device) capaz de ejecutar un gran número de hilos en paralelo. Éste opera como un
Trabajo Fin de Máster -34- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
coprocesador de la CPU principal, o host. En otras palabras, los datos paralelos,
cálculo intensivo de porciones de aplicaciones ejecutándose en el host son cargados
en el device. De forma más precisa, una parte de una aplicación que se ejecuta
muchas veces, pero con datos diferentes e independientes, puede ser aislada en una
función que es ejecutada en el device como muchos hilos independientes. Como
dicha función es compilada, la instrucción obtenida a partir del device (en nuestro
caso, la GPU) y el programa resultante, llamado kernel, se descargan en el device.
Tanto el host como el device mantienen su propia DRAM, referidas como memoria
del host y memoria del device respectivamente. Una puede copiar datos de una
memoria a la otra a través de llamadas a una API optimizada, que usa el Acceso
Directo a Memoria (DMA) del device [23].
Hilos, Bloques y Grids
El tratamiento por lotes de los hilos que ejecuta el kernel está organizado como
un grid de bloques de hilos, ilustrado en la figura 3.9. Un bloque de hilos es un lote
de hilos que pueden cooperar juntos compartiendo datos eficientemente a través de la
memoria compartida y sincronizar sus ejecuciones para coordinar los accesos a
memoria. De forma precisa, uno puede especificar puntos de sincronización en el
kernel, donde los hilos en un bloque están suspendidos hasta que todos ellos alcancen
el punto de sincronización. Cada hilo es identificado por su identificador de hilo
(thread ID), que es el número de hilo dentro de un bloque [23].
Hay un número máximo de hilos que un bloque puede contener (512 hilos
concretamente). Sin embargo, los bloques de misma dimensión y tamaño que
ejecutan el mismo kernel pueden ser tratados por lotes de forma conjunta, en un grid
de bloques, así que el número total de hilos puede ser lanzado en una única
invocación del kernel es mucho más grande. Esto se debe al gasto de reducir la
cooperación entre hilos, porque los hilos en diferentes bloques del mismo grid no
pueden comunicarse ni sincronizarse con los de los demás. Este modelo permite a los
kernels ejecutarse eficientemente sin recompilación en varios devices con diferentes
capacidades paralelas: un device puede ejecutar todos los bloques de un grid
secuencialmente si tiene poca capacidad, o en paralelo si tiene mucha, o
Trabajo Fin de Máster -35- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
normalmente una combinación de ambas [23]. La figura 3.9 muestra como cada
kernel se ejecuta como un grid de bloques de hilos.
Modelo de memoria
Figura 3.9. Grid, bloques e hilos.
Un hilo que se ejecute en el device tiene solo acceso a la DRAM del device y a
la memoria on-chip a través de los siguientes espacios de memoria (ver tabla 3.1)
[23], como se muestra en la figura 3.10.
Registro
de hilo
Memoria
compartida
de bloque
Memoria
local de
hilo
Memoria
global de
grid
Memoria
constante
de grid
Memoria
de texturas
de grid
Lectura ✓ ✓ ✓ ✓ ✓ ✓
Escritura ✓ ✓ ✓ ✓ × ×
Tabla 3.1. Lecturas y escrituras en los diferentes tipos de memoria.
Trabajo Fin de Máster -36- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Los espacios de memoria global, constante y de textura pueden ser leídos o
escritos por el host y perduran durante las distintas ejecuciones del kernel en la
misma aplicación. Estos espacios se optimizan para diferentes usos de la memoria.
Además la memoria de texturas ofrece diferentes modos de direccionamiento, así
como de filtrado de datos, para diferentes formatos de datos.
Figura 3.10. Acceso a diferentes espacios de memoria.
3.4. Implementación hardware y modelo de ejecución.
En esta sección se presenta la arquitectura hardware de la GPU utilizada en el
trabajo y se explica el modelo de ejecución que sigue CUDA.
NVidia Tesla c1060
A lo largo de la presente memoria hemos cubierto muchos de los puntos básicos
de la programación de GPUs de NVidia, así que ahora podemos echar un vistazo a
los aspectos específicos de la arquitectura Tesla c1060 [22], la tarjeta que estamos
Trabajo Fin de Máster -37- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
usando para realizar este TFM. La figura 3.11 describe la arquitectura hardware de
dicha tarjeta. El significado de las siglas que aparecen en el esquema es el siguiente:
TPC (Texture/Processor Cluster), SM (Streaming Multiprocessor), SP (Streaming
Processor), Tex (Texture), ROP (Raster Operation Processor).
Figura 3.11. Arquitectura de la GPU Tesla c1060 de NVidia.
A continuación la tabla 3.2 muestra las características técnicas de la GPU:
Specification Description
Form Factor 10.5” x 4.376”, Dual Slot
# of Streaming Processor Cores 240
Frequency of Processor cores 1.3 GHz
Single Precision floating point performance (peak) 933
Double Precision floating point performance (peak) 78
Floating Point Precision IEEE 754 single & double
Total Dedicated Memory 4 GDDR3
Memory Speed 800 MHz
Memory Interface 512-bit
Memory Bandwidth 102 GB/sec
Max Power Consumption 187.8 W
System Interface PCIe x16
Trabajo Fin de Máster -38- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Auxiliary Power Connectors
6-pin & 8-pin
Thermal Solution Active fan sink
Tabla 3.2. Especificaciones técnicas de la GPU Tesla c1060 de NVidia.
Modelo de ejecución
La GPU se implementa como un conjunto de multiprocesadores como se puede
ver en la figura 3.12. Cada multiprocesador tiene una arquitectura SIMD: en cada
ciclo de reloj, cada procesador del multiprocesador ejecuta la misma instrucción,
pero opera en datos distintos. Los espacios de memoria local y global son
implementados como regiones de la memoria del device. Cada procesador tiene
acceso a la memoria compartida del multiprocesador en el que está integrado. Cada
multiprocesador accede a la cache de textura mediante una unidad de textura que
implementa los diferentes modos de direccionamiento y filtros de datos [23].
Figura 3.12. Conjunto de multiprocesadores SIMD con memoria compartida on-chip.
Trabajo Fin de Máster -39- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Un grid de bloques de hilos se ejecuta en el device mediante la programación de
los bloques en cada multiprocesador. Cada multiprocesador procesa los bloques por
lotes, un lote tras otro. Un bloque solo se procesa en un multiprocesador, así el
espacio de memoria compartida reside en la memoria on-chip compartida por lo que
se puede beneficiar de la velocidad que proporciona dicha memoria.
El número de bloques que cada multiprocesador puede procesar en un lote
depende de cuantos registros necesita cada hilo y de cuanta memoria compartida
necesita cada bloque en un kernel ya que estos recursos se deben compartir entre
todos los hilos de los bloques del lote. Si no hay una cantidad suficiente de registros
o de memoria compartida disponible en un multiprocesador para procesar al menos
un bloque, el kernel fallará en su ejecución.
Los bloques que se procesan en un multiprocesador en un lote se llaman activos.
Cada bloque activo se divide en grupos de hilos SIMD llamados warps. Cada uno de
estos warps contiene el mismo número de hilos, este número se llama warp size, y se
ejecuta en un multiprocesador en modo SIMD. Los warps activos (los warps de los
bloques activos) se dividen en el tiempo: un programador de hilos cambia de un warp
a otro para maximizar el uso de recursos computacionales del multiprocesador. Se
llama half warp a la primera o a la segunda mitad de un warp.
La forma en la que un bloque se divide en warps es siempre la misma; cada warp
contiene hilos consecutivos, incrementando sus identificadores de hilo (thread ID).
El primer warp contiene al hilo 0.
El orden de emisión de los warps de un bloque no está definido y no existe un
mecanismo de sincronización entre bloques para coordinar los accesos a memoria
global o compartida.
El orden de emisión de los bloques en un grid de bloques de hilos tampoco está
definido y no hay un mecanismo de sincronización entre bloques, así que los hilos de
dos bloques diferentes pertenecientes al mismo grid no se pueden comunicar de una
forma segura a través de la memoria global durante la ejecución de un grid.
Si una instrucción no atómica ejecutada por un warp escribe en la misma
Trabajo Fin de Máster -40- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
posición ya sea de memoria global o compartida por más de un hilo de warp, el
número de de escrituras serializadas que ocurran en esa posición así como el orden
de las escrituras es indefinido, pero se garantiza que al menos una escritura tenga
éxito. Si una instrucción atómica ejecutada por un warp lee, modifica o escribe en
una posición de memoria ya sea global o compartida por más de un hilo del warp,
cada lectura, modificación o escritura en la posición ocurre de forma serializada
aunque el orden es indefinido.
Especificaciones generales
A continuación en la tabla 3.3 se listan una serie de especificaciones generales
que se deben tener en cuenta a la hora de programar una GPU con CUDA para lograr
una ejecución más eficiente en función de la capacidad de cómputo (Compute
capability) de la GPU.
Parámetro Valor según gener. CPU
CUDA Compute
Capabilities
1.0 y 1.1 1.2 y 1.3 Fermi
Limitación Impacto
Multiprocesadores
/ GPU
16 30 16 HW. Escalabilidad
Procesadores /
Multiprocesador
8 8 32 HW. Escalabilidad
Hilos / Warp 32 32 32 SW. Throughput
Bloques de hilos /
Multiprocesador
8 8 8 SW. Throughput
Hilos / Bloque 512 512 512 SW. Paralelismo
Hilos /
Multiprocesador
768 1024 1536 SW. Paralelismo
Registros de 32
bits / Multiproc.
8192 16384 4096 HW. Working Set
Memoria
compartida /
Multiproc.
16384 16384
16 K
48 K
HW. Working Set
Tabla 3.3. Recursos y limitaciones según la GPU que utilicemos para programar CUDA.
A continuación en la tabla 3.4 se muestra la capacidad de cómputo y el número
de multiprocesadores de cada GPU de NVidia.
Trabajo Fin de Máster -41- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Número de
Multiprocesadores (1
Multiprocesador = 8
Procesadores)
Compute
Capability
GeForce GTX 295 2 x 30 1.3
GeForce GTX 285, GTX 280 30 1.3
GeForce GTX 260 24 1.3
GeForce 9800 GX2 2x16 1.1
GeForce GTS 250, GTS 150, 9800
GTX, 9800 GTX+, 8800 GTS 512
16 1.1
GeForce 8800 Ultra, 8800 GTX 16 1.0
GeForce 9800 GT, 8800 GT, GTX
280M, 9800M GTX
14 1.1
GeForce GT 130, 9600 GSO, 8800 GS,
8800M GTX, GTX 260M, 9800M GT
13 1.1
GeForce 8800 GTS 12 1.0
GeForce 9600 GT, 8800M GTS, 9800M
8 1.1
GTS
GeForce 9700M GT
GeForce GT 120, 9500 GT, 8600 GTS,
6 1.1
8600 GT, 9700M GT, 9650M GS,
9600M GT, 9600M GS, 9500M GS,
4 1.1
8700M GT, 8600M GT, 8600M GS
GeForce G100, 8500 GT, 8400 GS,
8400M GT, 9500M G, 9300M G,
8400M GS, 9400 mGPU, 9300 mGPU,
8300 mGPU, 8200 mGPU, 8100 mGPU
GeForce 9300M GS, 9200M GS,
9100M G, 8400M G
2 1.1
1 1.1
Tesla s1070 4x30 1.3
Tesla c1060 30 1.3
Tesla s870 4x16 1.0
Testa d870 2x16 1.0
Tesla c870 16 1.0
Quadro Plex 2200 D2 2x30 1.3
Quadro Plex 2100 D4 4x14 1.1
Quadro Plex 2100 Model S4 4x16 1.0
Quadro Plex 1000 Model IV 2x16 1.0
Quadro FX 5800 30 1.3
Quadro FX 4800 24 1.3
Quadro FX 4700 X2 2x14 1.1
Quadro FX 3700 M 16 1.1
Quadro FX 5600 16 1.0
Quadro FX 3700 14 1.1
Quadro FX 3600M 12 1.1
Quadro FX 4600 12 1.0
Quadro FX 2700 M 6 1.1
Trabajo Fin de Máster -42- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Quadro FX 1700, FX 570, NVS 320M,
FX 1700M, FX 1600M, FX 770M, FX
570M
Quadro FX 370, NVS 290, NVS 140M,
NVS 135M, FX 360M
Número de
Multiprocesadores (1
Multiprocesador = 8
Procesadores)
Compute
Capability
4 1.1
2 1.1
Quadro FX 370M, NVS 130M 1 1.1
Tabla 3.4. Capacidad de cómputo y número de multiprocesadores de cada GPU de
NVidia.
Trabajo Fin de Máster -43- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
4. Procesamiento en Imágenes. Tipos de clasificaciones:
clustering
Es uno de los pasos más importantes una vez que disponemos del acceso al
servicio web de Google Maps en nuestra aplicación, para ello será necesario
desarrollar diferentes algoritmos de análisis de imágenes y reconocimiento de
patrones orientados a caracterizar entre otras cosas, el color englobados en zonas
geográficamente compactas seleccionadas por el usuario.
Con la integración de técnicas de clasificación de imágenes, vamos a intentar
conseguir asignar los distintos píxeles de una imagen a un grupo o clase que posea
unas características similares. Este tipo de procedimiento es conocido como
clustering [26-27], cuyo procedimiento consta de realizar agrupaciones de una serie
de vectores de acuerdo a un criterio de cercanía. Para definir dicho criterio vamos a
utilizar en esta ocasión la distancia euclídea, aunque existen otras funciones más
robustas.
Con todo esto, nos surgió la duda de qué algoritmo habría que utilizar o si habría
que utilizar varios. Para ello tendremos dos opciones:
• Algoritmos no supervisados. También conocidos como algoritmos de
clasificación sin aprendizaje, presuponen que no existe ningún tipo de
conocimiento a priori sobre las clases existentes. El objetivo de estas
técnicas es identificar, de forma automatizada, clases o agrupaciones de
píxeles, utilizando para ello una métrica de similaridad (aquellos píxeles
cuyos valores RGBA se encuentren más próximos se van agrupando
formando clases).
• Algoritmos supervisados. También conocidos como algoritmos de
clasificación con aprendizaje, parten de un cierto conocimiento sobre las
clases existentes basados en la disponibilidad de áreas de entrenamiento
donde a priori se puede conocer la clase a la que pertenece y que servirá
para generar una firma espectral característica de cada una de las clases.
Trabajo Fin de Máster -44- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
En este trabajo afrontaremos la implementación de un algoritmo de clasificación
no supervisada ampliamente conocido en el ámbito científico, dicho algoritmo es es:
K-Means. La implementación lementación paralela de los algoritmos supervisados lo dejaremos
como posibles líneas futuras de este trabajo.
4.1. Algoritmos de clasificación no supervisados
Las técnicas de clasificación no supervisadas suponen un intento de automatizar
el proceso de clasificación, reduciendo al máximo la necesidad de una supervisión
del proceso. Entre ntre las técnicas existentes [18 [18], ], destaca el método K-Means, que
supone la existencia de K clases (parámetro que deberá ser determinado a priori) y
realiza una agrupación de los píxeles de la imagen en dichas clases utilizando los
vectores métodos puramente estadísticos basados en los espectros promedio de
dichas clases.
El funcionamiento de dicho algoritmo es el siguiente:
Paso 1/4
De una forma arbitraria se deben de elegir K centros de cluster mm1
(0) , m2 (0) , …,
mk (0) (Por ejemplo, podría ser las k primero muestras del conjunto. Siendo Conjunto
l=0).
Paso 2/4
Asignar cada una de las muestras {x {xi, , i = 1, …, N} a uno de los grupos de
acuerdo a la distancia entre la muestra y el centro de agrupación:
x wj
if DL(x, mj (l) ) = min {DL(x, mi (l) ), i = 1, …, k} (4.1)
donde wj denota el grupo i de muestras cuyo centro es mj (l) .
Trabajo Fin de Máster -45- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Paso 3/4
( l + 1)
Actualizar todos los centros de cluster para obtener mj
()
=
∑
∈ , ( = 1, … , ) (4.2)
Donde Nj (l) es el número de muestras en la actualidad wj (l) , y
()
=
De este modo la suma de las distancias desde todos los puntos wj (l) al nuevo
centro se reduce al mínimo, es decir,
Paso 4/4
()
∑ () , → . ( = 1, … , )
∈
Se terminaría si el algoritmo converge (es decir, el número de miembros de cada
modelo no se cambia por el paso 2):
() ()
= ( = 1, … , )
o también si se ha llegado a un número máximo predeterminado de iteraciones.
De lo contrario, se pasaría a la siguiente iteración y se volvería al paso dos.
Cómo hemos podido comprobar, este método es simple, pero tiene algunos
inconvenientes (ver tabla 4.1). La figura 4.1 muestra un ejemplo gráfico de
funcionamiento del algoritmo en un espacio de dos dimensiones.
(4.3)
(4.4)
(4.5)
Trabajo Fin de Máster -46- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
VENTAJAS INCONVENIENTES
Sencillo y eficiente Limitado por el orden de presentación de los
patrones (el resultado depende de la
configuración inicial de los agrupamientos).
Un único parámetro Necesidad de conocer el número de clusters K:
su comportamiento depende enormemente del
valor elegido para el parámetro K.
Tabla 4.1. Ventajas e inconvenientes de la utilización del algoritmo K-Means.
Gráficamente y reducido a dos bandas sería de la siguiente forma:
Figura 4.1. Ejemplo gráfico del algoritmo K-Means.
Por otra parte, otro método bastante reconocido en el ámbito de clasificaciones
no supervisadas, es el método ISODATA (Iterative Self-Organizing Data Analysis
Techniques). Dado que esta técnica se basa en el anterior método comentado, lo
dejaremos como futura línea de trabajo.
Finalmente, tras la aplicación de cualquiera de las dos técnicas no supervisadas
mencionadas anteriormente, y con carácter opcional, los datos resultantes de la
clasificación pueden ser post-procesados (por ejemplo, utilizando técnicas
espaciales) para mejorar la coherencia de los mismos.
Trabajo Fin de Máster -47- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
5. Procesamiento paralelo en GPU
Una vez introducidas las ventajas que aportan las GPUs para el procesamiento
paralelo pasemos a exponer como se llevo a cabo este procesamiento en el caso que
nos ocupa, es decir en el algoritmo de clasificación no supervisada que ha sido
descrito anteriormente. Como ya sabemos contamos con una GPU NVidia Tesla
c1060 la cual cuenta con 30 multiprocesadores cada uno de los cuales dispone a su
vez de 8 procesadores. Pongamos como caso de uso una imagen hipotética de
dimensiones 512 x 512 x 4, esto es, 512 líneas, 512 columnas y 4 bandas (red R,
green G, blue B, alpha A).
Pues bien, cuando se necesita paralelizar un algoritmo, el diseñador debe ser
consciente de las características de la arquitectura donde se va a ejecutar un
algoritmo dado. Realizar una buena distribución del trabajo, es decir, repartir una
serie de hilos proporcionalmente al número de elementos de procesamiento
independientes, es una de las cuestiones que pueden favorecer al proceso de
paralelización o perjudicarlo. Por ello, dependiendo de cómo asignemos la carga de
trabajo a cada uno de los threads, nos vamos a poder encontrar con problemas de
paralelización tales como el denominado “cuello de botella”.
En nuestro caso, que ya conocemos como funciona el algoritmo que se desea
paralelizar, sabremos que la parte más importante del algoritmo es la asignación de
cada uno de los píxeles al cluster cuyo centro sea más cercano.
Para ello necesitaremos calcular la distancia euclídea (ver tabla 5.1) para cada
uno de los píxeles al centro de cluster más cercano. Para implementar este algoritmo
en CUDA, podemos asignar el cálculo de la distancia de cada píxel de la imagen en
un único subproceso. De tal manera que cada thread realice el cálculo de la distancia
entre los valores de cada uno de los píxeles y el centro de cluster más cercano,
además de la asignación a su cluster correspondiente. Cuando todos los threads
hayan terminado, conoceremos la composición de cada uno de los cluster y por tanto
la primera fase del algoritmo habrá terminado.
En la práctica va a ser complicado que nos vayamos a encontrar que el número
Trabajo Fin de Máster -48- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
de elementos a procesar sean iguales al número de proce procesos sos (éste último en la
práctica se encuentra limitado). En el algoritmo que se ha desarrollado los píxeles
son distribuidos en una matriz de 1 dimensión (cuyas posiciones son los valores
RGBA de cada uno de los píxeles).
Tabla 5.1. Métricas utilizadas para calcular la similitud de características.
Para la siguiente fase del algoritmo, donde se necesitan recalcul recalcular los centros de
cada cluster y reasignar de nuevo los píxeles a cada uno de los clusters,
aprovecharemos la idea del algoritmo serie utilizado utilizado. . Se realizará de esta manera por
dos razones:
• En este paso el algoritmo requiere un intenso intercambio de datos y podría
crear una congestión en la memoria del subsistema. Aunque una forma de
poder paralelizar esta parte, sería pedir a cada uno de los th threads qué píxeles
es miembro de un determinado clu cluster ster para poder añadir sus valores a una
cierta estructura en memoria. Esta opción no sería muy buena ya que crearía
demasiado tráfico tráfico.
• También se podría aplicar el proceso de reducción, es decir, teniend teniendo una lista
de valores RGBA correspondientes a los píxeles de cada uno de los clusters,
se podrían sumar en log log2(n), (n), siendo n el número de elementos pertenecientes
Trabajo Fin de Máster -49- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
a un cluster determinado. Para ello en cada iteración produciríamos n/2
sumas, después n/4 sumas, n/8 sumas y así hasta llegar al proceso que quede
una suma única. Gráficamente tendríamos lo siguiente (ver figura 5.1):
Figura 5.1. Ejemplo de reducción en tres pasos de una suma dado un cluster de 8
elementos.
• Incluso utilizando un enfoque en serie, este paso del algoritmo no es un factor
dominante en el tiempo total de la solución.
Para el último paso del algoritmo, comprobar si converge, no vale la pena el
esfuerzo de paralelizar este paso, ya que normalmente el número de clusters que se
suele utilizar está comprendido entre 1 y 10, por tanto, optaremos a realizar este paso
en serie ya que tampoco es un factor dominante en el tiempo total de la solución.
5.1. Implementación CUDA
Para dicha implementación, hemos utilizado dos estructuras de dato:
Trabajo Fin de Máster -50- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
El algoritmo de aceleración para KK-Means
Means que se ha implementado consta de
tres etapas de operación bien diferenciadas.
5.1.1. Primera etapa
En esta primera etapa se inicializa el hardware CUDA, reservando las áreas de
almacenamiento de memoria necesaria para el hhost
ost y el device, las estimacion estimaciones
iniciales del conjunto de clu cluster ster y el conjunto de datos en la memoria a bordo de la
tarjeta gráfica. La utilización de las macros CUT_SAFE_CALL y
CUDA_SAFE_CALL es únicamente para la comprobación de errores.
Trabajo Fin de Máster -51- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
A continuación mostraremos el código que lanzará lanzarán todos los threads en la parte
del host. Los threads serán enviados automáticamente por el hardware.
La llamada a la función kkernel
ernel se quedará bloqueada en la parte host, hasta que
todos los threads sean env enviados iados y completados. Después en el código host se
Trabajo Fin de Máster -52- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
comprobará bará la correcta ejecución del kkernel
CUDA, copiando los resultados desde la
memoria del dispositivo.
Finalmente, el host liberará la memoria reservada y finalizará.
5.1.2. Segunda etapa
La segunda parte parte, , qué es la carga de trabajo más pesada del programa, es la
ejecución del kernel en el dispositivo GPU. Cada thread procesará un único píxel, y
calculará la distancia entre el píxel y el centro de cada cluster. Durante la ejecución
del bucle se estará dete determinando rminando la misma distancia entre el píxel y cada uno de los
Trabajo Fin de Máster -53- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
clusters y una vez que este bucle termine, los resultados serán almacenados en la
memoria del dispositivo.
Un aspecto importante de este código es el uso de la memoria constante para el
almacenamiento de los datos relacionados con cada uno de los clusters. La memoria
constante es una parte cacheable de la memoria del device. En el modelo c1060 de
Tesla, tenemos 16 KB por cada bloque de threads. Su utilización proporciona un
acceso rápido a determinadas variables, que en nuestro caso se trataba de acceder a la
información de cada uno de los clusters, de modo que cada thread dentro del bucle
pudiera acceder a la información de cada cluster. Nos dimos cuenta que su
utilización fue tan importante que de no haberla utilizado (por tanto se habría
utilizado la memoria global), los resultados hubieran sido de un orden menor a los
obtenidos tras esta implementación.
5.1.3. Tercera etapa
La tercera parte de esta implementación se trata de actualizar los centros una vez
que cada uno de los píxeles se ha asignado al centro de cluster más cercano y de
comprobar si se ha alcanzado la condición de convergencia o incluso si se ha llegado
al máximo de iteraciones definidas por el usuario. Esta parte del código se decidió
realizarla en serie en el host.
Todos los pasos descritos en el algoritmo se van a realizar hasta que se llegue al
máximo de iteraciones permitidas por el usuario o bien hasta que se alcance la
Trabajo Fin de Máster -54- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
condición de convergencia del bucle. A continuación mostraremos el código
utilizado tanto para la actualización de los centros, como para comprobar la
convergencia y la posterior asignación de los píxeles a su posible cluster más
cercano.
5.2. CUDA Occupancy Calculator
Es una herramienta que nos asesora en la elección de los parámetros de
configuración de un kernel. Se trata de una hoja de cálculo que nos presenta diversas
gráficas de la ocupación de un multiprocesador en función de la capacidad de
cómputo, del número de hilos que utilicemos en cada bloque, del número de registros
que utilicemos por hilo y de la cantidad de memoria compartida por bloque. El
número de hilos por bloque es fácil de conocer ya que es un parámetro fijado por el
desarrollador. Para conocer tanto el número de registros usados como la cantidad de
Trabajo Fin de Máster -55- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
memoria compartida necesitamos incluir como modificador en el compilador el flag
–ptxas-options=”-v”. Con esto a la hora de compilar podremos conocer esos valores.
Con estos cuatros parámetros CUDA Occupancy Calculator nos mostrará entre
otras cosas el número de hilos activos por multiprocesador, el número de warps
activos por multiprocesador, el número de bloques de hilos activos por
multiprocesador y la ocupación de cada multiprocesador. El principal objetivo de
usar esta herramienta es conseguir un 100% de ocupación lo que significa que no hay
ningún procesador ocioso en ningún multiprocesador. A continuación la figura 5.2
muestra el aspecto de esta herramienta:
Figura 5.2. Cuda Occupancy Calculator.
Seguidamente mostraremos los resultados de CUDA Occupancy Calculator para
una de nuestras ejecuciones, concretamente para una de nuestras imágenes de satélite
Trabajo Fin de Máster -56- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
extraída de Google Maps y descrita en el siguiente capítulo.
La tabla 5.2 muestra los parámetros introducidos en la herramienta:
Tabla 5.2: Cuda occupancy calculator: parámetros introducidos introducidos.
Una vez que hemos introducido los parámetros se calcula la ocupación de cada
multiprocesador y se muestra el estado de est estos os en las gráficas. La tabla 5.3 muestra
los resultados calculados en base a estos parámetros:
Tabla 5.3: : Cuda occupancy calculator: resultados calculados en función de los
parámetros.
La herramienta además proporciona tres gráficas, cada una de ellas asociada a un
parámetro (nº de hilos po por r bloque, nº de registros por hilo y memoria compartida
usada por cada bloque), en éstas se muestra la ocupación conseguida con la
configuración actual y los posibles cambios en la ocupación si variamos el valor del
parámetro asociado.
La ocupación se calc calcula como:
Ocupación =
º
º á
Máximo = 24 warps (1.0 y 1.1), 32 warps (1.3)
Trabajo Fin de Máster -57- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
La figura 5.3 muestra la gráfica asociada al número de hilos por bloque.
Figura 5.3: Cuda occupancy calculator: gráfica asociada al número de hilos por bloque.
La ocupación calculada con la configuración actual viene representada por la
posición del triángulo rojo, éste está a la misma altura en las tres gráficas. De esta
gráfica podemos extraer que con 512 hilos por bloque conseguimos la máxima
ocupación. Además si no variamos ninguno de los otros dos parámetros, salvo pocas
configuraciones (128, 256,..), cualquier otra configuración en cuanto al número de
hilos por bloque perjudicaría a la ocupación y por tanto al rendimiento conseguido.
Por otra parte 512 hilos es el límite permitido para un tamaño de bloque de una
dimensión.
La figura 5.4 muestra la gráfica asociada al número de registros utilizado por
cada hilo.
En esta gráfica podemos observar que se ha alcanzado la ocupación máxima
usando cada hilo un total de 6 registros. Como sabemos por los resultados de la tabla
Trabajo Fin de Máster -58- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
5.3 en cada multiprocesador tenemos 2 bloques activos por tanto los recursos
hardware de ese multiprocesador se comparten entre los dos bloques, estos bloque
podrán ejecutarse en paralelo siempre y cuando ninguno de los dos consuma más de
la mitad de los recursos disponibles. Cada multiprocesador tiene un total de 16K
registros de 32 bits, es decir 16384 registros. La mitad de estos es 8192, tenemos en
un bloque 512 hilos que consumen 6 registros cada uno lo que hace un total de 3072
registros, cantidad que no supera la mitad. Como puede verse en la gráfica, en el
supuesto de que cada hilo utilizase más de 16 registros, la ocupación se reduciría a la
mitad, permitiendo solamente la ejecución de un bloque de hilos por
multiprocesador.
Figura 5.4: Cuda occupancy calculator: gráfica asociada al número de registros por hilo.
Finalmente la figura 5.5 muestra la gráfica asociada a la cantidad de memoria
compartida usada por cada bloque.
Trabajo Fin de Máster -59- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Figura 5.5: Cuda occupancy calculator: gráfica asociada a la cantidad de memoria
compartida usada por cada bloque.
En esta gráfica también podemos ver que la ocupación de los multiprocesadores
es máxima, como sabemos el número de bloques activos en un multiprocesador es 2
por tanto cada bloque no debe consumir más de la mitad de los recursos disponibles.
Un total de 9 píxeles en memoria compartida almacenados por cada bloque hacen
que se usen 8104 bytes que no alcanza por poco la mitad de la memoria compartida
disponible que tiene un total de 16KB. Si mantenemos el número de hilos y el
número de registros por hilo y aumentamos el uso de la memoria compartida a más
de la mitad del total, la ocupación se reduciría a la mitad y afectaría al rendimiento
gravemente (al 50%). En esta ocasión la cantidad de memoria compartida utilizada es
muy pequeña ya que esta vez se ha utilizado la memoria de constantes, que es más
rápida y además es una de las optimizaciones utilizada para reducir el tiempo de
ejecución de dicho algoritmo.
Trabajo Fin de Máster -60- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
6. Resultados
En este apartado pasaremos a mostrar y analizar cada uno de los resultados
obtenidos y posteriormente verificar su correcto funcionamiento al utilizar una
clasificación no supervisada como es el caso del algoritmo K-Means y así poder
validar los mismos comparando los resultados con herramientas de análisis y
procesado de imágenes como es el caso de ENVI 5 .
Para probar el correcto funcionamiento del algoritmo implementado de una
forma cualitativa y posteriormente cuantitativa, el primer paso que debemos realizar
es escoger una zona de entrenamiento desde la aplicación GoogleCBIR y una vez
almacenada en disco, aplicar el algoritmo implementado K-Means en sus versiones
serie y paralelo. Después para verificar su correcto funcionamiento en función de la
precisión, clasificaremos la misma imagen utilizando la herramienta software para
análisis y procesado de imágenes, ENVI.
ENVI 6 , Entorno para Visualización de Imágenes (ENVIronment for Visualizing
Images), es un moderno sistema para procesar imágenes y así proporcionar análisis
multiespectral de los datos obtenidos por teledetección desde aviones y satélites.
Proporciona un potente entorno para poder analizar imágenes de cualquier tamaño y
tipo de datos en un amplio rango de plataformas.
Esta herramienta software está completamente escrita en IDL (Interactive Data
Language), Lenguaje de Datos Interactivo. IDL es un lenguaje de programación
estructurada bastante potente, basado en matrices, que proporciona un procesamiento
de imágenes integrado, grandes capacidades de visualización y herramientas GUI
fáciles de usar. Para la ejecución de ENVI es necesario IDL, ya que de parte de su
flexibilidad es conseguida de la potencia de IDL.
Antes de comentar los diferentes ejemplos de clasificación que se han utilizado
en la validación de la herramienta, procedemos a describir las métricas empleadas en
la validación. En concreto, la matriz de confusión [28] es una técnica que permite
5 http://www.ittvis.com/ProductServices/ENVI.aspx
6 http://www.innovanet.com.ar/gis/TELEDETE/TELEDETE/maneENVI.htm
Trabajo Fin de Máster -61- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
evaluar la precisión de algoritmos de clasificación de imágenes digitales obtenidas de
forma remota. Esta técnica presupone que la información verdad terreno viene
expresada en forma de un mapa temático [29, 30], caracterizado por las siguientes
propiedades:
a) Cada píxel se encuentra etiquetado como perteneciente a una determinada
R = .
clase, de forma que tienen N clases o regiones de referencia { } N
i i 1
b) Las regiones de referencia son mutuamente excluyentes entre sí, es decir, dos
regiones diferentes no tienen ningún píxel en común: ∩ R = ∅,
∀i
≠ j.
Ri j
Supongamos que cada píxel i de la imagen a evaluar, I, es asignado por el
algoritmo como perteneciente a una determinada clase Ci, de forma que se tienen N
clases. Los conjuntos Ci determinan una partición de la imagen a evaluar, es decir, la
unión de todos ellos da como resultado la imagen y dos conjuntos distintos no tienen
N
Ci i j
i=
1
ningún elemento en común: U = I y C ∩ C = ∅,
∀i
≠ j.
Teniendo en cuenta las
anteriores consideraciones, la figura 6.1 muestra un ejemplo del proceso de
construcción de una matriz de confusión. En la figura, se muestra el mapa temático
asociado a la imagen a clasificar, el resultado de clasificación proporcionado por un
determinado algoritmo para dicha imagen, y la matriz de confusión que cuantifica la
precisión del algoritmo en la tarea de clasificación.
Lago (R 0 )
Carretera (R 1 )
Árboles (R 2 )
Suelo (R 3 )
C 0
C 1
C 2
C 3
Mapa temático
(verdad terreno)
R 0
a 00 =|C 0 ∩R 0 |
a 10 =|C 1 ∩R 0 |
a 20 =|C 2 ∩R 0 |
a 30 =|C 3 ∩R 0 |
Matriz de confusión
R 1
a 01 =|C 0 ∩R 1 |
a 11 =|C 1 ∩R 1 |
a 21 =|C 2 ∩R 1 |
a 31 =|C 3 ∩R 1 |
Clasificación
(Algoritmo)
a 02 =|C 0 ∩R 2 |
a 12 =|C 1 ∩R 2 |
a 22 =|C 2 ∩R 2 |
a 32 =|C 3 ∩R 2 |
a 03 =|C 0 ∩R 3 |
a 13 =|C 1 ∩R 3 |
a 23 =|C 2 ∩R 3 |
a 33 =|C 3 ∩R 3 |
Lago (C 0 )
Carretera (C 1 )
Árboles (C 2 )
Suelo (C 3 )
Figura 6.1. Ejemplo de construcción de una matriz de confusión.
Trabajo Fin de Máster -62- Sergio Bernabé García
R 2
R 3

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
Como puede apreciarse, las entradas de la matriz vienen expresadas en forma
a jk,
siendo =
efectuar la intersección entre una clase CCj
obtenida por el algoritmo y una clase
etiquetada Rk. A partir de la matriz de confusión pueden derivarse algunas me medidas
de precisión genéricas [31 [31] ] como el porcentaje de acierto global: tanto por ciento de
píxeles clasificados de forma correcta en todas las clases, calculado de la siguiente
forma:
∩ , el número de píxeles de la región resultante al
OA =
N
∑i N
6.1. Ejemplo de uso 1: World Trade Center de New York
Para este primer caso de estudio seleccionaremos una zona urbana del World
Trade Center de New York 7 . Esta zona fue un complejo ubicado en Lower
Manhattan, en Nueva York, Estados Unidos, donde se situaban las Torres Gemelas.
El WTC fue diseñado por Minoru Yamasaki a principios de los años 1960.
Actualmente esta zona se encuentra en construcción debido al atentado ocurrido el
11 de septiembre de 2001. En Wikipedia, se facilitan las coordenadas de longitud y
latitud para encontrar dicha zona tan espectacular (ver figura 6.2).
∑
7
http://es.wikipedia.org/wiki/World_Trade_Center
ij ij
× 100
Trabajo Fin de Máster -63- Sergio Bernabé García
a
a
ii
(6.1)
Figura 6.2. Ubicación del WTC de
Nueva York, situado en las
coordenadas: 40.713º, -74.0135º.

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
Una vez situados en esas coordenadas dentro de la aplicación “GoogleCBIR”,
seleccionaremos por ejemplo, alguna zona urbana cualquiera del WTC (ver figura
6.3).
Figura 6.3. Selección de una zona urbana perteneciente al WTC de Nueva York (Estados
Unidos).
Figura 6.4. Segmentación de la zona seleccionada del WTC, utilizando el algoritmo
K-Means.
Trabajo Fin de Máster -64- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
A dicha selección una vez almacenada en disco, ejecutaremos el algoritmo de
clasificación no supervisada K-Means paralelizado, al que aplicaremos 5 clases para
segmentar la imagen. Los resultados los obtendremos en la figura 6.4.
A continuación y una vez realizado la ejecución del algoritmo K-Means,
procesaremos dicha zona con la herramienta ENVI. Para ello, seleccionaremos el
algoritmo de clasificación no supervisada K-Means con la misma configuración que
en la ejecución del código paralelizado (ver figura 6.5).
Figura 6.5. Segmentación de la zona seleccionada de WTC (Nueva York) utilizando el
algoritmo K-Means con la herramienta ENVI.
Como hemos podido comprobar de forma visual la segmentación realizada por
nuestro algoritmo en GPU no es muy distinta a la realizada por la herramienta ENVI.
Ahora nos quedaría demostrarlo a través de la comparación de los distintos píxeles
clasificados por nuestro algoritmo calculando un porcentaje de acierto. Ya que no se
disponen de medidas verdad-terreno, se ha decidido utilizar las imágenes de la
herramienta ENVI cómo nuestra medida de referencia para evaluar las imágenes
obtenidas por nuestra herramienta. De esta manera, es necesario conocer cuántos
píxeles de la imagen clasificada generada por nuestra herramienta se clasifican
correctamente por clase. Así tendremos unas estadísticas que nos ayudarán a valorar
positivamente o negativamente nuestros resultados tras la aplicación del algoritmo de
Trabajo Fin de Máster -65- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
clasificación no supervisada.
Para la obtención de dichas estadísticas, se ha elaborado un pequeño programa
capaz de ir comparando los píxeles de una imagen y otra, atendiendo que los colores
asignados por nuestra herramienta y por la de ENVI no son iguales. Por ello, es
necesario tenerlos en cuenta para ofrecer unos resultados correctos.
La tabla 6.1 muestra una comparativa (en términos de porcentaje de acierto)
entre la imagen mostrada en la figura 6.4 (correspondiente al método K-Means
implementado) y la imagen mostrada en la figura 6.5 (correspondiente al método
K-Means implementado en ENVI). Los códigos de color indicados en la tabla
corresponden a los colores asociados a cada clase en nuestra implementación
paralelizada. Las celdas que se encuentran sombreadas corresponden a las clases con
las que el usuario ha querido conservar, de las que se han obtenido una media de
valores por encima del 80% de acierto. Como puede apreciarse en la tabla 6.1, la
evaluación de los resultados obtenidos se encuentra en torno al 70-80% de similitud
al emplear el porcentaje de acierto calculado píxel a píxel, con porcentajes muy
elevados de similitud al comparar clases predominantes en la escena del World Trade
Center como las asociadas a zonas urbanas, por lo que podemos concluir que la
implementación desarrollada se comporta de forma correcta con la imagen que ha
sido procesada.
Estos resultados aún podrían ser mejores, puesto que la comparación que se ha
realizado con la imagen de validación ha sido píxel a píxel, sin tener en cuenta
ningún posible margen de error entre el resultado obtenido y el deseado.
Azul
(Sombra1)
Verde
(ZUrbana2)
Naranja
(Zurbana3)
Rojo
(Sombra2)
Amarillo
(Zurbana1)
Media
Global
78.26 % 90.65 % 97.39 % 95.49 % 85.56 % 89.47 %
Tabla 6.1. Resultados estadísticos tras la ejecución paralela del algoritmo de
clasificación no supervisado K-Means con la imagen del World Trade Center.
Una vez que hemos explicado como se ha llevado a cabo el análisis de
resultados en cuanto a precisión, a continuación expondremos los resultados de los
Trabajo Fin de Máster -66- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
experimentos realizados sobre la imagen del World Trade Center y compararemos
los tiempos de las versiones CPU y GPU.
La tabla 6.2 muestra el tiempo de ejecución por cada una de las GPUs y la
versión serie, además del speedup conseguido.
Parámetros
Núm.
Elementos
Núm.
Clusters
K-Means versión
Tiempo
(segs)
C (CPU)
Speedup Tiempo
(segs)
K-Means versión
CUDA (GPU
GeForce 9400M)
K-Means versión
CUDA (GPU
Tesla c1060)
Speedup Tiempo
(segs) Speedup
512x512 5 0.822 1x 0.252 3.26x 0.145 5.67x
512x512 64 3.769 1x 0.496 7.60x 0.210 17.95x
512x512 128 7.861 1x 0.764 10.29x 0.268 29.33x
1024x1024 64 22.147 1x 3.582 6.18x 0.715 30.97x
1024x1024 128 38.301 1x 4.374 8.76x 1.044 36.69x
Tabla 6.2. Comparación de resultados CPU y GPU utilizando la imagen del World Trade
Center ajustada según la dimensión.
A medida que aumentamos el número de elementos, es decir, las dimensiones de
la imagen a clasificar y el número de clusters, el speedup conseguido por la GPU
Tesla es cada vez mayor, concretamente la versión GPU tarda casi 37 veces menos
en ejecutarse que la versión CPU demostrando la gran potencia de cálculo que puede
aprovecharse en una GPU. Sin embargo utilizando una GPU GeForce 9400M el
límite nos lo encontramos al aumentar en 1024x1024 las dimensiones de la imagen,
en donde el speedup va disminuyendo. Así y todo se ha conseguido ejecutar el
código en 10 veces menos que la versión CPU.
Trabajo Fin de Máster -67- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
6.2. Ejemplo de uso 22:
El río Nilo africano
Para este caso seleccionaremos un pequeño tramo de este gran río situado en
África 8 , considerado uno de los ríos más largos del mundo aunque hay fuentes que ya
no lo colocan como el más largo del mundo y le han cedido este puesto al río
Amazonas. El Nilo por su parte, nace en Burundi, recorre Uganda, Sudán y Egipto,
desembocando en el mar Mediterráneo, al norte de El Cairo, formand formando un amplio
delta. En Wikipedia, se facilitan las coordenadas de longitud y latitud para encontrar
dicha zona tan particular de África (ver figura 6.6).
Figura 6.6. Ubicación del río Nilo (África), situado en las coordenadas: 29.89º, 31.28º.
Una vez situados en esas coordenadas dentro de la aplicación “GoogleCBIR”,
seleccionaremos por ejemplo, algún tramo del río Nilo (ver figura 6.7 6.7).
A dicha selección una vez almacenada en disco, ejecutaremos el algoritmo de
clasificación no supervisada K-Means Means paralelizado, al que aplicaremos 5 clases para
segmentar la imagen. Los resultados los obtendremos en la figura 6.8.
8
http://es.wikipedia.org/wiki/Nilo
Trabajo Fin de Máster -68- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
Figura 6.7. Selección de un tramo perteneciente al río Nilo ilo (África).
Figura 6.8. Segmentación de la zona seleccionada del río Nilo (África) utilizando el
algoritmo K-Means.
A continuación y una vez realizado la ejecución del algoritmo KK-Means,
procesaremos dicha zona con la herramienta ENVI. Para ello, seleccionaremos el
algoritmo de clasificación no supervisada KK-Means
con la misma isma configuración que
en la ejecución del código paralelizado (ver figura 6.9).
Trabajo Fin de Máster -69- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Figura 6.9. Segmentación de la zona seleccionada del río Nilo utilizando el algoritmo
K-Means con la herramienta ENVI.
Como hemos podido comprobar de forma visual la segmentación realizada por
nuestro algoritmo en GPU no es muy distinta a la realizada por la herramienta ENVI.
Ahora nos quedaría demostrarlo a través de la comparación de los distintos píxeles
clasificados por nuestro algoritmo calculando un porcentaje de acierto. Ya que no se
disponen de medidas verdad-terreno, se ha decidido utilizar las imágenes de la
herramienta ENVI cómo nuestra medida de referencia para evaluar las imágenes
obtenidas por nuestra herramienta. De esta manera, es necesario conocer cuántos
píxeles de la imagen clasificada generada por nuestra herramienta se clasifican
correctamente por clase. Así tendremos unas estadísticas que nos ayudarán a valorar
positivamente o negativamente nuestros resultados tras la aplicación del algoritmo de
clasificación no supervisada.
Para la obtención de dichas estadísticas, se ha elaborado un pequeño programa
capaz de ir comparando los píxeles de una imagen y otra, atendiendo que los colores
asignados por nuestra herramienta y por la de ENVI no son iguales. Por ello, es
necesario tenerlos en cuenta para ofrecer unos resultados correctos.
La tabla 6.3 muestra una comparativa (en términos de porcentaje de acierto)
entre la imagen mostrada en la figura 6.8 (correspondiente al método K-Means
implementado) y la imagen mostrada en la figura 6.9 (correspondiente al método
Trabajo Fin de Máster -70- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
K-Means implementado en ENVI). Los códigos de color indicados en la tabla
corresponden a los colores asociados a cada clase en nuestra implementación
paralelizada. Las celdas que se encuentran sombreadas corresponden a las clases con
las que el usuario ha querido conservar, de las que se han obtenido una media de
valores por encima del 80% de acierto. Como puede apreciarse en la tabla 6.3, la
evaluación de los resultados obtenidos se encuentra en torno al 70-80% de similitud
al emplear el porcentaje de acierto calculado píxel a píxel, con porcentajes muy
elevados de similitud al comparar clases predominantes en la escena del río Nilo
como las asociadas a zonas de agua, por lo que podemos concluir que la
implementación desarrollada se comporta de forma correcta con la imagen que ha
sido procesada.
Estos resultados aún podrían ser mejores, puesto que la comparación que se ha
realizado con la imagen de validación ha sido píxel a píxel, sin tener en cuenta
ningún posible margen de error entre el resultado obtenido y el deseado.
Azul
(Suelo2)
Verde
(Agua2)
Naranja
(Suelo1)
Rojo
(Agua1)
Amarillo
(Zurbana1)
Media
Global
94.85 % 57.29 % 89.25 % 99.56 % 99.74 % 88.14 %
Tabla 6.3. Resultados estadísticos tras la ejecución paralela del algoritmo de
clasificación no supervisado K-Means con la imagen del río Nilo.
Una vez que hemos explicado como se ha llevado a cabo el análisis de
resultados en cuanto a precisión, a continuación expondremos los resultados de los
experimentos realizados sobre la imagen del río Nilo y compararemos los tiempos de
las versiones CPU y GPU.
La tabla 6.4 muestra el tiempo de ejecución por cada una de las GPUs y la
versión serie, además del speedup conseguido.
A medida que aumentamos el número de elementos, es decir, las dimensiones de
la imagen a clasificar y el número de clusters, el speedup conseguido por la GPU
Tesla es cada vez mayor, concretamente la versión GPU tarda casi 21 veces menos
en ejecutarse que la versión CPU demostrando la gran potencia de cálculo que puede
Trabajo Fin de Máster -71- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
aprovecharse en una GPU. Sin embargo utilizando una GPU GeForce 9400M el
límite nos lo encontramos al aumentar en 1024x1024 las dimensiones de la imagen,
en donde el speedup va disminuyendo. Así y todo se ha conseguido ejecutar el
código en 6 veces menos que la versión CPU.
Parámetros
Núm.
Elementos
Núm.
Clusters
K-Means versión
Tiempo
(segs)
C (CPU)
Speedup Tiempo
(segs)
K-Means versión
CUDA (GPU
GeForce 9400M)
K-Means versión
CUDA (GPU
Tesla c1060)
Speedup Tiempo
(segs) Speedup
512x512 5 0.537 1x 0.140 3.84x 0.118 4.55x
512x512 64 2.196 1x 0.458 4.79x 0.210 10.46x
512x512 128 3.718 1x 0.592 6.28x 0.223 16.67x
1024x1024 64 18.492 1x 5.153 3.59x 1.046 17.68x
1024x1024 128 25.902 1x 6.467 4.01x 1.254 20.66x
Tabla 6.4. Comparación de resultados CPU y GPU utilizando la imagen del río Nilo
ajustada según la dimensión.
Trabajo Fin de Máster -72- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
6.3. Ejemplo de uso 3: Población de Guareña y sus alrededores
Para este tercer y último caso de estudio seleccionaremos una zona cercana a la
población de Guareña 9 , municipio español perteneciente a la provincia de Badajoz
(comunidad autónoma de Extremadura) del que es natural el autor del presente
trabajo. Wikipedia nos facilita las coordenadas de longitud y latitud para encontrar
dicha localidad (ver figura 6.10).
Figura 6.10. 10. Ubicación del municipio de Guareña (B (Badajoz), adajoz), situado en las coordenadas:
38.85º, -6.083333º.
Una vez situados en esas coordenadas dentro de la aplicación “GoogleCBIR”,
seleccionaremos emos por ejemplo, una zona de vegetación (ver figura 6.11).
Figura 6.11. Selección de una zona si situada tuada cerca de la población de GGuareña
de la que
escogeremos las zonas con vegetación.
9
http://es.wikipedia.org/wiki/Guare%C3%B1a_(Badajoz)
Trabajo Fin de Máster -73- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
A dicha selección una vez almacenada en disco, ejecutaremos el algoritmo de
clasificación no supervisada KK-Means
Means paralelizado, al que aplicaremos 5 clases para
segmentar la imagen. Los resultados los obtendremos en la figura 6.12.
Figura 6.12. Segmentación de la zona seleccionada si situada tuada cerca de la población de GGuareña
utilizando el algoritmo K-Means.
A continuación y una vez realizado la ejecución del algoritmo KK-Means,
procesaremos dicha zona con la herramienta ENVI. Para ello, seleccionaremos el
algoritmo de clasificación no supervisada KK-Means
Means con la misma conf configuración que
en la ejecución del código paralelizado (ver figura 6.13).
Figura 6.13. Segmentación de la zona seleccionada situada cerca de la población de
Guareña utilizando el algoritmo KK-Means
Means con la herramienta ENVI ENVI.
Como hemos podido comprobar de forma visual la segmentación realizada por
Trabajo Fin de Máster -74- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
nuestro algoritmo en GPU no es muy distinta a la realizada por la herramienta ENVI.
Ahora nos quedaría demostrarlo a través de la comparación de los distintos píxeles
clasificados por nuestro algoritmo calculando un porcentaje de acierto. Ya que no se
disponen de medidas verdad-terreno, se ha decidido utilizar las imágenes de la
herramienta ENVI cómo nuestra medida de referencia para evaluar las imágenes
obtenidas por nuestra herramienta. De esta manera, es necesario conocer cuántos
píxeles de la imagen clasificada generada por nuestra herramienta se clasifican
correctamente por clase. Así tendremos unas estadísticas que nos ayudarán a valorar
positivamente o negativamente nuestros resultados tras la aplicación del algoritmo de
clasificación no supervisada.
Para la obtención de dichas estadísticas, se ha elaborado un pequeño programa
capaz de ir comparando los píxeles de una imagen y otra, atendiendo que los colores
asignados por nuestra herramienta y por la de ENVI no son iguales. Por ello, es
necesario tenerlos en cuenta para ofrecer unos resultados correctos.
La tabla 6.5 muestra una comparativa (en términos de porcentaje de acierto)
entre la imagen mostrada en la figura 6.12 (correspondiente al método K-Means
implementado) y la imagen mostrada en la figura 6.13 (correspondiente al método
K-Means implementado en ENVI). Los códigos de color indicados en la tabla
corresponden a los colores asociados a cada clase en nuestra implementación
paralelizada. Las celdas que se encuentran sombreadas corresponden a las clases con
las que el usuario ha querido conservar, de las que se han obtenido una media de
valores por encima del 80% de acierto. Como puede apreciarse en la tabla 6.5, la
evaluación de los resultados obtenidos se encuentra en torno al 70-80% de similitud
al emplear el porcentaje de acierto calculado píxel a píxel, con porcentajes muy
elevados de similitud al comparar clases predominantes en la escena de Guareña
como las asociadas a hierba y vegetación (árboles) por lo que podemos concluir que
la implementación desarrollada se comporta de forma correcta con la imagen que ha
sido procesada.
Estos resultados aún podrían ser mejores, puesto que la comparación que se ha
realizado con la imagen de validación ha sido píxel a píxel, sin tener en cuenta
Trabajo Fin de Máster -75- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
ningún posible margen de error entre el resultado obtenido y el deseado.
Rojo
(Pasto)
Verde
(Hierba1)
Azul
(Hierba2)
Amarillo
(Vegetación1)
Naranja
(Vegetación2)
Media
Global
71.93 % 90.11 % 90.57 % 83.67 % 81.44 % 83.54 %
Tabla 6.5. Resultados estadísticos tras la ejecución paralela del algoritmo de
clasificación no supervisado K-Means con la imagen de Guareña.
Una vez que hemos explicado como se ha llevado a cabo el análisis de
resultados en cuanto a precisión, a continuación expondremos los resultados de los
experimentos realizados sobre la imagen de Guareña y compararemos los tiempos de
las versiones CPU y GPU.
La tabla 6.6 muestra el tiempo de ejecución por cada una de las GPUs y la
versión serie, además del speedup conseguido.
Parámetros
Núm.
Elementos
Núm.
Clusters
K-Means versión
Tiempo
(segs)
C (CPU)
Speedup Tiempo
(segs)
K-Means versión
CUDA (GPU
GeForce 9400M)
K-Means versión
CUDA (GPU
Tesla c1060)
Speedup Tiempo
(segs) Speedup
512x512 5 0.311 1x 0.093 3.34x 0.126 2.47x
512x512 64 5.122 1x 1.307 3.92x 0.415 12.34x
512x512 128 6.387 1x 1.453 4.40x 0.457 13.98x
1024x1024 64 15.305 1x 5.427 2.82x 0.930 16.46x
1024x1024 128 24.234 1x 8.056 3.01x 1.060 22.86x
Tabla 6.6. Comparación de resultados CPU y Gpu utilizando la imagen de Guareña.
A medida que aumentamos el número de elementos, es decir, las dimensiones de
la imagen a clasificar y el número de clusters, el speedup conseguido por la GPU
Tesla es cada vez mayor, concretamente la versión GPU tarda casi 23 veces menos
en ejecutarse que la versión CPU demostrando la gran potencia de cálculo que puede
aprovecharse en una GPU. Sin embargo utilizando una GPU GeForce 9400M el
Trabajo Fin de Máster -76- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
límite nos lo encontramos al aumentar en 1024x1024 las dimensiones de la imagen,
en donde el speedup va disminuyendo, aunque los resultados obtenidos son de 4
veces menos en ejecutarse que la versión CPU.
Trabajo Fin de Máster -77- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
7. Conclusiones y líneas futuras
En la presente memoria se ha realizado un estudio sobre la implementación de
un algoritmo de clasificación no supervisado en imágenes multiespectrales sobre
GPUs programables. Concretamente se ha implementado el algoritmo K-Means en
sus versiones serie (C++) y paralela (CUDA) obteniendo una serie de resultados en
base al tiempo y la precisión que han sido comparados. Dichos resultados han sido
obtenidos utilizando el repositorio de imágenes de satélites de Google Maps,
necesarios para evaluar el algoritmo en términos de precisión y rendimiento
computacional en arquitecturas GPU de última generación.
Como resultado, se ha obtenido un detallado estudio de técnicas paralelas para
tratamiento de datos multiespectrales en GPU, realizando contribuciones sustanciales
al estado del arte en la materia dada la falta de implementaciones paralelas (en
particular, en GPUs) de algoritmos de análisis de imágenes multiespectrales en la
literatura actual.
Según los objetivos conseguidos a lo largo del trabajo, las principales
aportaciones del presente estudio pueden resumirse un conjunto de contribuciones
que se enumeran a continuación:
• Después de analizar los resultados de las ejecuciones podemos decir que se
ha conseguido obtener una precisión superior al 80% en los tres casos
estudiados, además se ha conseguido obtener un speedup cercano a 40
respecto a la versión C, por lo que podemos decir que las GPUs son buena
alternativa a la hora de dar soporte de una forma barata a algoritmos
paralelos.
• Conviene destacar, llegados a este punto, las ventajas económicas que la
implementación GPU ofrece con respecto a otras soluciones paralelas como
las basadas en cluster de computadores. En concreto, mientras que el precio
de una GPU de última generación se sitúa en torno a los 400 euros, el precio
de un cluster puede ser mucho mayor, además de resaltar en una serie de
condiciones desfavorables desde el punto de vista de su implantación como
Trabajo Fin de Máster -78- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
módulo de procesamiento a bordo del sensor, con diferentes aspectos que
puedan afectar de forma negativa al payload de la misión (peso, consumo
energético, calentamiento, mantenimiento, etc.) En este sentido, las GPUs
ofrecen una solución mucho más compacta, si bien es cierto que es preciso
realizar un estudio detallado de las condiciones de tolerancia de las GPUs a
requerimientos extremos en cuanto a consumo y sensibilidad a radiación,
necesario a la hora de calibrar la adaptabilidad de esta plataforma hardware
especializada a misiones reales de observación remota de la tierra.
Para concluir este capítulo, planteamos algunas líneas futuras de trabajo
adicionales que serían interesante perseguir en futuras ampliaciones de este trabajo:
• Se ha hablado de que la principal ventaja de la implementación GPU con
respecto al uso de cluster es el aspecto económico; sin embargo no se ha
podido realizar ningún tipo de comparación real entre ambas soluciones en
cuanto resultados y tiempos de ejecución, luego sería interesante realizar
dicho estudio en el futuro.
• Una alternativa interesante a la metodología propuesta viene dada por la
posibilidad de implementar algoritmos paralelos en clusters de GPUs,
aprovechando las ventajas de ambos paradigmas de computación paralela.
• Por otra parte, y con vistas a ampliar el desarrollo de este trabajo, otra línea
futura de trabajo deberá consistir en probar implementaciones GPU en
algoritmos de clasificación supervisada que han sido desarrollados en la
herramienta GoogleCBIR, tales como Maximum Likelihood y Mínimas
distancias.
• Finalmente, se plantea como futura extensión del trabajo desarrollado la
implementación del algoritmo en otras arquitecturas paralelas como FPGAs,
clusters de computación paralela o sistemas GRID, de cara a evaluar las
prestaciones de dicho algoritmo en comparación con otros algoritmos de
clasificación no supervisada también disponibles en forma de
implementación paralela.
Trabajo Fin de Máster -79- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
8. ANEXO I: Manual de CUDA
A continuación vamos a incluir un pequeño manual sobre cómo poner en marcha
una tarjeta gráfica programable, para ello necesitaremos realizar unas
configuraciones en el equipo. Además será necesario tener unas nociones básicas de
las técnicas que podrán ser utilizadas en una programación con CUDA. Finalmente
pasaremos a tratar algunas técnicas de optimización y una serie de herramientas de
desarrollo y de depuración.
8.1. Introducción
Lo primero que debemos de conocer: ¿Qué es CUDA? ¿Para qué sirve?. Pues
bien, CUDA es la arquitectura de cómputo paralelo de propósito general de NVIDIA
que nos va a permitir realizar cómputos de altas prestaciones, de tal manera, que
podamos aprovechar al máximo la potencia de la GPU (Unidad de Procesamiento
Gráfico). Incluye el conjunto de instrucciones de la arquitectura CUDA (ISA) y el
motor de cálculo paralelo en la GPU. Para programar en arquitecturas CUDA, los
desarrolladores podrán utilizar C, uno de los lenguajes de programación más
utilizados de alto nivel, que funcionarán a un gran rendimiento en la utilización de
procesadores donde se encuentren habilitados con CUDA.
Hasta la fecha actual nos podremos encontrar con varios tipos de GPUs, en los
que desarrolladores de software, científicos e investigadores han ido encontrando
usos distintos utilizando una programación CUDA, incluyendo procesamiento de
imágenes de media y alta resolución, al igual pasa con el procesamiento de vídeo, la
biología y la química computacional, la simulación dinámica de fluidos, el análisis
sísmico, y mucho más.
Actualmente en la página oficial de CUDA de NVIDIA 10 nos vamos a poder
encontrar con las herramientas necesarias para configurar nuestro equipo con todo lo
necesario para utilizar CUDA. Para hacerlo más fácil, comentaremos las
configuraciones previas necesarias para Windows y cualquier distribución de Linux.
10 http://www.nvidia.com/object/cuda_home_new.html
Trabajo Fin de Máster -80- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
8.2. Configuraciones necesarias
Windows:
Para poder usar CUDA en nuestro sistema (Microsoft Windows XP, Microsoft
Windows Vista o Microsoft Windows 7), tendremos que instalar o verificar si se
encuentra instalado lo siguiente:
CUDA habilitado para GPU.
Driver del dispositivo.
Software CUDA.
Microsoft Visual Studio 2005 o 2008.
Antes de realizar las instalaciones oportunas, sería importante comprobar si
nuestra tarjeta de NVIDIA pertenece a algunas de estas categorías:
• NVIDIA GeForce 8, 9, 200 y GPUs de la serie 400.
• NVIDIA Tesla.
• NVIDIA Quadro.
Una vez que se ha comprobado que nuestra tarjeta de NVIDIA está en algunas
de las categorías anteriores, ahora ya podremos instalar lo siguiente:
Driver.
CUDA Toolkit: contiene las herramientas necesarias para construir y
compilar una aplicación CUDA en Microsoft Visual Studio.
CUDA SDK: incluye una serie de ejemplos de proyectos que tienen
todas las configuraciones de proyectos necesarias, desarrolladas y válidas
en Microsoft Visual Studio.
Después necesitaremos descargar el software de NVIDIA CUDA y una vez
descargado, será necesario desinstalar otras versiones de NVIDIA CUDA Toolkit en
Trabajo Fin de Máster -81- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
nuestro equipo. Ahora ya podremos instalar CUDA Toolkit, que se instalará por
defecto en C:\CUDA.
A continuación tendremos que definir las siguientes variables de entorno:
• CUDA_BIN_PATH (por defecto lo encontraremos en C:\CUDA\bin o
C:\CUDA\bin64). Contiene los ejecutables del compilador y las
bibliotecas en tiempo de ejecución.
• CUDA_INC_PATH (por defecto lo encontraremos en
C:\CUDA\include). Contiene los ficheros que hay que incluir y que son
necesarios para compilar programas CUDA.
• CUDA_LIB_PATH (por defecto lo encontraremos en C:\CUDA\lib o
C:\CUDA\lib64). Contiene las librerías necesarias para conectar códigos
CUDA.
Por último nos quedará por instalar el CUDA SDK que por defecto se instalará
en C:\Documents and Settings\All Users\Application Data\NVIDIA Corporation\NVIDIA
GPU Computing SDK y contiene el código fuente de muchos problemas de ejemplo y
plantillas para Microsoft Visual Studio.
Linux:
Para poder usar CUDA en nuestro sistema, tendremos que instalar o verificar si
se encuentra instalado lo siguiente:
CUDA habilitado para GPU.
Driver del dispositivo.
Una versión de Linux que soporte el compilador gcc y
Software CUDA (disponible gratuitamente en http://www.nvidia.com/cuda).
Antes de realizar las instalaciones oportunas, sería importante comprobar si
nuestra tarjeta de NVIDIA pertenece a algunas de estas categorías:
Trabajo Fin de Máster -82- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
• NVIDIA GeForce 8, 9, 200 y GPUs de la serie 400.
• NVIDIA Tesla.
• NVIDIA Quadro.
Para comprobar qué adaptador de vídeo es utilizado por nuestro sistema y qué
modelo utiliza, tendremos que consultarlo desde línea de comando escribiendo lo
siguiente:
lspci | grep –i nvidia
Una vez que se ha comprobado que nuestra tarjeta de NVIDIA está en algunas
de las categorías anteriores y es compatible con la versión de Linux, ahora ya
podremos instalar lo siguiente:
Driver (última versión disponible).
CUDA Toolkit: contiene las herramientas necesarias para construir y
compilar una aplicación CUDA. Incluye librerías, herramientas, ficheros
cabeceras y otros recursos.
CUDA SDK: incluye una serie de ejemplos de proyectos que tienen
todas las configuraciones de proyectos necesarias y desarrolladas para
construir programas CUDA.
Con el driver y el software de NVIDIA ya descargados, necesitaremos instalar el
driver. A partir de este momento ya podremos instalar y configurar CUDA Toolkit y
SDK, previamente descargados. Para conseguir una instalación satisfactoria, es
necesario seguir los siguientes pasos:
1. Desinstalar cualquier versión de CUDA Toolkit y CUDA SDK. Para ello
tendremos que eliminar los archivos de /usr/local/cuda y de
$(HOME)/NVIDIA_CUDA_SDK/, los lugares de instalación predeterminados.
En caso de no ser los mismos directorios, ajustarlos.
2. Instalar el CUDA Toolkit ejecutando el archivo descargado. Ejecutarlo
en modo super-usuario. La instalación de CUDA Toolkit por defecto es
Trabajo Fin de Máster -83- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
/usr/local/cuda.
3. Definir las variables de entorno.
a. La variable PATH debe incluir /usr/local/cuda/bin.
b. LD_LIBRARY_PATH debe contener /usr/local/cuda/lib o
/usr/local/cuda/lib64 para sistemas operativos de 32 o 64 bits,
respectivamente.
La forma típica de colocar estos valores en su entorno, son con los
siguientes comandos:
export PATH=/usrlocal/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib:$LD_LIBRARY_PATH
para los sistemas operativos de 32 bit, con lib64 sustituir lib para
sistemas operativos de 64bits como se mencionó anteriormente. Para
realizar los ajustes, colóquelos en ~/.bash_profile.
4. Instale el SDK (que se encuentra en el segundo fichero .run) como un
usuario normal en la ubicación por defecto,
$(HOME)/NVIDIA_GPU_Computing_SDK. Tenga en cuenta que este
lugar es diferente a la ubicación por defecto en las versiones anteriores:
$(HOME)/NVIDIA_CUDA_SDK. La instalación como un usuario
normal evita problemas de acceso.
La versión del CUDA Toolkit puede comprobarse mediante la ejecución de
nvcc –V en un ventana de terminal. El comando nvcc ejecuta el driver compilador
que compila los programas CUDA. Llama al compilador gcc para códigos en C y el
compilador de NVIDIA PTX para el código de CUDA.
NVIDIA incluye programas de ejemplo en el directorio fuente de CUDA SDK.
Usted deberá compilarlos cambiando al directorio de NVIDA_GPU_Computing_SDK/C
y teclear make. Los binarios resultantes se instalarán en el directorio home en
NVIDIA_GPU_Computing_SDK/C/bin/Linux/release.
Trabajo Fin de Máster -84- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
8.3. Compilación programas CUDA.
Necesitaremos crearnos un proyecto en C para Cuda, para ello necesitaremos
crear un proyecto con una serie de ficheros necesarios (ver figura 8.1):
Figura 8.1. Arquitectura paralela Cuda.
• Archivos *.cpp, *.c: serán necesarios para el código que se ejecute en la
CPU.
o Compilador plataforma (gcc, …).
• Archivos *.cu: código para CPU y GPU (kernels).
o Nvcc los separa y compila los kernels GPU.
PTX code: código ensamblador.
.cubin: código objeto (binario)
Con nvcc proporcionado por el Toolkit de CUDA, es el encargado de llevar
todas las tareas necesarias para generar los ejecutables. Además, podrá estar
acompañado de los siguientes argumentos:
• -arch: especifica la compute capability con la que se compila código C a
PTX (conjunto de instrucciones máquinas de CUDA).
Ejemplo: nvcc –o sumavectores sumavectores.cu –arch=sm_13
Trabajo Fin de Máster -85- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
• -deviceemu: modo de emulación, compila todo el código para ser ejecutado
en la CPU, incluyendo los kernels escritos para ser lanzados a la GPU.
Ejemplo: nvcc –o sumavectores_dbg –deviceemu –g sumavectores.cu
• -G: proporciona una herramienta nativa de depuración para CUDA,
ejecutando en modo de depuración los códigos en la GPU, con sus
limitaciones y comportamiento reales, sin las variaciones introducidas por la
emulación.
Ejemplo: nvcc –o sumavectores_dbg –g –G sumavectores.cu
• -c: no se genera binario ejecutable.
8.4. Librerías CUDA.
Nos podemos encontrar con varios tipos de librerías bastantes utilizadas en el
ámbito científico cuando se utiliza CUDA, a continuación expondremos las más
utilizadas:
CUBLAS: implementación BLAS.
o Basic Linear Algebra Subprograms.
CUFFT: implementación de la transformada de Fourier.
o 1D, 2D, 3D Fast Fourier Transform.
CUDPP: Data Parallel Primitives.
o Reducciones, ordenaciones, búsquedas.
NPP: NVIDA Performance Primitives.
o Implementación IPP para GPU.
Trabajo Fin de Máster -86- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
8.5. Arquitectura y modelo de programación
ARQUITECTURA:
La utilización de una arquitectura CPU más una arquitectura GPU, estamos
obteniendo una arquitectura heterogénea (ver figura 8.2).
Figura 8.2 8.2. Arquitectura heterogénea CPU + GPU.
Otro apartado interesante es la utilización de las copias entre las distintas
memorias. . Nos vamos a encontrar con espacios separados de memoria:
Copia a través de bus PCI PCI-e x16.
Punteros no indican explícitamente a qué memoria pertenecen.
Ejemplo: reserva e inicialización de un array de 512 enteros.
Trabajo Fin de Máster -87- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
Ejemplo: copia CPU GPU.
Las primitivas utilizadas son las siguientes:
• cudaMalloc: : asigna size bytes de memoria lineal en el dispositivo y vuelve
en *devPtr un puntero a la memoria asignada. La memoria asignada está
convenientemente preparada para cualquier tipo de variable. cudaMalloc()
devuelve cudaErrorMemory
cudaErrorMemoryAllocation, la a memoria no se borra. cudaMalloc
() devuelve cudaErrorMemoryAllocation
cudaErrorMemoryAllocation, en caso de fallo. La función se
define de la siguiente forma:
cudaError_t cudaMalloc (voiod **devPtr, size_t tamaño)
• cudaMemset: : rellena el primer count byte del área de memoria apuntada por
devPtr con el valor cconstante
value. La función se define de la siguiente
forma:
cudaError_t cudaMemset (voiod *devPtr, int valor, size_t nbytes)
• cudaFree: libera ibera el espacio de memoria apuntado por devPtr , que debe haber
sido devuelto por una llamada previa a cudaMalloc () o cudaMallocPitch () ().
De lo contrario devolverá un error. Si devPtr es 0, no realiza realizará ninguna
operación. CudaFree udaFree () devuelve cudaErrorInvalidDevicePointer en caso de
fallo. La función se define de la siguiente forma:
cudaError_t cudaFree (void *devPtr)
• cudaMemCpy
cudaMemCpy: copia count bytes desde el área de memoria apuntada por src
al área de memoria apuntada por dst, donde kind es uno de los siguientes
Trabajo Fin de Máster -88- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
modificadores: cudaMemcpyHostToHost, cudaMemcpyHostToDevice,
cudaMemcpyDeviceToHost o cudaMemcpyDeviceToDevice, y especifican la
dirección de la copia. Las áreas de memoria no se pueden solapar.
cudaError_t cudaMemcpy (void *dst, const void *src, size_t nbytes, enum
MODELO DE PROGRAMACIÓN:
cudaMemcpyKind kind)
Los kernels son funciones invocadas desde el host y ejecutadas en paralelo sobre
el device empleando GPU threads. Características:
• Paralelismo a nivel de datos.
• Agrupación de threads.
• Block: thread ∈ block.
o Compartir datos.
o Sincronizar ejecución.
• Grid: # blocks.
o Dominio de cálculo.
• Tamaño block y grid se decide en la invocación del kernel.
Otro aspecto utilizado en el modelo de programación son las dimensiones e
identificadores:
• Grid (hasta 2D), block (hasta 3D), tipos dim3.
• Ejemplos (ver figura 8.3):
Trabajo Fin de Máster -89- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
Figura 8.3 8.3. Ejemplos de dimensiones e identificadores.
El tamaño del grid y de los bloques los determina el programador. Se usan las
variables gridDim y blockDim para referenciar la dimensión de grid y bloque,
respectivamente. De esta manera, un thread va a quedar identificado por un
identificador dentificador propio dent dentro ro del bloque al que pertenece y por un identificador del
bloque al que pertenece. Para ello, se utilizarán las variables threadIdx y blockIdx
para referenciar el identificador del thread dentro del bloque y al bloque dentro del
grid, respectivamente.
También ién resulta necesario conocer los aspectos que intervienen en la ejecución
sobre el hardware:
• Device: : compuesta de SMs.
o SM: Stream Multiprocessor.
Shared memory.
o SP: Scalar Processor.
Registers, local mem.
• Kernel (son funciones C con algunas restricciones)
restricciones).
o SP thread.
Trabajo Fin de Máster -90- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
• SIMT
o SM block.
o Device grid.
o WARP:
A través de la creac creación de un kernel, ernel, estamos utilizando el mismo código para
cada uno de los threads que se están ejecutando. Como hemos comentado
anteriormente, posee algunas restricciones que pasamos a mencionarlas:
Deben de devolver un tipo void.
El número de variables por parámetros es fijo.
Son funciones no recursivas.
Solo podrán acceder a la memoria propia de la GPU.
Utiliza variables dinámicas.
Ejemplo de invocación:
32 threads.
Concurrentes SM.
myKernel(..);
Trabajo Fin de Máster -91- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Extensiones básicas:
Modificadores de función:
Indica donde se ejecuta la función: GPU (device) o CPU (host)
__device__: la función debe ejecutarse en el dispositivo.
• Sólo podrá ser llamada por el propio dispositivo.
• No soporta recursividad.
• No podrán declararse variables estáticas dentro de la función.
• La función no puede tener un número variable de argumentos.
__global__: la función es un kernel que debe ejecutarse en el dispositivo.
• Sólo puede ser llamada por el host.
• No soporta recursividad.
• No podrán declararse variables estáticas dentro de la función.
• La función no puede tener un número variable de argumentos.
• La función debe devolver siempre void.
__host__: la función debe ejecutarse en el host.
• Sólo puede ser llamada por el host.
• No puede utilizarse junto con __global__.
Modificadores de función:
Indica en qué parte de la memoria se localiza la variable.
__device__: la variable reside en el dispositivo.
• Requiere que se indique uno de los otros dos modificadores de
variables para indicar dónde exactamente reside la variable en el
dispositivo.
Trabajo Fin de Máster -92- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
__constant__: la variable reside en el espacio de memoria constante del
dispositivo.
• Está viva durante todo el tiempo de ejecución de la aplicación.
• Accesible por todos los threads del grid, así como desde el host.
__shared__: la variable reside en el espacio de memoria compartida del bloque
de threads en el dispositivo.
• Está viva mientras el bloque está vivo.
• Accesible sólo por los threads del bloque.
Herramientas de sincronización:
Todas las ejecuciones de los kernels son asíncronas. El control es devuelto a la
CPU inmediatamente. Los kernels que se ejecuten después de llamadas CUDA
previas tienen que completarse. De la misma manera la llamada cudaMemcpy
síncrona, por lo que el control se devuelve a la CPU después de que las copias se han
completado. Las copias que comienzan después de llamadas CUDA previas tienen
que completarse. Para sincronizar contamos con la siguiente llamada:
cudaThreadSynchronize()
cudaError_t cudaThreadSynchronize(void);
La CPU espera hasta que el device ha completado todas las áreas pendientes
anteriores. CudaThreadSynchronize() retorna error si una de las tareas pendientes
falla.
Existe otra herramienta de sincronización interna a un kernel que se utiliza para
sincronizar hilos dentro de un bloque, esto resulta útil por ejemplo cuando todos los
hilos de un bloque necesitan leer un dato común que debe ser calculado previamente,
suele utilizarse también tras finalizar una escritura en la memoria compartida de
manera que ningún hilo lea de ésta hasta que no se haya finalizado la escritura.
Utilizamos la siguiente llamada:
syncthreads()
cudaError_t syncthreads(void);
Trabajo Fin de Máster -93- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
8.6. Técnicas de Optimización.
Es un apartado a tener en cuenta cuando estamos implementando un código en
CUDA para después aplicarlo en una arquitectura paralela como puede ser el caso de
una GPU. Para ello, comentamos los principales problemas que nos encontraremos
cuando un código se encuentra sin optimizar:
• Paralelización + implementación en CUDA:
o Intensidad aritmética (cálculos frente al BW): a veces resulta
necesario tener que re-calcular un dato antes que re-acceder al dato.
Por ello, es importante optimizar las transferencias de Memoria.
o Maximizar paralelismo a nivel de datos: minimizar la dependencia
entre hilos. Por ello, es importante evitar la divergencia de threads
en un warp.
o Maximizar la utilización de HW: hay que prestar atención en la
elección de los tamaños de bloque y de grid. Además hay que tener
cuidado con la Ocupancia (ocultar latencia memoria).
De los tres problemas señalados anteriormente, que podrán encontrarse
fácilmente cuando nos encontrarnos programando en CUDA, pasaremos a describir
una serie de indicaciones para poderlos contrarrestarlos.
1) Optimizar las transferencias de Memoria.
Reducir la penalización de transferencias de memoria según el tipo de memoria
utilizado:
Memoria global: copias entre memoria CPU – GPU y viceversa. En este tipo de
copias tendremos que simultanear las copias con los cálculos en CPU, es decir,
cuando estemos utilizando la primitiva cudaMemcpy(…) devuelve el control a CPU
sólo al finalizar:
Trabajo Fin de Máster -94- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
La solución sería reservar memoria no paginable y emplear la primitiva
cudaMemcpyAsync(…) en vez de malloc(…) pero sin abusar:
Otro problema dentro de la memoria global son los accesos ccesos coalescentes kernel
GPU – Memoria GPU y viceversa. En este caso los accesos por threads van a ser
agrupados para minimizar el número de transferencias. Vamos a poder tener
segmentos de 32,64 y 128 bits.
Un ejemplo lo podemos tener al realizar la traspuesta de una matriz, en donde las
lecturas serán coalescentes, pero las escrituras NO (ver figura 8.4).
Figura 8.4. Ejemplo: traspuesta de una matriz utilizando memoria global global.
En este caso tendremos que aprovechar la memoria compartida (shared memory)
para solucionarlo.
Trabajo Fin de Máster -95- Sergio Bernabé García

Implementación en GPU del algoritmo KK-Means
Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google MMaps
Memoria compartida compartida: copias entre memoria GPU – on-chip chip GPU y viceversa.
En este caso, tendremos en cada SM (dentro del chip):
• Latencia

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
• En cada SM la memoria está dividida en 16 bloques.
• Las palabras de 32 bits se asignan a bancos sucesivamente.
• Cada bloque permite una lectura/escritura por ciclo.
• Accesos simultáneos al mismo banco producen un conflicto:
o Serialización de los accesos.
o Broadcast desde un banco no penaliza.
Texturas y memoria constante: en memoria global, para lectura:
• Caché 2D en SM: beneficio si coalescencia es problemática de conseguir.
• Permite interpolación de valores por hardware.
• Modos de acceso: Clamp (to edge), Repeat, …
2) Evitar la divergencia de threads en un warp.
Características de los Warp:
• Grupos de 32 threads.
o Concurrentes SM.
• Branching: if, switch, do, for, while.
• Si threads en warp toman distintos caminos serialización.
Evitar divergencias:
• Con divergencia: if (threadIdx.x>4) {}
• Sin divergencia: if (threadIdx.x/WARP_SIZE >= 1) {}
Trabajo Fin de Máster -97- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
3) Ocupancia: maximizar utilización HW.
Si los threads ejecutan una instrucción de acceso a memoria global se pierden
ciclos de reloj. Por ello, es posible “ocultar” esa latencia ejecutando mientras tanto
un warp distinto. La ocupancia viene determinada por la siguiente ecuación:
Ocupancia =
# á
# á
El número máximo de warps que nos podemos encontrar es de 24 warps (1.0 y
1.1) y 32 warps (1.3).
Para ocultar la latencia implica aumentar el tamaño del bloque:
• Limitación: recursos disponibles (registros y shared memory).
o Compilar con flag --ptxas-options=-v
o Compilar con flag –cubin
code{
}
name = my_kernel
lmem = 0
smem = 2048
reg = 10
bar = 0
bincode { … }
const { … }
• Si se supera el número de registros, el thread usará memoria “local”
(muy lenta, en zona de memoria global).
• Si hay reserva dinámica de memoria compartida es necesario sumarla a
smem.
Una de las partes importantes de este apartado, es la elección del tamaño de
bloque y de grid:
Trabajo Fin de Máster -98- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Bloque:
Grid:
o El tamaño del bloque estará entre 192 y 256 threads.
o Aumentar ocupancia sólo significa aumentar el rendimiento si el
kernel está “bandwidth bound”.
o Empezar con #bloques / #SMs > 2 (hasta 8 bloques simultáneamente
en cada SM).
o Idealmente: algoritmo # bloques >> (escalable a futuras GPUs).
o En Fermi distintos SMs podrán ejecutar distintos kernel, de esta
manera se obtendrá un paralelismo a nivel de tarea.
8.7. Herramientas desarrollo y depuración.
• Modo emudebug:
o Opción –deviceemu en nvcc.
o Código de kernels se ejecuta en CPU.
o Posibilidad de depurar con la incorporación de printf();
• CUDA Profiler:
• NEXUS:
o Utiliza HW counters: según compute capability.
o Coalescencia, memory/instruction throughput, divergencia threads …
o Entorno integrado sobre Visual Studio: CUDA, OpenCL, …
o Profiling + depuración sobre GPU.
o Más información en: http://developer.nvidia.com/object/nexus.html.
Trabajo Fin de Máster -99- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
9. Bibliografía
[1] K. Alsabti, S. Ranka, V. Singh. An efficient K-means Clustering Algorithm. In
11th International Parallel Processing Symposium, 1998.
[2] A. Plaza and C.-I. Chang, High Performance Computing in Remote Sensing,
CRC Press, Boca Raton, Fla, USA, 2007.
[3] R. A. Schowengerdt, Remote Sensing: Models and Methods for Image
Processing, Academic Press, New York, NY, USA, 2nd edition, 1997.
[4] D. A. Landgrebe, Signal Theory Methods in Multispectral Remote Sensing,
John Wiley & Sons, New York, NY, USA, 2003.
[5] Smeulders, A.W.M., M. Worring, S. Santini, A. Gupta, R. Jain: Content-based
image retrieval at the end of the early years. IEEE Transactions on Pattern
Analysis and Machine Intelligence 22 (2000) 1349–1380.
[6] J. Vogel, B. Schiele: Performance evaluation and optimization for content-
based image retrieval. Pattern Recognition 39 (2006) 897–909.
[7] H.-W. Yoo, H.-S. Park, D.-S. Jang: Expert system for color image retrieval.
Expert systems with applications 28 (2005) 347–357.
[8] A. Plaza, P. Martinez, R. M. Perez, J. Plaza: A quantitative and comparative
analysis of endmember extraction algorithms from hyperspectral data. IEEE
Transactions on Geoscience and Remote Sensing 42 (2004) 650–663.
[9] A. Plaza, J. A. Benediktsson, J. W. Boardman, et al., “Recent advances in
techniques for hyperspectral image processing,” Remote Sensing of
Environment, vol. 113, supplement 1, pp. S110–S122, 2009.
[10] J. W. Boardman, F. A. Kruse, and R. O. Green,“Mapping Target Signatures
Via Partial Unmixing of Aviris Data”, Proc. VII NASA/JPL Airborne Earth
Science Workshop, pp. 23–26, 1995.
[11] P.-F. Hsieh, D. Landgrebe, Classification of High Dimensional Data. Tesis
Trabajo Fin de Máster -100- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Doctoral, School of Electrical and Computer Engineering, Purdue University,
1998.
[12] S.V. Stehman, “Selecting and Interpreting Measures of Thematic Classification
Accuracy”. Remote Sensing of Environment, vol. 62, pp. 77-89, 1997.
[13] J. Theiler, G. Gisler, “A contiguity-enhanced k-means clustering algorithm for
unsupervised multispectral image segmentation”, en: Proc. SPIE, vol. 3159, pp.
108-118, 1997.
[14] J. A. Richards, Remote Sensing Digital Image Analysis: An Introduction.
Springer-Verlag, Berlin, 1993.
[15] G. Ball and D. Hall,“ISODATA, a novel method of data analysis and
classification”. Tech. Rep. AD-699616, Stanford University, 1965.
[16] S. Bernabé, A. Plaza., “A New System to Perform Unsupervised and
Supervised Classification of Satellite Images from Google Maps”. SPIE Optics
and Photonics, Satellite Data Compression, Communication, and Processing
Conference, San Diego, CA, 2010.
[17] S. Bernabé, A. Plaza, “A New Tool for Information Extraction and Mining
from Satellite Imagery Available from Google Maps Engine”. 3 rd International
Symposium on Recent Advances in Quantitative Remote Sensing
(RAQRS´10), Valencia, Spain, 2010.
[18] A. Plaza, J. Plaza, D. Valencia, “AMEEPAR: Parallel Morphological
Algorithm for Hyperspectral Image Classification in Heterogeneous Networks
of Workstations.” Lecture Notes in Computer Science, vol. 3391, pp. 888-891,
2006.
[19] J. Setoain, M. Prieto, C. Tenllado, A. Plaza, F. Tirado, “Parallel Morphological
Endmember Extraction Using Commodity Graphics Hardware,” IEEE
Geoscience and Remote Sensing Letters, vol. 43, no. 3, pp. 441-445, 2007.
[20] R. M. Pérez, P. Martinez, A. Plaza, P. L. Aguilar. “Systolic Array
Methodology for a Neural Model to Solve the Mixture Problem”, in: Neural
Trabajo Fin de Máster -101- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Networks and Systolic Array Design. Edited by D. Zhang and S.K. Pal. World
Scientific, 2002.
[21] A. Plaza, C.-I. Chang,“Clusters Versus FPGA for Parallel Processing of
Hyperspactral Imagery”The International Journal of High Performance
Computing Applications, vol. 22 – no. 1 – pp.1-7, 2008.
[22] NVIDIA GeForce 8800 GPU Architecture Overview (November 2006
TB-02787-001_v0.9).
[23] NVIDIA CUDA Compute Unified Device Architecture – Programming Guide,
Versión 1.1 (29/11/07).
[24] NVIDIA CUDA. Installation and Verification on Microsoft Windows XP and
Windows Vista (C Edition). (August 2008 | DU-04165-001_v01).
[25] CUDA Technical Training. Volumen 1: Introduction to CUDA Programming
(Prepared and Provided by NVIDIA. Q2 2008).
[26] Zhexue Huang,”A Fast Clustering Algorithm to Cluster Very Large Categorical
Data Sets in Data Mining.” Workshop on Research Issues on Data Mining and
Knowledge Discovery, 1997.
[27] P. Drineas, A. Frieze, R. Kannan, S. Vempala, and V.Vinay, ”Clustering in
large graphs and matrices,” in SODA ’99: Proceedings of the tenth annual
ACM-SIAM symposium on Discrete algorithms. Philadelphia, PA, USA:
Society for Industrial and Applied Mathematics, 1999, pp. 291299.
[28] R. G. Congalton, “Considerations and Techniques for Assessing the Accuracy
of Remotely Sensed Data”, en: Proc. International Geoscience and Remote
Sensing Symposium IGARSS, vol. 3, pp. 1847-1850, 1989.
[29] S. V. Stehman, “Practical Implications of Design-Based Sampling Inference
for Thematic Map Accuracy Assessment”. Remote Sensing of Environment,
vol. 72, pp. 35-45, 2000.
[30] B. M. Steele, J. C. Winne, R. L. Redmond, “Estimation and Mapping of
Trabajo Fin de Máster -102- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
Misclassification Probabilities for Thematic Land Cover Maps”, Remote
Sensing of Environment, vol. 66, pp. 192-202, 1998.
[31] G. Jäger, U. Benz, “Measures of classification accuracy based on fuzzy
similarity”. IEEE Transactions on Geoscience and Remote Sensing, vol. 38,
no. 2, pp. 1462-1467, 2000.
Trabajo Fin de Máster -103- Sergio Bernabé García

Implementación en GPU del algoritmo K-Means para procesamiento paralelo
de imágenes de satélite disponibles en la herramienta Google Maps
10. Publicaciones
Congresos internacionales:
• S. Bernabé and A. Plaza. A New System to Perform Unsupervised and
Supervised Classification of Satellite Images from Google Maps. SPIE Optics
and Photonics, Satellite Data Compression, Communication, and Processing
Conference, San Diego, CA, 2010.
• S. Bernabé and A. Plaza. A New Tool for Information Extraction and
Mining from Satellite Imagery Available from Google Maps Engine. 3 rd
International Symposium on Recent Advances in Quantitative Remote
Sensing (RAQRS´10), Valencia, Spain, 2010.
Próximos congresos internacionales (previsto presentar este trabajo):
• SPIE Optics and Photonics, Satellite Data Compression, Communication, and
Processing Conference, San Diego, CA, 2011.
• 3 rd Workshop on Hyperspectral Image and Signal Processing: Evolution in
Remote Sensing (Whispers), Lisbon, Portugal, 2011.
Trabajo Fin de Máster -104- Sergio Bernabé García