Tesis Viloria-Tona Gold

Instituto Superior Politcnico Jos Antonio Echeverra Facultad de Ingeniera Informtica

Deteccin de rostros en GPUAlgoritmo de Viola-Jones

Trabajo de diploma para optar por el ttulo de Ingeniera en Informtica

Autor:

Jos Luis Viloria Rodrguez([email protected]) Tonathiuh Daz Miranda ([email protected])

Tutor:

MSc. Raisa Socorro Llanes Facultad de Ingeniera Informtica ([email protected]) MSc. Osmany Ferrer Borges Facultad de Ingeniera Informtica ([email protected])

Consultante:

MSc. Omar Antonio Hernndez Duany Facultad de Ingeniera Informtica ([email protected])

Ciudad de La Habana, Cuba Junio, 2011

DECLARACIN DE AUTORADeclaramos que somos los nicos autores de este trabajo y autorizamos al ARP del CITI y al Centro de Estudios de Ingeniera y Sistemas para que hagan el uso que estimen pertinente con este trabajo. Para que as conste firmamos la presente a los _____ das del mes de ______________ del _________.

____________________________Jos Luis Viloria Rodrguez

____________________________Tonathiuh Daz Miranda

____________________________MSc.Raisa Socorro Llanes

____________________________MSc. Osmany Ferrer Borges

Agradecimientos

Tonathiuh Daz Miranda:Les agradezco a todos mis profesores pues fue su dedicacin y sabidura la que hizo de m una persona ms preparada . Le agradezco a mis tutores por su paciencia con nosotros y su invalorable gua , si ellos no lo hubisemos logrado . Le agradezco a la Revolucin y en especial a Taide y al comandante Guillermo que me dieron la oportunidad de ser un profesional . En especial , les agradezco a mis padres por sacrificarse para que yo pudiera llegar hasta aqu . Les agradezco a mis amigos Jos Luis Viloria y Lisandro por haberme ayudado tanto durante la carrera . Gracias a todos. Tona

Jos Luis Viloria Rodrguez:Le agradezco a mi familia por estar siempre conmigo apoyndome y confiando en mi , en especial a mi mam Nury Rodrguez Crdenas , a mi pap Jos Luis Viloria Martnez, a mis abuelos Jos Benito Viloria Vzquez , Esther Martnez Betancourt y a mis hermanos Maylin Viloria Rodrguez , Andy Minsal Rodrguez y a mi hermanita Ketty por todo su cario y amor . A mis tas y en especial a mi nico to Benigno Rodrguez que siempre fue mi ejemplo y mi gua , a mi padrastro Francisco Paco . No se quedan atrs mis hermanos y amigos que aunque algunos no se encuentren conmigo en

estos momentos siempre me han apoyados desde cualquier lugar y en cualquier situacin Ernesto Rivero Artigas , Yaima Corcuera Bernal , David Cardos Reyes y a sus familias que son mas tambin . A mis suegros que son especiales y siempre me han apoyado y sacado de apuros , a mi pareja Claudia Aguilar Ros por apoyarme y comprenderme desde el comienzo. A mis amigos y compaeros que siempre estn a mi lado la mayor parte del da ellos son : Mariela Castillo , Romy Orosco ,Yaima Cabrera, Anllely Daz, Giselle Alfonso, Diana Esther Herrada, DaireneGonzlez, Indira Snchez,Tonathiuh Daz Miranda,Adrian Rodrguez, Jos OrlandoYakelin Rivero, ,Mileneentre otros .A mis profesores que a lo largo de la carrera han sabido cmo hacer de mi lo que hoy soy , los ms allegados son Denis Lester , Yane Fords , Thaimy , Jenny Fajardo , Isis , Raisa , Osmay Ferrer , Ernesto Cabonel , entre otros. Las palabras se quedan cortas con todas las cosas que siento por todos y es por eso que siempre estoy y estar hay para todos dando lo mejor de mi persona . Gracias a todos . Vilo

Dedicatoria

Tonathiuh Daz Miranda:Este trabajo de fin de carrera se lo dedico en especial a mi madre Blanca Estela que dio la vida por m y por mi hermano para que pudisemos estudiar . A mi padre Paulino que no ha muerto por nosotros pero con gusto lo hara . A Taide Conejo que con tanto cario nos ha ayudado mucho en esta vida .

Jos Luis Viloria Rodrguez:Este trabajo de fin de carrera se lo dedico a mi familia en especial a mi madre Nury Rodrguez Crdenas , a mi padre Jos Luis Viloria Martnez , a mi abuelo Jos Benito Viloria Vzquez , a mi abuelo Benigno Rodrguez Rodrguez , a mi abuela Esther Martnez Betancourt y en memoria a mi abuela Pura Crdenas Crdenas que han dado la vida por m . Tambin a mi hermana Maylin Viloria y mi hermano Andy Minsal que siempre he tratado de ser su ejemplo en todo . Tambin se lo dedico a todos los que han luchado por esta revolucin que me ha permitido estudiar y llegar a donde he querido . Gracias por estar siempre a mi lado . Vilo

ResumenEn este trabajo de diploma se presenta la aplicacin de las tecnologas para uso de Propsito General de la Unidad de Procesamiento de Grficos (GPGPU, por sus siglas en ingls) para dar respuesta a la demanda de procesamiento durante la etapa de deteccin de rostros de los sistemas de video-vigilancia inteligente. El objetivo de esta investigacin es reducir el tiempo de deteccin de rostros ya que para ello existen soluciones de hardware econmicamente muy costosas. En el trabajo se propone el uso de la GPU como una alternativa de gran

capacidad de procesamiento a un costo econmicamente bajo. Los lenguajes de programacin para GPU que se utilizaron son Open Computing Language (OpenCL) y Compute Unified Device Architecture (CUDA). Se implement con CUDA C el algoritmo Deteccin de Objetos Viola-Jones y con respecto a OpenCL se utiliz el marco de trabajo OpenCloovision. Este ltimo es basado en C# y OpenCL e incorpora el algoritmo de Deteccin de Objetos Viola-Jones. Las pruebas realizadas arrojaron que ejecutando el algoritmo paralelizado de deteccin de rostros en el GPU se acelera el proceso de deteccin, en

comparacin a cuando esto se hace utilizando el algoritmo secuencial de deteccin en el CPU. Se espera, teniendo en cuenta la significacin de este resultado, que el uso de este tipo de tecnologas paulatinamente se incorpore a las aplicaciones como parte de una solucin de alto desempeo. Palabras claves: CUDA, OpenCL, OpenMP, OpenCV, paralelismo, paralelizacin, programacin paralela, reconocimiento de patrones, tcnicas de paralelismo, video-vigilancia, GPU, GPGPU, Deteccin de Objetos, Deteccin de rostros, Viola-Jones.

AbstractThis paper presents the use of General Purpose Graphics Processor Unit technologies, to solve the problem of processing demand during face detection stage of smart video surveillance systems. The objective of this research is to reduce the face detection time avoiding the use of very costly hardware solutions. The paper proposes the use of the GPU as a low cost alternative of high-performance. Open Computing Language (OpenCL) and Compute Unified Device Architecture (CUDA) were used as GPU programming languages. The algorithm "Object Detection Viola-Jones" was implemented with CUDA C. OpenCloovision framework were used as OpenCL solution, it is based on C# and OpenCL and incorporates the "Object Detection Viola-Jones" algorithm too. The tests showed that running the face detection parallelized algorithm on the GPU accelerates the process of detection, compared when this is done using the sequential detection algorithm on the CPU. It is expected by the significance of this result that using of these technologies be gradually incorporated into applications as part of a high performance solution. Key words: CUDA, OpenCL, OpenMP, OpenCV, parallelism, parallelization, parallel programming, pattern recognition, parallel techniques, video surveillance, GPU, GPGPU, Object Detection, Face Detection, Viola-Jones

ndice Introduccin ........................................................................ 1 Captulo 1 Fundamentos tericos ..................................... 31.1 RECONOCIMIENTO DE PATRONES EN IMGENES ................................................................................ 3 Etapas del reconocimiento de patrones .................................................................................. 3 Enfoques del Reconocimiento de Patrones ............................................................................. 5 Problemas de Reconocimiento de Patrones ........................................................................... 6 Aplicaciones............................................................................................................................ 7 1.1.1 1.1.2 1.1.3 1.1.4 1.2 1.3

PROCESAMIENTO DE IMGENES ........................................................................................................ 8 DETECCIN DE ROSTRO..................................................................................................................... 8 Framework Viola-Jones para la deteccin de objetos y entrenamiento de clasificadores ..... 9

1.3.1 1.4

PROGRAMACIN PARALELA .............................................................................................................11 Modelo conceptual del paralelismo .......................................................................................11 Niveles de aplicacin del paralelismo ...................................................................................13

1.4.1 1.4.2 1.5

DISEO DE ALGORITMOS PARALELOS [7] .........................................................................................13 Particin ................................................................................................................................14 Comunicacin ........................................................................................................................15 Agrupacin ............................................................................................................................17 Asignacin .............................................................................................................................19

1.5.1 1.5.2 1.5.3 1.5.4 1.6

TENDENCIAS Y TECNOLOGAS ACTUALES .........................................................................................21 OpenCV [8] ...........................................................................................................................22 OpenCL..................................................................................................................................22 CUDA ....................................................................................................................................23 OpenCloovision .....................................................................................................................24

1.6.1 1.6.2 1.6.3 1.6.4 1.7

PROGRAMACIN PARALELA UTILIZANDO CPU Y GPU ....................................................................25 Comparacin del CPU y el GPU ...........................................................................................25 OpenMP .................................................................................................................................27 CUDA ....................................................................................................................................29 OpenCL..................................................................................................................................36

1.7.1 1.7.2 1.7.3 1.7.4 1.8

CONCLUSIONES ................................................................................................................................43

Captulo 2 Descripcin de la solucin propuesta .......... 442.1 FUNCIONAMIENTO DEL ALGORITMO DE DETECCIN DE OBJETOS DE VIOLA-JONES. .........................44 Implementacin en OpenCV ..................................................................................................45 2.1.1

2.2

DETECCIN DE PUNTOS DE FUEGO EN EL ALGORITMO ......................................................................46 Integral de la Imagen.............................................................................................................46 Clculo de las caractersticas ...............................................................................................48 Conversin de la imagen de RGB a YUV ..............................................................................50

2.2.1 2.2.2 2.2.3 2.3

ALGORITMO PROPUESTO ..................................................................................................................51 CUDA ....................................................................................................................................51 OpenCLOpenCloovision ........................................................................................................56

2.3.1 2.3.1 2.4

HERRAMIENTAS PARA EL DESARROLLO ...........................................................................................61 OpenCV .................................................................................................................................61 CUDA ....................................................................................................................................61 OpenCL..................................................................................................................................63 OpenCloovision .....................................................................................................................64

2.4.1 2.4.2 2.4.3 2.4.4 2.5

CONCLUSIONES ................................................................................................................................64

Captulo 3 Anlisis de los experimentos ........................ 663.1 EXPERIMENTO 1 ...............................................................................................................................66 CUDA- OpenCL ....................................................................................................................67 Conclusiones..........................................................................................................................72 3.1.1 3.1.2 3.2

EXPERIMENTO 2 ...............................................................................................................................72 CUDA- OpenCL ....................................................................................................................72 Conclusiones..........................................................................................................................75

3.2.1 3.2.2 3.3

EXPERIMENTO 3 ...............................................................................................................................76 CUDA- OpenCL ....................................................................................................................76 Conclusiones..........................................................................................................................77

3.3.1 3.3.2 3.4

ANLISIS DE COSTO BENEFICIO ........................................................................................................77 Conclusiones..........................................................................................................................80

3.4.1 3.5

CONCLUSIONES ................................................................................................................................80

Conclusiones ..................................................................... 82 Recomendaciones ............................................................ 84 Referencias Bibliogrficas ............................................... 85 Glosario de trminos ........................................................ 87 Anexo 1 .............................................................................. 88

Anexo 2 .............................................................................. 90

NDICE DE TABLASTABLA1 ACCESO A MEMORIA USANDO CUDA ............................................................................... 31 TABLA 2 DISPOSITIVOS-CUDA HABILITADOS CON CAPACIDAD DE CLCULO, MULTIPROCESADORES Y NCLEOS CUDA ........................................................................... 33 TABLA 3 MUESTRA LA RESERVA DE MEMORIA EN REGIONES Y LAS CARACTERSTICAS DE ACCESO ...................................................................................................................................... 41 TABLA 4 COSTO POR RENDIMIENTO (X) .......................................................................................... 78

ndice de figurasFIGURA 1.1 ESQUEMA GENERAL DE UN SISTEMA DE RECONOCIMIENTO DE PATRONES 5 FIGURA 1.2 ESQUEMA DE LOS ENFOQUES Y PROBLEMAS ......................................................... 7 FIGURA 1.3 FLUJO DEL CLASIFICADOR EN CASCADA. ............................................................... 11 FIGURA 1.4 ETAPAS EN EL DISEO DE ALGORITMOS PARALELOS........................................ 14 FIGURA 1.5 INTEGRACIN DE OPENCL CON TECNOLOGAS ORIENTADAS AL GRFICO POR COMPUTADORA. ................................................................................................................... 23 FIGURA 1.6 INTEGRACIN DE CUDA CON TECNOLOGAS ORIENTADAS AL GRFICO POR COMPUTADORA. ............................................................................................................................. 24 FIGURA 1.7 ESTRUCTURA GENERAL DEL CPU Y GPU [13] ......................................................... 27 FIGURA 1.8 HISTORIAL DE LANZAMIENTOS DEL API OPENMP [15] ......................................... 28 FIGURA 1.9 MODELOS DE FORK-JOIN .............................................................................................. 28 FIGURA 1.10 VISTA GENERAL EN CAPAS DE LOS ELEMENTOS QUE COMPONEN A CUDA [1] ......................................................................................................................................................... 30 FIGURA 1.11 MUESTRA CMO LUCE EL NDRANGE Y CMO EST CONSTITUIDO ........... 39 FIGURA 1.12 MODELO DE LA PLATAFORMA, UN HOST CON UNO O MS DISPOSITIVOS DE COMPUTO, TANTO GPU COMO CPU E INCLUSO OTROS. ........................................... 40 FIGURA 1.13 DIAGRAMA DE CLASES DE OPENCL REPRESENTADO CON UML ................... 43 FIGURA 2.1 PROCESO DE DETECCIN DE ROSTRO EN UNA IMAGEN ................................... 45 FIGURA 2.2 EVALUACIN DE CARACTERSTICAS USANDO LA INTEGRAL DE LA IMAGEN ............................................................................................................................................................. 46 FIGURA 2.3 PROCESO DE LA INTEGRAL DE LA IMAGEN. A) EN CPU. B) EN GPU ................ 48 FIGURA 2.4 CLCULO DE LA INTEGRAL DE LA IMAGEN POR LOS EJES (X, Y) .................... 48 FIGURA 2.5 FORMAS DE PARALELIZAR EL CLCULO DE CARACTERSTICAS ..................... 49 FIGURA 2.6 RESULTADO DEL MACHEO DE LA IMAGEN CONTRA LA CASCADA EN SU PRIMERA ETAPA ............................................................................................................................. 50 FIGURA 2.7 RESULTADO DEL MACHEO DE LA IMAGEN CONTRA LA CASCADA EN DIFERENTES ETAPAS ................................................................................................................... 50 FIGURA 2.8 DISTRIBUCIN DEL ALGORITMO EN CAPAS ............................................................ 52 FIGURA 2.9 INTEGRAL DE LA IMAGEN POR LAS FILAS ............................................................... 53 FIGURA 2.10 SALIDA DE LA INTEGRAL DE LAS FILAS .................................................................. 54 FIGURA 2.11 INTEGRAL DE LA IMAGEN POR LAS COLUMNAS .................................................. 55 FIGURA 2.12 SALIDA DE LA INTEGRAL DE LAS COLUMNAS ...................................................... 55 FIGURA 2.13 MUESTRA LA DISTRIBUCIN DEL KERNEL DE INTERCAMBIO DE CANALES 58

FIGURA 2.14 MUESTRA LA DISTRIBUCIN DEL KERNEL DE CONVERSIN DE FORMATO ............................................................................................................................................................. 58 FIGURA 2.15 EJEMPLO VISUAL DE CMO LOS KERNELS PROCESAN LA IMAGEN ............ 59 FIGURA 2.16 DETECIN DE ROSTRO ................................................................................................ 60

ndice de grficosGRFICO 3.1 ALGORITMO EN CUDA EN DISTINTOS DISPOSITIVOS CON UNA IMAGEN DE 320 X 240 ........................................................................................................................................... 67 GRFICO 3.2 ALGORITMO EN OPENCL EN DISTINTOS DISPOSITIVOS CON UNA IMAGEN DE 320 X 240 .................................................................................................................................... 68 GRFICO 3.3 ALGORITMO EN CUDA EN DISTINTOS DISPOSITIVOS CON UNA IMAGEN DE 640 X 480 ........................................................................................................................................... 69 GRFICO 3.4 ALGORITMO EN OPENCL EN DISTINTOS DISPOSITIVOS CON UNA IMAGEN DE 640 X 480 .................................................................................................................................... 70 GRFICO 3.5 ALGORITMO EN CUDA EN DISTINTOS DISPOSITIVOS CON UNA IMAGEN DE 640 X 1440 ......................................................................................................................................... 71 GRFICO 3.6 ALGORITMO EN OPENCL EN DISTINTOS DISPOSITIVOS CON UNA IMAGEN DE 640 X 1440 .................................................................................................................................. 71 GRFICO 3.7 DETECCIN DE 40 ROSTROS EN 3 IMGENES DE DISTINTO TAMAO CON CUDA .................................................................................................................................................. 73 GRFICO 3.8 DETECCIN DE 40 ROSTROS EN 3 IMGENES DE DISTINTO TAMAO CON OPENCL ............................................................................................................................................. 74 GRFICO 3.9 DETECCIN DE 160 ROSTROS EN 2 IMGENES DE DISTINTO TAMAO CON CUDA .................................................................................................................................................. 74 GRFICO 3.10 DETECCIN DE 160 ROSTROS EN 2 IMGENES DE DISTINTO TAMAO CON OPENCL ................................................................................................................................... 75 GRFICO 3.11 DETECCIN DE ROSTROS EN VIDEO CON CUDA ............................................. 76 GRFICO 3.12 DETECCIN DE ROSTROS EN VIDEO CON OPENCL ........................................ 77 GRFICO 3.13 RENDIMIENTO DEL ALGORITMO EN LOS DIFERENTES DISPOSITIVOS ..... 79 GRFICO 3.14 PRECIO POR DISPOSITIVO HARDWARE .............................................................. 79 GRFICO 3.15 COSTO DADO POR EL PRECIO/ RENDIMIENTO EN (X) .................................... 80

Deteccin de rostro en GPU Algoritmo Viola-Jones

Introduccin

IntroduccinEl creciente uso de sistemas de video-vigilancia por el MINIT ha generado un aumento del gasto de la institucin en recursos materiales y humanos. Esta situacin ha propiciado la necesidad de optimizar el empleo de estos recursos mediante el desarrollo de aplicaciones y herramientas informticas, para posibilitar el anlisis inteligente de los videos. La existencia de un sistema de video-vigilancia, con infraestructura de red territorial y alcance nacional, que emplea cmaras IP enlazadas en red constituye una fortaleza para la implementacin y despliegue de estas aplicaciones y herramientas con efectividad. Hoy en da la video-vigilancia inteligente tienes dos modos de operar: el modo on-line y modo off-line. El anlisis de video requiere la aplicacin de algoritmos de reconocimiento de patrones como es el caso de la identificacin y deteccin de rostros, deteccin de objetos abandonados, identificacin de chapas, entre otros. Estos algoritmos son excesivamente consumidores de tiempo por lo que las respuestas del anlisis son tardas. Se identifica en lo planteado anteriormente que, la situacin problemtica es la respuesta tarda de los algoritmos de reconocimiento de patrones en la video-vigilancia inteligente. Con respecto a este tema el MININT ha manifestado su inters en que se priorice el trabajo en la deteccin de rostros. El problema a resolver es: Cmo lograr mejorar el tiempo de respuesta del algoritmo para deteccin de rostros en video? El objeto de estudio comprende el anlisis de: los algoritmos de reconocimiento de patrones, el tratamiento de imgenes y la programacin paralela. El campo de accin comprende el estudio del algoritmo de deteccin de rostro y el estudio de la programacin paralela en GPU.

1


Introduccin Incrementar la eficiencia de los algoritmos tendr un impacto positivo en la

seguridad y el orden del pas, al disminuir el tiempo de anlisis de los videos de vigilancia. La adecuada seleccin de las tecnologas y su uso correcto, le permitira al pas aprovechar al mximo la capacidad de cmputo disponible y reducir gastos econmicos innecesarios. El objetivo general de este trabajo de diploma es, mejorar la eficiencia del algoritmo para la deteccin de rostros en la video-vigilancia con el uso de las tcnicas de paralelismo. Este objetivo general requiere del cumplimiento de los siguientes objetivos especficos: 1. Implementar el uso de recursos adicionales para no sobrecargar el CPU. 2. Disear el algoritmo de deteccin facial de forma paralelizada con el uso de la programacin GPGPU 3. Analizar las tecnologas de GPGPU ms utilizadas en la actualidad. Tareas desarrolladas para cumplir los objetivos: 1. Estudiar y analizar los diferentes mtodos, tcnicas y bibliotecas para la programacin paralela. 2. Estudiar y comparar las tecnologas de GPGPU ms utilizadas en la actualidad. 3. Seleccionar las tecnologas de GPGPU a utilizar para la implementacin de la solucin. 4. Estudiar el algoritmo de deteccin de objeto de Viola-Jones. 5. Estudiar y determinar los puntos de fuego del algoritmo de deteccin de objeto de Viola-Jones. 6. Disear e implementar el algoritmo utilizando las tecnologas GPGPU seleccionadas. 7. Disear los experimentos. 8. Analizar los resultados de los experimentos.

2


Fundamentos tericos

Captulo 1 Fundamentos tericosEn este captulo se tratar el tema de los fundamentos tericos a tener en cuenta para poder dar solucin al problema en cuestin. Algunos de los elementos ms importantes que se desarrollarn son: el reconocimiento de patrones, el procesamiento de imgenes y la programacin paralela. Tambin se identificarn y analizarn las tecnologas actuales y se ver el framework de Viola-Jones para la deteccin de objetos y entrenamiento de clasificadores.

1.1 Reconocimiento de patrones en imgenesQu es el reconocimiento de patrones? Son los medios por los cuales se puede interpretar el mundo [1]. El reconocimiento de patrones es la ciencia que se encarga de la descripcin y clasificacin (reconocimiento) de objetos, personas, representaciones, etc. [2]. Siendo la mquina capaz de procesar e identificar objetos de inters en una imagen o en imgenes de flujo continuo (video). Qu es un patrn? Un patrn no es ms que un modelo o gua, ubicada en una imagen proyectada o digitalizada. 1.1.1 Etapas del reconocimiento de patrones Principales etapas del reconocimiento de patrones descritas en [3]: Etapa de pre-procesamiento: En esta etapa es donde se limpian los ruidos de la imagen, para una mejor ejecucin de las siguientes etapas. Etapa de segmentacin: Durante esta etapa los objetos que conforman la imagen son identificados y aislados, facilitando la extraccin de

caractersticas.

3


Fundamentos tericos Etapa de extraccin de caractersticas: Las caractersticas ms

representativas del objeto son extradas para mejorar el trabajo durante la etapa de clasificacin (reconocimiento) y la discriminacin entre las clases. Etapa de reconocimiento: La frontera conceptual entre la extraccin de caractersticas y la clasificacin es algo difusa: un extractor de

caractersticas ideal produce una representacin tal, que el trabajo del clasificador es trivial; por otro lado, un clasificador omnipotente no necesita la ayuda de un extractor de caractersticas sofisticado. El grado de dificultad de la clasificacin depende de la variabilidad entre los valores de las caractersticas para objetos en la misma categora y los valores de los objetos de categoras diferentes. Esquema general de un sistema de reconocimiento de patrones El esquema de un sistema de reconocimiento de patrones consta de varias etapas relacionadas entre s (los resultados de una etapa pueden modificar los parmetros de etapas anteriores).La Figura 1.1 muestra un esquema genrico de un sistema de reconocimiento de patrones.

4


Fundamentos tericos

Figura 1.1 Esquema general de un sistema de reconocimiento de patrones

1.1.2 Enfoques del Reconocimiento de Patrones Los principales enfoques del reconocimiento de patrones definidos en [1] son: Reconocimiento Estadstico de Patrones. Este enfoque se basa en la teora de probabilidad y estadstica. Supone que se tiene un conjunto de medidas numricas con distribuciones de probabilidad conocidas y a partir de ellas se hace el reconocimiento. Reconocimiento Sintctico de Patrones. Este enfoque se basa en encontrar las relaciones estructurales que guardan los objetos de estudio, utilizando la teora de lenguajes formales. El objetivo es construir una gramtica que describa la estructura del universo de objetos. Redes Neuronales. Este enfoque supone que tiene una estructura de neuronas interconectadas que se estimulan unas a otras, las cuales pueden ser entrenadas para dar una cierta respuesta cuando se le presentan determinados valores.

5


Fundamentos tericos Reconocimiento Lgico Combinatorio de Patrones. Este enfoque se basa en la idea de que la modelacin del problema debe ser lo ms cercana posible a la realidad del mismo, sin hacer suposiciones que no estn fundamentadas. Uno de los aspectos esenciales del enfoque es que las caractersticas utilizadas para describir a los objetos de estudio deben ser tratadas cuidadosamente. 1.1.3 Problemas de Reconocimiento de Patrones Carrasco describe en [1] como los principales problemas de reconocimientos de patrones los siguientes: Seleccin de variables. Consiste en determinar cul es el conjunto de caractersticas ms adecuado para describir a los objetos. Clasificacin Supervisada. Consiste en clasificar nuevos objetos basndose en la informacin de una muestra ya clasificada. Clasificacin no supervisada. Consiste en dada una muestra no clasificada encontrar la clasificacin de la misma. En la Figura 1.2 se muestra el esquema de los diferentes enfoques y problemas antes vistos.

6


Fundamentos tericos

Figura 1.2 Esquema de los enfoques y problemas

1.1.4 Aplicaciones Si bien el margen de aplicaciones es muy amplio, las ms importantes estn relacionadas con la visin y audicin de una mquina, de forma anloga a los seres humanos. Algunos campos de aplicacin que se ejemplifican en [3] y [2] son: Reconocimiento de caracteres. Cartografa. Aplicaciones mdicas. Reconocimiento de persona por diferentes vas como (voz, iris, rostro, huella dactilar, etc.) Prediccin de magnitudes mximas de terremotos. Bsqueda de petrleo. Determinacin de factores que inciden en la lactancia materna.

Algunas de estas aplicaciones no se consideran estrictamente reconocimiento de patrones, pero estn relacionadas con el tema.

7


Fundamentos tericos

1.2 Procesamiento de imgenesEl procesamiento digital de imgenes se puede definir de manera sencilla como un conjunto de procedimientos que se realizan sobre una escena para su almacenamiento, transmisin, reconocimiento, anlisis e interpretacin [3]. Se considera que existen tres tipos de procesos dentro del procesamiento de imgenes: bajo, medio y alto nivel. Los procesos a bajo nivel involucran operaciones primitivas tales como pre procesado de imgenes para la reduccin del ruido, mejora del contraste y perfilado de la imagen, entre otras. Un proceso a bajo nivel se caracteriza por el hecho de que tanto la entrada, como la salida, son imgenes. El procesamiento en el nivel medio sobre las imgenes, involucra tareas tales como: segmentacin (particionar una imagen en regiones u objetos), descripcin de objetos para llevarlos hacia una forma conveniente para el procesamiento por la computadora y clasificacin o reconocimiento de los objetos individuales. Un proceso de nivel medio se caracteriza por el hecho de que sus entradas son generalmente imgenes pero sus salidas son atributos extrados de esas imgenes (por ejemplo: bordes y contornos). Finalmente el procesamiento a alto nivel involucra el darle sentido al conjunto de objetos reconocidos y llevar a cabo funciones cognitivas normalmente asociadas con la visin. El procesamiento de flujo continuo (video), no es ms que el procesamiento de una imagen tras otra, donde esa continuidad representa el movimiento y ocurrencia de eventos de una imagen a otra.

1.3 Deteccin de rostroLa deteccin de rosto es una tarea computacional que intenta, de manera rpida y robusta, detectar caras en imgenes o videos. Es la primera y una de las ms 8


Fundamentos tericos importantes etapas en el proceso de reconocimiento de rostros, el

reconocimiento de expresiones faciales y otros. Los rostros, al no ser un objeto definible fcilmente, y adems por ser tan variables sus caractersticas, enfrentan entonces mayor dificultad para ser detectarlos. Es por esto que, el detector de rostros debe ser lo suficientemente robusto como para detectar rostros de distintos tamaos, edades, gneros, colores, con distintos cabellos, gafas, barbas o bigotes. Sin dejar de lado el que stos puedan tener distintos fondos e iluminaciones. Es as que dada una imagen cualquiera, la deteccin de rostros se define como la determinacin de la posicin y tamao de todos los rostros que en ella pueda haber. Cuando se habla de deteccin en tiempo real o video, entonces se intentan detectar los rostros en cada uno de los cuadros del video. La deteccin y reconocimiento de rostros, son una tarea que los humanos realizamos a diario. 1.3.1 Framework Viola-Jones para la deteccin de objetos y entrenamiento de clasificadores Los ingenieros Paul Viola de Mitsubishi Electric ResearchLabs y Michael Jones de Compaq CRL durante el desarrollo de un algoritmo de deteccin de rostros en una imagen con un costo computacional muy bajo, publicaron el da 13 de julio de 2001 un framework que constaba de dos partes principales: un algoritmo de deteccin de objetos que emplea la clasificacin en cascada y un entrenador de clasificadores basado en AdaBoost [4]. El algoritmo alcanza altas tasas de deteccin y, a diferencia de otros algoritmos que utilizan informacin auxiliar, como: el color del pixel o diferencias en la secuencia de video, procesa solamente la informacin presente en una imagen en escala de grises (Formato YUV).

9


Fundamentos tericos El algoritmo para la deteccin no utiliza directamente la imagen sino una representacin de la misma llamada imagen integral. La obtencin de esta representacin se logra con tan slo unas pocas operaciones por pixel. Hecho esto, buscar caractersticas en subregiones de la nueva imagen se transforma en una tarea de tiempo constante, sin importar la escala de la subregin ni posicin de la misma [4]. Para determinar si en una imagen se encuentra un rostro o no, el algoritmo divide la imagen integral en subregiones de tamao variable y utiliza una serie de clasificadores (etapas), cada uno con un conjunto de caractersticas visuales. Este tipo de clasificacin es denominada clasificacin en cascada [4]. En cada etapa se determina si la subregin es un rostro o no. Si la subregin es aceptada como rostro entonces es evaluada por la siguiente etapa (ms rigurosa) y si no es discriminada. La clasificacin en cascada garantiza la discriminacin rpida de subregiones que no sean un rostro. Esto significa un ahorro considerable de tiempo, pues no se procesarn innecesariamente subregiones de la imagen que con certeza no contengan un rostro y solamente se invertir tiempo en aquellas que posiblemente s contengan Figura 1.3. Al culminar slo llega la imagen que aprueba todas las etapas. Este mtodo, segn [4], tiene una tasa de verdaderos-positivos de 99.9%, mientras que tiene una tasa de falsos-positivos de 33.3%.

10


Fundamentos tericos

Figura 1.3 Flujo del clasificador en cascada.

1.4 Programacin paralelaEl paralelismo en aplicaciones informticas a veces se ve con poca relevancia para el programador medio. En [5] se realiza un estudio de las tendencias en las aplicaciones informticas que muestra que una visin clsica ya no es sostenible. El paralelismo se ha estado expandiendo en las ltimas dcadas y la programacin en paralelo se est convirtiendo en una buena opcin para la optimizacin de las aplicaciones. 1.4.1 Modelo conceptual del paralelismo Se plantea en [6] que el paradigma de diseo y programacin difiere del utilizado para disear y programar aplicaciones secuenciales en: Una buena estrategia de divisin del problema puede determinar la eficiencia de un algoritmo paralelo. Es importante considerar la disponibilidad de hardware.

Respecto a los mecanismos de comunicacin entre procesos, existen dos paradigmas de computacin paralela: Memoria compartida. Pasaje de mensajes.

Existen tambin modelos hbridos, que combinan ambas tcnicas. Las dependencias entre tareas imponen limitaciones al nivel de paralelismo [6]: 11


Fundamentos tericos Dependencia de datos. Sincronizaciones.

No siempre es una buena decisin partir de un algoritmo secuencial (paralelizar una aplicacin). En ocasiones ser necesario disear un nuevo algoritmo muy diferente.

Resumiendo las etapas de diseo de aplicaciones paralelas [6]: Identificar el trabajo que puede hacerse en paralelo. Dividir el trabajo y los datos entre los procesadores. Resolver los accesos a los datos, las comunicaciones entre procesos y las sincronizaciones. Descomposicin Asignacin Orquestacin Mapeo Descomposicin Identifica concurrencia y decide el nivel y la forma en la cual se explotar. Cantidad de tareas. Tareas estticas o dinmicas. Criterios de divisin y utilizacin de recursos. Asignacin Asigna datos a procesos Criterios de asignacin: Estticos o dinmicos. Balance de cargas. Reduccin de costos de comunicacin y sincronizacin. Orquestacin Decisin sobre parmetros de arquitectura, modelo de

programacin, lenguaje o biblioteca a utilizar. Estructuras de datos, localidad de referencias. Optimizar comunicacin y sincronizacin. Mapeo (Scheduling) Asignacin de procesos a procesadores. 12


Fundamentos tericos Criterios de asignacin: Performance. Utilizacin. Reduccin de costos de comunicacin y sincronizacin. 1.4.2 Niveles de aplicacin del paralelismo El paralelismo puede aplicarse [6]: 1. A nivel intrainstruccin (hardware, pipelines). 2. A nivel interinstruccin (SO, optimizacin de cdigo, compilador). 3. A nivel de procedimientos o tareas. 4. A nivel de programas o trabajos. Nos enfocaremos en los niveles 3 y 4 de aplicacin de las tcnicas de paralelismo (enfocado al diseo y programacin de algoritmos paralelos).

1.5 Diseo de algoritmos paralelos [7]Disear algoritmos paralelos no es tarea fcil y es un proceso altamente creativo. Inicialmente se deben explorar los aspectos independientes de la mquina y los especficos a la mquina deben ser dejados para ms tarde. El diseo involucra cuatro etapas las cuales se presentan como secuenciales pero que en la prctica no lo son Figura 1.4. 1) Particin: El cmputo y los datos sobre los cuales se opera se descomponen en tareas. Se ignoran aspectos como el nmero de procesadores de la mquina a usar y se concentra la atencin en explotar oportunidades de paralelismo. 2) Comunicacin: Se determina la comunicacin requerida para coordinar las tareas. Se definen estructuras y algoritmos de comunicacin.

13


Fundamentos tericos 3) Agrupacin: El resultado de las dos etapas anteriores es evaluado en trminos de eficiencia y costos de implementacin. De ser necesario, se agrupan tareas pequeas en tareas ms grandes. 4) Asignacin: Cada tarea es asignada a un procesador tratando de maximizar la utilizacin de los procesadores y de reducir el costo de comunicacin. La asignacin puede ser esttica (se establece antes de la ejecucin del programa) o a tiempo de ejecucin mediante algoritmos de balanceo de carga.

Figura 1.4 Etapas en el diseo de algoritmos paralelos.

1.5.1 Particin En la etapa de particin se buscan oportunidades de paralelismo y se trata de subdividir el problema lo ms finamente posible, es decir; que la granularidad sea fina1. Evaluaciones futuras podrn llevar a aglomerar tareas y descartar

1

Un grano es una medida del trabajo computacional a realizar.

14


Fundamentos tericos ciertas posibilidades de paralelismo. Una buena particin divide tanto los cmputos como los datos. Hay dos formas de proceder con la descomposicin. Descomposicin del dominio: el centro de atencin son los datos. Se determina la particin apropiada de los datos y luego se trabaja en los cmputos asociados con los datos. Descomposicin funcional: es el enfoque alternativo al anterior. Primero se descomponen los cmputos y luego se ocupa de los datos. Estas tcnicas son complementarias y pueden ser aplicadas a diferentes componentes de un problema e inclusive al mismo problema para obtener algoritmos paralelos alternativos. Al particionar se deben tener en cuenta los siguientes aspectos: 1. El nmero de tareas debe ser por lo menos un orden de magnitud superior al nmero de procesadores disponibles para tener flexibilidad en las etapas siguientes. 2. Hay que evitar cmputos y almacenamientos redundantes; de lo contrario el algoritmo puede ser no extensible a problemas ms grandes. 3. Hay que tratar de que las tareas sean de tamaos equivalentes ya que facilita el balanceo de la carga de los procesadores. 4. El nmero de tareas debe ser proporcional al tamao del problema. De esta forma el algoritmo ser capaz de resolver problemas ms grandes cuando se tenga ms disponibilidad de procesadores. En otras palabras, se debe tratar de que el algoritmo sea escalable; que el grado de paralelismo aumente al menos linealmente con el tamao del problema. 5. Considere alternativas de paralelismo en esta etapa ya que pueden flexibilizar etapas subsecuentes. 1.5.2 Comunicacin Las tareas definidas en la etapa anterior, en general, concurrentemente pero no independientemente. Los pueden correr deben 15 ser

datos


Fundamentos tericos transferidos o compartidos entre tareas y esto es lo que se denomina la fase de comunicacin. La comunicacin requerida por un algoritmo puede ser definida en dos fases. Primero se definen los canales que conectan las tareas que requieren los datos con las que los poseen. Despus se especifica la informacin o mensajes que deben ser enviado y recibidos por estos canales. La forma de atacar la comunicacin entre tareas vara dependiendo del tipo de mquina en que se implementar el algoritmo, memoria distribuida o memoria compartida. En ambientes de memoria distribuida, cada tarea tiene una identificacin nica e interactan enviando y recibiendo mensajes entre estas. Las libreras ms conocidas para implementar el pase de mensajes en ambientes de memoria distribuida son: MPI (MessagePassing Interface) y PVM (Parallel Virtual Machine). En ambientes de memoria compartida no existe la nocin de pertenencia y el envo de datos no se da como tal. Todas las tareas comparten la misma memoria. Semforos, semforos binarios, barreras y otros mecanismos de sincronizacin son usados para controlar el acceso a la memoria compartida y coordinar las tareas. En esta etapa hay que tener en cuenta los siguientes aspectos: 1. Todas las tareas deben efectuar aproximadamente el mismo nmero de operaciones de comunicacin. Si esto no se da, es muy probable que el algoritmo no sea extensible a problemas mayores ya que habrn cuellos de botella. 2. La comunicacin entre tareas debe ser tan pequea como sea posible. 3. Las operaciones de comunicacin deben poder proceder

concurrentemente.

16


Fundamentos tericos 4. Los cmputos de diferentes tareas deben poder proceder

concurrentemente. 1.5.3 Agrupacin En las dos etapas anteriores se particion el problema y se determinaron los requerimientos de comunicacin. El algoritmo resultante es an abstracto en el sentido de que no se tom en cuenta la mquina sobre el cual correr. En esta etapa se va de lo abstracto a lo concreto y se revisa el algoritmo obtenido tratando de producir un algoritmo que corra eficientemente sobre cierta clase de computadores. En particular se considera si es til agrupar tareas y si vale la pena replicar datos y/o cmputos. En la fase de particin se trat de establecer el mayor nmero posible de tareas con la intensin de explorar al mximo las oportunidades de paralelismo. Esto no necesariamente produce un algoritmo eficiente ya que el costo de comunicacin puede ser significativo. En la mayora de los computadores paralelos la comunicacin es mediante el pase de mensajes y frecuentemente hay que parar los cmputos para enviar o recibir mensajes. Mediante la agrupacin de tareas se puede reducir la cantidad de datos a enviar y as reducir el nmero de mensajes y el costo de comunicacin. La comunicacin no solo depende de la cantidad de informacin enviada. Cada comunicacin tiene un costo fijo de arranque. Reduciendo el nmero de mensajes, a pesar de que se enve la misma cantidad de informacin, puede ser til. As mismo se puede intentar replicar cmputos y/o datos para reducir los requerimientos de comunicacin. Por otro lado, tambin se debe considerar el

17


Fundamentos tericos costo de creacin de tareas y el costo de cambio de contexto2 (context switch) en caso de que se asignen varias tareas a un mismo procesador. En caso de tener distintas tareas corriendo en diferentes computadores con memorias privadas, se debe tratar de que la granularidad sea gruesa: exista una cantidad de cmputo significativa antes de tener necesidades de comunicacin. Esto se aplica a mquinas como la SP2 y redes de estaciones de trabajo. Se puede tener granularidad media si la aplicacin correr sobre una mquina de memoria compartida. En estas mquinas el costo de comunicacin es menor que en las anteriores siempre y cuando el nmero de tareas y procesadores se mantenga dentro de cierto rango. A medida que la granularidad decrece y el nmero de procesadores se incrementa, se intensifican las necesidades de altas velocidades de comunicaciones entre los nodos. Esto hace que los sistemas de grano fino por lo general requieran mquinas de propsito especfico. Se pueden usar mquinas de memoria compartida si el nmero de tareas es reducido, pero por lo general se requieren mquinas masivamente paralelas conectadas mediante una red de alta velocidad (arreglos de procesadores o mquinas vectoriales). Los puntos resaltantes que se deben considerar en esta etapa son: 1. Chequear si la agrupacin redujo los costos de comunicacin. 2. Si se han replicado cmputos y/o datos, se debe verificar que los beneficios son superiores a los costos. 3. Se debe verificar que las tareas resultantes tengan costos de cmputo y comunicacin similares.

2

Cada vez que el procesador cambia de tarea, se deben cargar registros y otros datos de la tarea que

correr.

18


Fundamentos tericos 4. Hay que revisar si el nmero de tareas es extensible con el tamao del problema. 5. Si el agrupamiento ha reducido las oportunidades de ejecucin concurrente, se debe verificar que aun hay suficiente concurrencia y posiblemente considerar diseos alternativos. 6. Analizar si es posible reducir an ms el nmero de tareas sin introducir desbalances de cargas o reducir la extensibilidad. 1.5.4 Asignacin En esta ltima etapa se determina en cul procesador se ejecutar cada tarea. Este problema no se presenta en mquinas de memoria compartida tipo UMA. Estas proveen asignacin dinmica de procesos y los procesos que necesitan de un CPU estn en una cola de procesos listos. Cada procesador tiene acceso a esta cola y puede correr el prximo proceso. No consideraremos ms este caso. Para el momento no hay mecanismos generales de asignacin de tareas para mquinas distribuidas. Esto contina siendo un problema difcil y que debe ser atacado explcitamente a la hora de disear algoritmos paralelos. La asignacin de tareas puede ser esttica o dinmica. En la asignacin esttica, las tareas son asignadas a un procesador al comienzo de la ejecucin del algoritmo paralelo y corren ah hasta el final. La asignacin esttica en ciertos casos puede resultar en un tiempo de ejecucin menor respecto a asignaciones dinmicas y tambin puede reducir el costo de creacin de procesos, sincronizacin y terminacin. En la asignacin dinmica se hacen cambios en la distribucin de las tareas entre los procesadores a tiempo de ejecucin, o sea, hay migracin de tareas en tiempo de ejecucin. Esto es con el fin de balancear la carga del sistema y reducir el tiempo de ejecucin. Sin embargo, el costo de balanceo puede ser

19


Fundamentos tericos significativo y por ende incrementar el tiempo de ejecucin. Entre los algoritmos de balanceo de carga estn los siguientes: Balanceo centralizado: un nodo ejecuta el algoritmo y mantiene el estado global del sistema. Este mtodo no es extensible a problemas ms grandes ya que el nodo encargado del balanceo se convierte en un cuello de botella. Balanceo completamente distribuido: cada procesador mantiene su propia visin del sistema intercambiando informacin con sus vecinos y as hacer cambios locales. El costo de balanceo se reduce pero no es ptimo debido a que solo se dispone de informacin parcial. Balanceo semi-distribuido: divide los procesadores en regiones, cada una con un algoritmo centralizado local. Otro algoritmo balancea la carga entre las regiones. El balanceo puede ser iniciado por envo o recibimiento. Si es balanceo iniciado por envo, un procesador con mucha carga enva trabajo a otros. Si es balanceo iniciado por recibimiento, un procesador con poca carga solicita trabajo de otros. Si la carga por procesador es baja o mediana, es mejor el balanceo iniciado por envo. Si la carga es alta se debe usar balanceo iniciado por recibimiento. De lo contrario, en ambos casos, se puede producir una fuerte migracin innecesaria de tareas. Entre los puntos que hay que revisar en esta etapa encontramos: 1. Se han considerado algoritmos con un nmero esttico de tareas y algoritmos de creacin dinmica de tareas? 2. Si se usan algoritmos centralizados de balanceo, hay que asegurarse de que no sea un cuello de botella. 3. Hay que evaluar los costos de las diferentes alternativas de balanceo dinmico, en caso de que se usen, y que su costo no sea mayor que los beneficios.

20


Fundamentos tericos

1.6 Tendencias y tecnologas actualesSensar las caractersticas fsicas del ser humano (biometra) se ha convertido en una medida de seguridad muy importante en la actualidad. Cada vez es mayor el nmero de sistemas de seguridad que incorporan algunas funcionalidades biomtricas: deteccin y reconocimiento de rostros, iris, huella dactilar, voz, etc. Los aeropuertos, empresas, crceles y embajadas, son algunos ejemplos de sitios donde una aplicacin de seguridad biomtrica o reconocimiento de patrones sera una pieza clave para el funcionamiento ptimo del cuerpo de seguridad. Existen varias tecnologas orientadas al reconocimiento de patrones, por ejemplo: OpenCV, MatLab, LookoutVerify SDK, etc. Sin embargo, se debe considerar que estas soluciones, por si solas, no son capaces de adaptarse a la demanda de procesamiento que requerira un sistema de seguridad de gran envergadura. Alcanzar niveles adecuados de procesamiento, para un

funcionamiento rpido de estos sistemas, slo es posible haciendo uso de otras tcnicas, como grid y clustering que requieren una inversin econmica de miles de dlares. En la actualidad se estn desarrollando otras vas para potenciar la capacidad de procesamiento. Hasta hace unos aos, las unidades de procesamiento de grficos (GPU) estaban limitadas a los videojuegos. Por las caractersticas propias de los videojuegos, las GPU deben poseer grandes capacidades de procesamiento matemtico, incluso muy superiores (hasta 285x ms rpidas que un CPU) a las unidades de procesamiento central (CPU) de la computadora. Actualmente ya es posible usar los GPUs como una alternativa para el procesamiento. Para ello es necesario escribir programas en lenguajes especiales que puedan ser compilados para su ejecucin sobre un GPU. Algunos ejemplos de lenguajes son: CUDA C, OpenCL y CAL de ATI (Ver Anexo 2).

21


Fundamentos tericos Los procesadores grficos de NVIDIA son compatibles con OpenCL y CUDA C y los de ATI son compatibles slo con OpenCL. El costo de los ms potentes GPU es inferior al costo de los mejores procesadores de tipo CPU no obstante, el poder de clculo del CPU es mucho menor que el del GPU. 1.6.1 OpenCV [8] OpenCV, que significa Open source Computer Vision library, es una librera multiplataforma de cdigo abierto desarrollada por Intel que proporciona funciones de alto nivel para el procesado de imgenes. Estas funciones les permiten a los programadores crear aplicaciones poderosas en el dominio de la visin por computadora. OpenCV contiene una gran variedad de herramientas para el procesamiento de imgenes. Es compatible con Intel Image Processing Library (IPL) que implementa algunas operaciones sobre imgenes digitales. Adems de

funciones como binarizacin, filtrado, estadsticas de la imagen, implementa algoritmos para las tcnicas de la calibracin (Calibracin de la Cmara), deteccin de objetos, para rastrear (Flujo ptico), anlisis de forma (Geometra, Contorno que Procesa), anlisis del movimiento (Plantillas del Movimiento, Estimadores), reconstruccin 3D (Transformacin de vistas), segmentacin de objetos y reconocimiento (Histograma, etc.). Los algoritmos estn basados en estructuras de datos muy flexibles, acoplados con estructuras IPL; ms de la mitad de las funciones han sido optimizadas aprovechndose de la Arquitectura de Intel. 1.6.2 OpenCL OpenCL (Open Computing Language) es un estndar de cdigo abierto para fines generales de programacin en paralelo a travs de las CPUs, GPUs y otros procesadores. Le proporciona a los desarrolladores de software acceso eficiente a todos los dispositivos compatibles con OpenCL de los que disponga la computadora. El cdigo puede ser ejecutado tanto en CPU como en GPU e 22


Fundamentos tericos incluso en ambos. Fue inicialmente desarrollado por Apple. Inc y cedido bajo licencia al grupo Khronos [9]. OpenCL es un lenguaje y un framework. En su desarrollo han participado muchas empresas y es compatible con un gran nmero de dispositivos, adems de ser totalmente compatible con OpenGL entre otros Figura 1.5 [10].

Figura 1.5 Integracin de OpenCL con tecnologas orientadas al grfico por computadora.

El lenguaje est basado en C++ pero con algunas variantes en su filosofa, por ejemplo: no permite la recursividad, arreglos de longitud variable en tiempo de ejecucin, demonios, etc. Tambin incorpora caractersticas orientadas al paralelismo como, grupos de trabajo, elementos de trabajo, colas de ejecucin asincrnicas y sincronizacin entre procesos [9]. 1.6.3 CUDA Compute Unified Device Architecture (CUDA) nombre que hace referencia tanto a un lenguaje como a una arquitectura creada por NVIDIA, que permite a los programadores usar las tarjetas grficas de NVIDIA para propsitos generales. CUDA C, como parte del conjunto de herramientas de CUDA es un lenguaje al estilo de C++ pero totalmente orientado al paralelismo. Este lenguaje se aprovecha de la arquitectura CUDA del GPU para explotar al mximo los recursos de la tarjeta grfica. La filosofa de trabajo con CUDA C es muy similar a OpenCL, incluso ambos lenguajes son muy parecidos desde el punto de vista de la sintaxis. De manera

23


Fundamentos tericos similar a OpenCL, CUDA es compatible con OpenGL y DirectCompute. Ver Figura 1.6.

Figura 1.6 Integracin de CUDA con tecnologas orientadas al grfico por computadora.

1.6.4 OpenCloovision OpenCloovision es un framework de visin por computadora basado en OpenCL y C#. Incorpora una interfaz llamada Cloo como interfaz de OpenCL, la cual es una librera de .NET desarrollada por el proyecto mono [11]. El framework soporta el conocido framework de Viola-Jones para la deteccin de objetos. El mismo es de cdigo abierto y libre de cualquier tipo de restriccin o cargo monetario, segn indica la licencia que tiene del MIT. Fue desarrollado por una comunidad de internet que tiene lugar en un espacio llamado CodePLex. Este sitio alberga varias comunidades, fue creado por Microsoft para el desarrollo del software libre [12]. Actualmente OpenCloovision se encuentra en pleno desarrollo y en fase alpha. La versin v0.4.2 es la ms reciente y contiene las siguientes caractersticas [12]: Tratamiento de imgenes de tipo byte y flotante. Funciones para hacer box blur en GPU. Funcin para escalado de grises en GPU. Funciones para Histograma en GPU. Funciones para hacer la Imagen Integral e imagen integral al cuadrado en GPU. 24


Fundamentos tericos Funciones para el SobelFilter. Algoritmo Viola-Jones para la deteccin de objetos en GPU.

1.7 Programacin paralela utilizando CPU y GPUDentro del campo de la programacin paralela existen muchas tecnologas para el desarrollo de algoritmos que hacen uso estricto del CPU, por ejemplo: OpenMP, MPI y PlinQ del Framework dotNetFx 4.0 de Microsoft.NET. Como ya se mencion en el acpite 1.6, tambin existen tecnologas para el uso del GPU como CUDA y OpenCL; que incluso pueden ser combinadas con otras tecnologas de CPU para aprovechar al mximo la capacidad de procesamiento de la que se disponga. 1.7.1 Comparacin del CPU y el GPU Tradicionalmente los GPU estaban diseados como unidades de procesamiento de grficos pero muchas comunidades cientficas han demostrado el uso extensivo de los GPU en otros campos de investigacin, como la simulacin fsica, bioinformtica y la Minera de Datos. Por qu usar un GPU para realizar los clculos generales? El CPU est diseado con niveles de memoria cach (L1, L2 y L3) de gran tamao para reducir la latencia hacia la memoria de acceso aleatorio (RAM) del sistema. La memoria cach ocupa una gran porcin del diseo del CPU, espacio que podra utilizarse para unidades de procesamiento adicionales de la aritmtica. El GPU adopta un enfoque muy diferente, casi la totalidad de su diseo est constituido por una arquitectura de ejecucin multi-hilo (multiprocesador), con ello logra hacer despreciable el valor de la latencia hacia la memoria de video. Con un nmero suficiente de hilos multiplexados en cada una de las unidades de procesamiento del GPU, la latencia es realmente despreciable y el dispositivo logra un gran rendimiento sin la necesidad de una memoria cach [5]. 25


Fundamentos tericos La capacidad de procesamiento de un GPU es mucho mayor que la de un CPU. Una computadora personal (PC), con un CPU Intel Core i7 de una frecuencia de reloj de2.67 GHz, puede tericamente ejecutar alrededor de 8.039 GFlop/s (millones de operaciones de punto flotante por segundo); sin embargo un GPU NVIDIA GTX 260 ejecuta cerca de 521.40 GFlop/s. En cuanto al ancho de banda entre la memoria y el procesador (GPU o CPU) se refiere, que en la GPU pueden alcanzarse tasas de 113.7 GB/seg mientras que en el CPU slo se alcanzan tasas de hasta 25.6 GB/s. El balance de carga es una caracterstica fundamental que hay que tener en cuenta. En aplicaciones comunes, la carga (los clculos que realiza algn algoritmo) es dirigida totalmente al CPU y se ignora por completo la existencia del GPU. Esto tiene como consecuencia una utilizacin permanente del CPU, pues el tiempo de procesador que el administrador de procesos del Sistema Operativo (SO) le asigna a una aplicacin, depende de la cantidad de operaciones atmicas que la aplicacin requiera. En una aplicacin que requiera de mucho procesamiento esto se traducira en una ralentizacin general de todo el SO [5]. En aplicaciones que aprovechen el GPU es posible que ciertos segmentos del cdigo de una aplicacin, donde el nivel de procesamiento aritmtico sea muy grande, queden totalmente a cargo del GPU; esto liberara al CPU de cargas innecesarias, incrementara el rendimiento de la aplicacin y permitira que el CPU se encargue de otras tareas. Las desventajas del GPU consisten en que no se puede implementar cualquier tipo de algoritmo en l y tampoco puede ser visto como una plataforma de eleccin para la implementacin de algoritmos debido a su obligatoria implementacin en paralelo. Adems, el soporte de herramientas de programacin para la GPU tales como: depuradores de cdigo y lenguajes de programacin son muy escasos a comparacin los que existen para la CPU.

26


Fundamentos tericos La principal razn que justifica la gran popularidad de las arquitecturas GPU en aplicaciones cientficas es el hecho de que el GPU est especializada para cmputo intensivo, computacin paralela elevada (exactamente sobre lo que trata el renderizado de grficos) y por tanto se designan ms unidades de lgica aritmtica (ALU) para el procesamiento de datos, que para la recoleccin de datos y control de flujo. (Ver Figura 1.7).

Figura 1.7 Estructura general del CPU y GPU [13]

1.7.2 OpenMP OpenMP es una interfaz de programacin de aplicaciones (API) estndar, basada principalmente en el uso de directivas (pragma), que definieron los principales fabricantes de hardware y software para permitir el desarrollo de aplicaciones paralelas con memoria compartida [14]. La API usa C, C++ y Fortan y es soportada por la gran mayora de las plataformas de software, como Unix/Linux y Windows NT [15]. En la Figura 1.8 se muestra el historial de lanzamientos del API OpenMP

27


Fundamentos tericos

Figura 1.8 Historial de lanzamientos del API OpenMP [15]

Modelo de programacin OpenMP se basa en la existencia de mltiples hilos en el paradigma de la programacin con memoria compartida. El modelo de programacin de OpenMP debe ser definido explcitamente, no es posible que se genere de manera automtica. OpenMP le brinda al programador un control total sobre el paralelismo y usa el modelo de fork-join para la ejecucin paralela [15] ( Ver Figura 1.9).

Figura 1.9 Modelos de Fork-Join

Todos los programas de OpenMP comienzan con un proceso simple: hilo maestro (master thread). El hilo maestro es ejecutado de forma serializada hasta encontrar la primera regin paralela [15]. Fork: El hilo maestro crea un equipo de hilos paralelos. Join: Cuando el equipo de hilos termina la funcin, son sincronizados y terminados, la salida es el hilo maestro.

28


Fundamentos tericos 1.7.3 CUDA Los programas desarrollados para ser ejecutados por el GPU, inicialmente, eran implementados en lenguajes de bajo nivel y se necesitaba un amplio conocimiento de programacin avanzada (adems de libreras grficas) para implementarlos en lenguajes de alto nivel. Por lo tedioso y complicado que resultaba el desarrollo de estos programas los desarrolladores de NVIDIA crearon una nueva tecnologa denominada CUDA, que incluye un entorno de programacin en C que aprovecha la capacidad de procesamiento de los GPU de NVIDIA, para as resolver los diversos problemas de clculos complejos y de mayor carga computacional; sin necesidad de recurrir a una API muy compleja (Ver Figura 1.10). Esta tecnologa est disponible para la serie 8 de GeForce hasta la GPU ms moderna de la empresa NVIDIA. El administrador de procesos del SO es el responsable de organizar el acceso al dispositivo grfico, tanto de tecnologas CUDA como aplicaciones grficas en ejecucin concurrente [5]. Cuando se programa para el GPU con CUDA, el GPU es visto como un device capaz de instanciar un alto nmero de hilos de ejecucin en paralelo y operar como un coprocesador del CPU. Durante la ejecucin de una aplicacin, un fragmento de ella puede ser ejecutado en GPU y pueden emplearse al mismo tiempo diferentes juegos de datos. Esto se logra a travs de una funcin kernel (algoritmo que se ejecuta sobre un GPU) que est siendo ejecutada en el device tantas veces y de manera simultnea, como hilos de ejecucin sea posible instanciar [5].

29


Fundamentos tericos

Figura 1.10 Vista general en capas de los elementos que componen a CUDA [1]

Modelo de memoria La memoria desde el punto de vista de la programacin GPGPU es vista de manera peculiar. La memoria del device es considerada memoria local (device memory) mientras que una porcin de memoria del sistema es tambin asignada al dispositivo grfico por el SO, sta recibe el nombre de memoria remota (host memory). El resto de la memoria del sistema mantiene la misma filosofa funcional. Tanto la memoria del ordenador (host memory) como la memoria del dispositivo (device memory) pueden copiar datos de la memoria de acceso aleatorio dinmico o DRAM (Dynamic Random Access Memory) entre ellas, utilizando las llamadas optimizadas de la API del dispositivo de alto rendimiento

30


Fundamentos tericos (high-performance) de la memoria de acceso directo o DMA (Direct Memory Access) [5]. Con el objetivo de establecer una estructura que permita controlar el cmo se tiene acceso a la memoria, CUDA estipula que dicho acceso depende del nivel de agrupacin que conformen los hilos de ejecucin durante la ejecucin de un Kernel (Ver Tabla1).Tabla1 Acceso a memoria usando CUDA

PermisoLectura y escritura Lectura y escritura Lectura y escritura Lectura y escritura Lectura Lectura

GrupoHilos de ejecucin Hilos de ejecucin Bloques de hilos Redes de Bloques Redes de Bloques Redes de Bloques

AccesoRegistros Memoria local Memoria compartida Memoria Global Memoria constante Memoria de textura

Arquitectura del device Desde la perspectiva fsica de estos dispositivos o hardware se puede afirmar que una unidad de procesamiento grfico o GPU (Graphics Processor Unit) se compone de un nmero limitado de multiprocesadores, cada uno de ellos consta de un conjunto de procesadores simples que operan de la forma Instruccin Simple, Mltiples Datos (SIMD), es decir, todos los procesadores de un multiprocesador ejecutan de manera sincronizada la misma operacin aritmtica al mismo tiempo; operando potencialmente sobre datos diferentes. Cada multiprocesador cuenta con un chip de memoria de los siguientes tipos [5]: 1. Un conjunto de registros locales de 32-bit por procesadores. 2. La memoria cach de los datos paralelos o memoria compartida est disponible para todos los procesos en los espacios de memoria compartida.

31


Fundamentos tericos 3. Una memoria cach constante de slo lectura que es compartida por todos los procesadores y aceleradores de lectura del espacio de la memoria constante. Capacidad de clculo (procesamiento) La capacidad de procesamiento de un device se define por el nmero de revisin. Los dispositivos con el mismo nmero de revisin principal son de la misma arquitectura de ncleo. El nmero de revisin est formado por dos partes, la izquierda se refiere a la revisin principal y la derecha a una mejora progresiva de la arquitectura del ncleo, que puede incluir nuevas

caractersticas. Los devices enumerados en la Tabla 2 son algunos de los de la revisin 1.x a 2.1 [13]. Funciones Atmicas Con el fin de sincronizar todos los procesos y asegurar la exactitud de los algoritmos paralelos, CUDA ofrece funciones atmicas tales como: incremento, decremento y el intercambio de palabras de bits, entre otras funciones. Desde la versin 1.3 de CUDA hasta la versin actual, se permiten las operaciones

atmicas en un multiprocesador (Streamer Multiprocessor SM). Un ejemplo claro de la necesidad de las funciones atmicas se cita a continuacin: Supngase que es necesario incrementar el valor de una variable entera X en uno. El cdigo estndar en C o C++, dado un nico proceso sera, X++. En realidad esta instruccin est compuesta de tres pasos: 1. Leer el valor de X. 2. Incrementar en uno el valor ledo de X. 3. Escribir de vuelta a X, el nuevo valor. En la programacin paralela, instrucciones como esta, se instanciaran muchas veces de manera concurrente y se crearan condiciones de competencia. Imagnese dos procesos X++ y cada uno con la secuencia de pasos descrita 32


Fundamentos tericos anteriormente, la idea es que al final de la ejecucin de los dos procesos, X termine incrementado en dos unidades ms. Desafortunadamente no es posible garantizar cual proceso se ejecutar primero, o si ambos se ejecutarn al mismo tiempo, cualquier combinacin desfavorable podra concluir en un mal resultado de X. Para resolver este problema CUDA ofrece muchos tipos de funciones atmicas, lo cual significa que, es posible que operaciones como esta se ejecuten sin riesgo alguno de ser interferidas, por otro proceso e incluso por miles de procesos simultneos [16].Tabla 2 Dispositivos-CUDA habilitados con capacidad de clculo, CUDA multiprocesadores y ncleos

Dispositivo

Revisin

Multiprocesadores

Ncleos CUDA

GeForce GTX 560 Ti GeForce GTX 460 GeForce GTX 470M GeForce GTS 450, GTX 460M GeForce GT 445M

2.1 2.1 2.1 2.1 2.1

8 7 6 4 3 2

384 336 288 192 144 96

GeForce GT 435M, GT 425M, GT 2.1 420M GeForce GT 415M GeForce GTX 580 GeForce GTX 480 GeForce GTX 470 GeForce GTX 295 GeForce GTX 285, GTX 280 GeForce GTX 260 GeForce 9800 GX2 2.1 2.0 2.0 2.0 1.3 1.3 1.3 1.1

1 16 15 14 2x30 30 24 2x16 16

48 512 480 448 2x240 240 192 2x128 128

GeForce GTS 250, GTS 150, 9800 1.1 GTX, 9800 GTX+,8800 GTS 512, GTX 285M, GTX 280M GeForce 8800 Ultra, 8800 GTX 1.0

16 14

128 112

GeForce 9800 GT, 8800 GT, GTX 1.1

33


Fundamentos tericos260M, 9800M GTX GeForce GT 240, GTS 360M, GTS 1.2 350M GeForce GT 130, 9600 GSO, 8800 GS, 1.1 8800M GTX, GTS 260M, GTS 250M, 9800M GT GeForce 8800 GTS GeForce GT 335M 1.0 1.2 12 9 8 96 72 64 12 96 12 96

GeForce 9600 GT, 8800M GTS, 9800M 1.1 GTS GeForce GT 220, GT 330M, GT 325M 1.2

6 6

48 48

GeForce 9700M GT, GT 240M,GT 1.1 230M GeForce GT 120, 9500 GT, 8600 GTS, 1.1 8600 GT, 9700M GT, 9650M GS, 9600M GT, 9600M GS, 9500M GS, 8700M GT, 8600M GT, 8600M GS GeForce 210, 310M, 305M 1.2

4

32

2 2

16 16

GeForce G100, 8500 GT, 8400 GS, 1.1 8400M GT, 9500M G, 9300M G, 8400M GS, 9400 mGPU, 9300 mGPU, 8300 mGPU, 8200 mGPU, 8100

mGPU, 210M, G110M GeForce 9300M GS, 9200M GS, 1.1 1 8

9100M G, 8400M G, G105M Tesla C2050 Tesla S1070 Tesla C1060 Tesla S870 Quadro 6000 Quadro 5000 Quadro 5000M Quadro 4000 2.0 1.3 1.3 1.0 2.0 2.0 2.0 2.0 14 4x30 30 4x16 14 11 10 8 448 4x240 240 4x128 448 352 320 256

34


Fundamentos tericos Nivel de la aplicacin En alto nivel, la aplicacin debe maximizar la ejecucin paralela entre el host, los devices disponibles y el correspondiente bus que los interconecta, todo ello mediante llamadas a funciones asincrnicas. Adems debe asignarle a cada dispositivo la carga de trabajo que mejor pueda realizar, la carga de trabajo serializada le corresponde al Host mientras que la carga de trabajo paralela le corresponde al device [13]. Nivel del dispositivo A bajo nivel, la aplicacin debe maximizar la ejecucin en paralelo entre los multiprocesadores (MP) de un device [13]. Un device de capacidad de clculo 1.x solo puede ejecutar un kernel a la vez, por lo que el kernel debe ser lanzado con bloques de varios hilos por cada multiprocesador que tenga el dispositivo. Un device de capacidad de cmputo 2.x, puede ejecutar de forma simultnea hasta 16 kernels distintos.

Arquitectura SIMT El multiprocesador crea, dirige, organiza y ejecuta hilos en grupos de 32 de forma paralela, estos grupos son llamados warps (trenza). Los hilos individuales que conforman una wrap inician juntos en la direccin de memoria de un mismo programa, pero ellos tienen su propia funcin de conteo de direcciones de

registros y estados, adems son libres de ramificarse y ejecutarse de forma independiente [13]. La arquitectura SIMT es similar a las organizaciones de vectores de SIMD (Single Instruction, Multiple Data), en las que una sola instruccin controla mltiples elementos de procesamiento. Una diferencia principal es que las organizaciones de vectores de SIMD exponen el ancho de SIMD al software, 35


Fundamentos tericos mientras que las instrucciones SIMT especifican la ejecucin y el

comportamiento de ramificacin de un slo hilo. En contraste con las mquinas de vectores SIMD, SIMT permite a los programadores escribir cdigo paralelo a nivel de hilos de manera independiente, as como cdigo para datos en paralelo con hilos coordinados. De una manera correcta, el programador puede esencialmente ignorar el comportamiento SIMT, sin embargo, las mejoras sustanciales en el rendimiento pueden ser realizadas enfocndose en parte del cdigo que rara vez requiera hilos en una warp para que diverja. En la prctica, esto es anlogo al papel de las lneas de cach en un cdigo tradicional. El tamao de las lneas de cach se puede omitir con seguridad cuando se disea de una manera correcta pero debe ser considerado en la estructura del cdigo cuando el diseo es para un rendimiento mximo. Las arquitecturas de vectores, por otra parte, requieren que el software combine las cargas de los vectores y organice la divergencia manualmente [13]. 1.7.4 OpenCL OpenCL es el primer estndar de cdigo abierto libre de regalas para mltiples plataformas de hardware y software como las que se encuentran en las computadoras, servidores y dispositivos porttiles de hoy en da [9]. OpenCL aade velocidad y mejora el tiempo de respuesta de un gran espectro de aplicaciones en numerosas categoras del mercado, desde los video-juegos y entretenimiento hasta el software mdico y cientfico [9]. OpenCL soporta un amplio rango de aplicaciones, desde las integradas en dispositivos mviles y de consumo general hasta soluciones de computacin de alto rendimiento (HPC). Todo ello a travs del bajo nivel, alto rendimiento y un nivel de abstraccin portable, adems de implementar una interfaz de programacin lo ms cercana al hardware posible [9]. OpenCL est formado por una API para la coordinacin de computacin paralela entre procesadores heterogneos y por un lenguaje de programacin multiplataforma con un ambiente bien especificado [9]. 36


Fundamentos tericos El estndar de OpenCL [9]: Soporta tanto el modelo de programacin paralela de datos, como el de tareas. Utiliza un subconjunto de ISO C99 con extensiones para el paralelismo. Define requerimientos numricos consistentes basados en IEEE 754 Define un perfil de configuracin para dispositivos mviles y dispositivos embebidos. Eficientemente se comunica con OpenGL, OpenGL ES y otras APIs de Grficos. Modelo de programacin de datos en paralelo En el modelo de programacin de datos en paralelo, un procedimiento es definido como una secuencia de instrucciones ejecutadas sobre mltiples elementos de un objeto de memoria. Estos elementos se encuentran en un espacio de ndice3, el cual define cmo la ejecucin se har sobre los llamados Elementos de Trabajo (Work-Items). En este modelo no es un requerimiento estricto el que haya un work-item para cada elemento del objeto de memoria, sobre el cual se est ejecutando un kernel en paralelo [17]. Este modelo es de tipo jerrquico y la subdivisin de jerarquas puede ser especificada de dos maneras [17]: Explcitamente El desarrollador define el nmero total de work-items a ejecutarse en paralelo as como la divisin especfica que estos tendrn en los llamados Grupos de Trabajo (Work-Groups). Implcitamente El desarrollador especifica el nmero total de workitems y entonces OpenCL administra su divisin en grupos de trabajo.

3

Espacio de 3 dimensiones, la primera dimensin especfica el total de work-item, la segunda el total de

work-groups y la tercera especifica la cantidad de work-items por work-group (NDRange).

37


Fundamentos tericos Modelo de programacin de tareas en paralelo En este modelo una instancia de kernel es ejecutada de forma independiente a cualquier espacio de ndice. Esto es equivalente a la ejecucin de un kernel en un device con un work-group y un NDRange que contiene solo un work-item. El paralelismo es expresado usando tipos de dato vector implementados por el dispositivo, poniendo en cola mltiples tareas, y /o poniendo en cola kernels nativos desarrollados usando un modelo de programacin ortogonal para OpenCL [17]. El NDRange El NDRange es el grid para controlar el cmo se ejecutan los kernels. Consta de tres dimensiones. La primera dimensin se usa para especificar cul ser la cantidad total de work-items, es decir, si cada work-tem ejecuta un kernel entonces se debe saber de antemano cuantas veces es necesario que el kernel se instancie. La segunda dimensin se usa para especificar cuantos workgroups habr. Muy a menudo es necesario agrupar a los work-items para que hagan alguna tarea de forma conjunta, es decir, que entre ellos compartan informacin, y para que eso sea posible, entonces hay que definir esta dimensin. La tercera dimensin se usa para definir cuantos work-items habr por cada work-group (Ver Figura 1.11) [17].

38


Fundamentos tericos

Figura 1.11 Muestra cmo luce el NDRange y cmo est constituido

El modelo de la plataforma El modelo de la plataforma para OpenCL consiste en Host conectado a uno o ms dispositivos (Compute device) OpenCL. Un dispositivo OpenCL es dividido en una o ms unidades de cmputo (Compute unit), las cuales son nuevamente divididas en uno o ms elementos de procesamiento (Processing elements). Las operaciones en un dispositivo ocurren al nivel de los elementos de procesamiento (Ver Figura 1.12) [9]. Una aplicacin de OpenCL se ejecuta en un host, acorde a los modelos nativos a la plataforma del host. La aplicacin enva comandos desde el host donde se est ejecutando hacia los elementos de procesamiento del dispositivo. Los elementos de procesamiento de la unidad de cmputo ejecutan una simple instruccin de flujo como si fuesen una unidad SIMD [9].

39


Fundamentos tericos

Figura 1.12 Modelo de la plataforma, Un host con uno o ms dispositivos de computo, tanto GPU como CPU e incluso otros.

Modelo de memoria El work-item que ejecuta un kernel tienen acceso a cuatro distintas regiones de memoria [9]: Memoria Global. Esta regin de memoria permite acceso de tipo lectura y escritura a todos los work-items en todos los work-groups. Los workitems pueden leer desde o escribir hacia cualquier elemento de un objeto de memoria. Memoria Constante. Es una regin de la memoria global que permanece constante durante la ejecucin de un kernel. El host reserva e inicializa los objetos de memoria colocados en la memoria constante. Memoria Local. Es una regin privada de memoria para un work-item. Las variables definidas en un espacio privado de memoria de un workitem no son visibles desde otro work-item. La Tabla 3 describe si el kernel o el host pueden reservar desde una regin especfica de memoria, define tambin el tipo de reserva que pueden hacer y el tipo de acceso a memoria que se les est permitido.

40


Fundamentos tericosTabla 3 Muestra la reserva de memoria en regiones y las caractersticas de acceso

Global Host Reserva dinmica

Constante Reserva dinmica

Local Reserva dinmica

Privada Sin Reserva

Acceso de Lectura/Escritura Kernel Sin reserva

Acceso de Lectura/Escritura Reserva Esttica Sin acceso Reserva Esttica Sin acceso Reserva Esttica

Acceso de Lectura/Escritura

Acceso de slo lectura



El marco de trabajo (framework) de OpenCL El framework de OpenCL le permite a las aplicaciones usar un host y uno o ms de los dispositivos OpenCL como un nico sistema de cmputo paralelo. El framework contiene los siguientes elementos [9]: La capa de plataforma OpenCL. La capa de la plataforma le permite al programa que se ejecuta en el host encontrar todos los dispositivos OpenCL disponibles, sus capacidades de cmputo y la creacin de contextos4. El Runtime de OpenCL. El Runtime le permite al programa que se ejecuta en el host manipular las caractersticas del contexto, una vez creado. El compilador de OpenCL. El compilador de OpenCL crea programas ejecutables que contienen los Kernels de OpenCL. El lenguaje OpenCL C implementado por el compilador soporta un subconjunto del lenguaje ISO C99 con extensiones para el paralelismo.

4

Es un entorno de ejecucin asociado a la tarjeta de video, el contexto deber contener

informacin suficiente como para que la ejecucin del Kernel sea satisfactoria, en el contexto se debe especificar la memoria que ser usada por el kernel y el dispositivo que llevar a cabo la ejecucin.

41


Fundamentos tericos Las extensiones de OpenCL Las extensiones de OpenCL son caractersticas adicionales soportadas por las especificaciones de OpenCL, sin embargo slo algunos dispositivos soportan este tipo de caractersticas. Por esta razn, un programa escrito en OpenCL con ciertas extensiones activadas es posible que no se ejecute correctamente en la mayora de los dispositivos OpenCL. Para evitar un mal funcionamiento, el Runtime proporciona funciones para determinar si un dispositivo OpenCL cumple con las caractersticas necesarias para que el programa OpenCL se ejecute adecuadamente [9]. A continuacin se enumeran algunas de las extensiones de las que dispone OpenCL [17]: cl_khr_global_int32_base_atomics Operaciones atmicas bsicas con enteros de 32 bit en memoria global cl_khr_global_int32_extended_atomics Operaciones atmicas

extendidas en enteros de 32bit en memoria global. cl_khr_3d_image_writes Habilita la escritura del Kernel en Objetos 3D. cl_khr_byte_addressable_store Elimina la restriccin de no poder

escribir en elementos en memoria menores a 32 bit, por ejemplo un arreglo de char. En la Figura 1.13 se muestra el Diagrama de clases de OpenCL [9]

42


Fundamentos tericos

Figura 1.13 Diagrama de clases de OpenCL representado con UML

1.8 ConclusionesA lo largo de este captulo se analizaron los temas fundamentales que permitirn la puesta en marcha de la solucin que se pretende implementar. Se determin el funcionamiento de las tecnologas GPGPU en aras de aprovechar la arquitectura orientada al paralelismo que rige al GPU. Tambin se seleccionaron los lenguajes de CUDA C y OpenCL para la implementacin del algoritmo de deteccin de objetos.

43


Descripcin de la solucin propuesta

Captulo 2 Descripcin de la solucin propuestaEn este captulo se abordar la descripcin de la solucin propuesta, adems se presentar la descripcin detallada del algoritmo de deteccin de objetos de Viola Jones y se determinarn las segmentos paralelizables (puntos de fuego) del algoritmo.

2.1 Funcionamiento del algoritmo de deteccin de objetos de Viola-Jones.En la Figura 2.1 se muestran los pasos del funcionamiento general del proceso de deteccin de rostros. Este algoritmo espera como parmetro de entrada una imagen en escala de grises y la cascada. A esta imagen se le calcula la integral obteniendo la denominada imagen integral dada por la Ecuacin 1, donde ii(x,y) es la imagen integral e i(x,y) es la imagen original. La imagen integral es una matriz del mismo tamao que la matriz de la imagen original.

(

)

(

)

Ecuacin 1 Integral de la imagen

A fin de poder detectar los rostros en toda localizacin de la imagen, se define una ventana para recorrer toda la imagen con un paso determinado. A cada rectngulo de la imagen definido por la ventana se le calcula su integral utilizando la Ecuacin 2 y se le extraen sus caractersticas. Estas caractersticas son comparadas con la cascada de clasificadores para detectar la presencia de un rostro en esa regin. Este proceso es repetido variando el tamao y posicin de la ventana [18].

44



Figura 2.1 Proceso de deteccin de rostro en una imagen

2.1.1 Implementacin en OpenCV El algoritmo de deteccin de objeto concebido por Viola y Jones implementado en la librera de OpenCV sigue los siguientes pasos para su ejecucin: 1. Comprobar que la cascada haya sido cargada. 2. Comprobar que la imagen est en escala de grises, de no ser as se convierte la imagen a escala de grises. 3. Clculo de la integral de la imagen.

45


Descripcin de la solucin propuesta4. Recorrer la imagen para la extraccin de caractersticas de cada

rectngulo y compararlas con la cascada, en donde, si termina con todas las etapas de la misma se confirma que es un rostro como se observa en la Figura 1.3.

2.2 Deteccin de puntos de fuego en el algoritmoLa deteccin de puntos de fuego se le aplica a los segmentos del algoritmo o a las funciones que pueden ser paralelizadas y que sean puntos de carga del algoritmo en cuestin. 2.2.1 Integral de la Imagen El primer concepto introducido por Viola y Jones [19] fue la integral de la imagen o las tablas de sumatoria de rea (SAT). La integral de la imagen en el punto ( ) contiene la suma de los pixeles por encima y hacia la izquierda (Ver

Ecuacin 1). La imagen integral de los rectngulos es una representacin de la imagen que permite calcular la covariancia en una ventana (regin de la imagen) muy rpidamente a partir de cuatro referencias solamente. El clculo de la suma de la integral del rectngulo de inters definido [20] se hace como lo muestra la Figura 2.2 y Ecuacin 2

Figura 2.2 Evaluacin de caractersticas usando la integral de la imagen

46


Descripcin de la solucin propuesta( ) ( ( ) ( )Ecuacin 2 Integral de un rectngulo

)

(

)

Una variante de la integral es almacenar el cuadrado de la suma para el uso del clculo de la desviacin estndar Ecuacin 3 [20].

(

)

(

)

Ecuacin 3 Cuadrado de la Imagen Integral

Clculo de la integral de la imagen CPU y GPU [21] En el CPU: Solucin: ( ) ( ) ( ) ( ) ( )

F(x,y) : es el valor del pixel en esa posicin (Ver Figura 2.3 a)).En la GPU: Problema: Dependencia de datos (Ver Figura 2.3 b) ) Solucin: El clculo de la integral es separable como se muestra en la Ecuacin 4.( )

(

)(

) ( )

(

)

(

)

Ecuacin 4 ImagenIntegral paralelizable

47



a)

b)

Figura 2.3 Proceso de la integral de la imagen. a) en CPU. b) en GPU

La implementacin del clculo de la integral de la imagen en la GPU consta de dos partes, la integral por las filas (x) y luego las columnas (y). En la Figura 2.4 se muestra como se ejecuta el proceso paralelizado del clculo de la integral de la imagen:

Figura 2.4 Clculo de la integral de la imagen por los ejes (x, y)

2.2.2 Clculo

Documents

Tesis Viloria-Tona Gold