título del proyecto de grado (6)

TÍTULO DEL PROYECTO DE GRADO

AUTOR

INGENIERÍA ELECTRÓNICAESCUELA DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA

UNIVERSIDAD DEL VALLESANTIAGO DE CALI, abril de 2023

TÍTULO DEL PROYECTO DE GRADO

AUTOR

TRABAJO PRESENTADO PARA OPTAR POR EL TÍTULO DE INGENIERO ELECTRÓNICO

NOMBRE DEL DIRECTOR 1DIRECTOR

NOMBRE DEL DIRECTOR 2DIRECTOR

INGENIERÍA ELECTRÓNICAESCUELA DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA

UNIVERSIDAD DEL VALLESANTIAGO DE CALI, abril de 2023

Contenido

Nota de Aceptación..................................................................................................................... i

RESUMEN.......................................................................................................................................... I

ABSTRACT......................................................................................................................................... I

1. INTRODUCCIÓN........................................................................................................................1

1.1 PROBLEMÁTICA.....................................................................................................................11.2 JUSTIFICACIÓN...................................................................................................................... 1

2. MARCO TEÓRICO.....................................................................................................................2

2.1 INTRODUCCIÓN.....................................................................................................................22.2 ANTECEDENTES....................................................................................................................2

2.2.1 Antecedentes Internacionales.......................................................................................102.2.2 Antecedentes Nacionales.............................................................................................102.2.3 Antecedentes Regionales.............................................................................................10

2.3 IDENTIFICACIÓN PERSONAL POR MEDIO DE IMÁGENES...........................................................102.3.2 Redundancia del espacio imagen...................................¡Error! Marcador no definido.

2.4 DETECCIÓN FACIAL BASADA EN CLASIFICADORES EN CASCADA, ALGORITMOS BOOSTING Y CARACTERÍSTICAS NPD.................................................................................................................. 10

2.4.1 Esquema general..........................................................................................................102.4.2 Característica................................................................................................................112.4.3 Weak learn................................................................................................................... 132.4.4 Strong learn.................................................................................................................. 172.4.5 Clasificador.....................................................................¡Error! Marcador no definido.

2.5 RECONOCIMIENTO FACIAL BASADO EN SOLUCIÓN DISPERSA Y MKD......................................202.5.1 Esquema general............................................................¡Error! Marcador no definido.2.5.2 Keypoints........................................................................¡Error! Marcador no definido.2.5.3 Descriptor........................................................................¡Error! Marcador no definido.2.5.4 MKD.............................................................................................................................. 212.5.5 CanAff........................................................................................................................... 232.5.6 GTP.............................................................................................................................. 252.5.7 SCR.............................................................................................................................. 282.5.8 Minimización L1 usando coordenada descendente......................................................31

2.6 CONCLUSIONES.................................................................................................................. 33

3. SOFTWARE DEL SISTEMA....................................................................................................34

3.1 DETECTOR FACIAL..............................................................................................................343.1.1 Construcción y entrenamiento del clasificador en cascada..........................................373.1.2 Funcionamiento de cada etapa de clasificación...........................................................393.1.3 Construcción de los clasificadores en cada etapa........................................................403.1.4 Construcción de cada árbol de regresión (Método Propuesto).....................................42

3.2 RECONOCEDOR FACIAL.......................................................................................................513.3 BLOQUE 1.......................................................................................................................... 653.4 BLOQUE 2.......................................................................................................................... 653.5 BLOQUE 3.......................................................................................................................... 653.6 CONCLUSIONES.................................................................................................................. 65

4. PRUEBAS Y RESULTADOS...................................................................................................66

4.1 PRUEBA 1.......................................................................................................................... 664.1.1 Descripción................................................................................................................... 664.1.2 Procedimiento...............................................................................................................664.1.3 Resultados.................................................................................................................... 66

4.2 PRUEBA 2.......................................................................................................................... 664.2.1 Descripción................................................................................................................... 664.2.2 Procedimiento...............................................................................................................664.2.3 Resultados.................................................................................................................... 66

4.3 ANÁLISIS COMPARATIVO......................................................................................................664.4 CONCLUSIONES.................................................................................................................. 66

5. CONCLUSIONES GENERALES.............................................................................................67

6. TRABAJOS FUTUROS...........................................................................................................68

7. REFERENCIAS BIBLIOGRÁFICAS........................................................................................69

ANEXO......................................................................................................................................... 70A1. MANUAL DE USUARIO (SI SE HA DESARROLLADO UN SOFTWARE O SI HAY UN EQUIPO QUE REQUIERE SER INSTALADO O MANIPULADO)......................................................................................70AN. ANEXO N: TÍTULO..................................................................................................................... 70

Lista de Figuras

Nota de Aceptación

Director

Codirectora

Jurado

Jurado

AGRADECIMIENTOS

ResumenEscriba un resumen en castellano y un abstract en inglés del trabajo desarrollado en el proyecto de grado.

Palabras Clave: No más de cinco palabras claves al final del resumen y el abstract.

Abstract---

Key Words:

3

TÍTULO DEL PROYECTO DE GRADOMarco Teórico

1. Introducción

1.1 Problemática

1.2 Justificación

1


2. Marco Teórico

2.1 IntroducciónSe indica el contenido de este capítulo y por qué es importante.

2.2 Antecedentes

Antecedentes detección facial:

Internacionales:

Robust Real time Object Detection (Viola & Jones, 2001)

El algoritmo de detección facial presentado en este artículo realizo un enorme aporte teórico al introducir las denominadas características HAAR y su evaluación por medio del concepto de imagen integral, la combinación de clasificadores débiles (Weak Learns) por medio de adaBoost (Freund & Schapire, 1995), (Schapire & Schapire, 1999) y la estructura de clasificación en cascada. La idea de los autores es construir un conjunto de clasificadores conocidos como strong classifiers (clasificadores fuertes) a partir de la ponderación de un conjunto de clasificadores mucho más sencillos denominados weak classifiers (clasificadores debiles). Cada uno de estos clasificadores débiles están conformados por una característica y un umbral de comparación, de tal manera que su funcionamiento es análogo al de un perceptron de salida binaria. Dado que es posible construir más 180000 Weak Learns de la totalidad de características HAAR existentes en una ventana de 24x24 pixeles, los autores llevan a cabo un proceso de selección que permite encontrar los mejores Weak Learns. Este proceso es realizado usando el algoritmo de Adaboost, el cual iterativamente elige los Weak Learns con el menor error de clasificación, y posteriormente los pondera de acuerdo a su exactitud. Esta ponderación de clasificadores es denominada Strong Learn, y múltiples Strong Learns cada vez más complejos (conformados por un número mayor de Weak Learns) son derivados del entrenamiento y organizados en lo que los autores denominan clasificador en cascada.

En la fase de detección, una ventana deslizante analiza las múltiples regiones de una imagen de prueba a diferentes escalas. Cada imagen producto del enventanado es entonces enviada al clasificador en cascada; las ventanas que sean clasificadas como “rostros” por cada uno de los clasificadores fuertes de la cascada, finalmente son declaradas como “rostros”, y las que sean rechazadas

2


por algún clasificador fuerte intermedio, como “no rostros”. Este algoritmo realiza un buen uso de los recursos de cómputo, puesto que la clasificación en cascada descarta rápidamente las regiones sencillas de la imagen y dedica la mayor parte del cálculo a las regiones complejas, además que para la evaluación de las características HAAR primero se calcula lo que los autores denominan imagen integral, de esta manera la evaluación de cada característica se reduce a un pequeño número de sumas y restas.

Para el entrenamiento los autores usaron 4916 imágenes de rostros frontales, este entrenamiento estuvo en el orden de semanas (aunque no se menciona cuantas) en un AlphaStation XP900 de 466 MHZ y para cuando finalizo, el detector contaba con 32 etapas y 4297 características HAAR elegidas. Los resultados de este detector sobre la prueba CUM+MIT son mostrados en la curva ROC de la Figura 2.1. La velocidad de ejecución de este detector en un computador Intel Pentiun III de 700 mhz para imágenes de 384×288 pixeles reportada por los autores es de 15 frames por segundo.

Figura 2.1 Curva ROC obtenida en la evaluación del detector facial de (Viola & Jones, 2001) sobre la prueba MIT+CMU.

An Extended Set of Haar-like Features for Rapid Object Detection (Lienhart & Maydt, 2002)

En este artículo los autores presentan un algoritmo de detección facial basado en el propuesto por (Viola & Jones, 2001). Este algoritmo similarmente usa características HAAR para construir los Weak Learns, Adaboost para combinar los Weak Learns en Strong Learns y clasificación en cascada para evaluar los Strong Learn de manera óptima en el proceso de enventanado. La novedad, radica en que los autores extienden el conjunto de características HAAR original, a un nuevo conjunto denominado HAAR-LIKE por medio de su rotación a 45°, con esto, buscan obtener un detector final robusto a leves variaciones del ángulo del rostro.

3


Otra mejora presentada por los autores tiene que ver con los clasificadores usados en cada etapa. Originalmente (Viola & Jones, 2001) usan Adaboost para construir el clasificador de cada etapa, esto implica que los clasificadores son ajustados para tener bajas tasas de error (Falsos positivos + falsos negativos). En este artículo, los autores proponen un proceso de post.-optimizado en el cual se modifica cada clasificador obtenido con Adaboost, forzándolo a alcanzar una tasa de existo deseada (verdaderos positivos). Para esto se realiza una búsqueda del umbral óptimo de cada Weak Learn perteneciente al clasificador, por medio de una técnica basada en gradiente descendente.

Para medir la mejora del detector de (Viola & Jones, 2001) obtenida con sus dos propuestas (HAAR-LIKE y el post-optimizado) los autores realizan dos experimentos. En el primero, se entrenó dos clasificadores de 12 etapas usando características HAAR y HAAR-LIKE respectivamente, como resultados se obtuvo que la taza de falso positivos mejor un 10% para el caso del detector que uso características HAAR-LIKE. En el segundo, se entrenó dos clasificador de 10 etapas sin post-optimizado y con post-optimizado respectivamente (para ambos clasificadores se usó características HAAR-LIKE), como resultado se obtuvo que la taza de falsos positivos mejoro en un 12.5%. Las curvas ROC reportadas por los autores para ambos experimentos se muestran en la Figura 2.2.

En lo que respecta a la velocidad de ejecución de este detector, los autores reportan velocidades de procesamiento de 5 frames por segundo en imágenes de 320x240 pixeles, usando un computador Pentium 4 de 2 ghz. La implementación fue realizada en el lenguaje de programación C++ y actualmente ha sido optimizado e integrado en la librería de visión artificial openCV.

(a) (b)

4


Figura 2.2 Curvas ROC obtenidas del detector de (Lienhart & Maydt, 2002) bajo la prueba CUM+MI. (a) Curvas ROC obtenida para 2 detectores de 12 etapas usando características HAAR y HAAR-LIKE respectivamente. (b) Curvas ROC obtenida para 2 detectores de 10 etapas sin post-optimizado y con post-optimizado respectivamente.

Fast Rotation Invariant Multi-View Face Detection Based on Real Adaboost (Bo Wu, Haizhou Ai, Chang Huang, & Shihong Lao, 2004)

En este artículo se presenta un novedoso algoritmo para detectar rostros a cualquier ángulo de rotación y con poses que varíen entre -90 y 90 grados, los autores denominan a este detector MVFD (Rotation invariant multiview face detection). Este detector facial al igual que el propuesto por (Viola & Jones, 2001) y (Lienhart & Maydt, 2002) usa características HAAR y clasificación en cascada, pero a diferencia de los anteriores presenta 3 nuevas mejoras que lo hacen mucho más robusto.

La primera, es el uso de un Weak Learn de salida real, y no binaria como en el detector de (Viola & Jones, 2001). Con esto, se busca construir clasificadores que se adapten mucho mejor a la distribución del conjunto de imágenes de entrenamiento. Para la construcción de este Weak Learn, los autores proponen particionar el rango de salida de una característica HAAR en partes iguales, y asignar a cada uno de estos rangos, un valor de confianza que en cierta medida representa la probabilidad de que la característica HAAR esté siendo evaluada sobre un rostro. Los autores denominan a este clasificador como LUT Weak Classifier, y para la combinación de múltiples de estos clasificadores se usa el algoritmo Real Adaboost.

La segunda, es la organización de los clasificadores de cada etapa en lo que los autores denominan estructura de clasificación anidada. Esta estructura es similar a la propuesta por (Viola & Jones, 2001), pero se diferencia en que toma en cuenta el valor de confianza dado a la ventana de análisis por la etapa anterior, de tal manera que en este esquema, la etapa anterior es considerada como otro Weak Learn.

La tercera, es la posibilidad de detectar rostros a múltiples ángulos (RIP rotation-in-plane) y múltiples poses (ROP rotation-out-of-plane). Para esto, los autores dividen los ángulos posibles de un rostro entre 12 (cada 30 grados) y las poses posibles entre 5 (perfil izquierdo, medio perfil izquierdo, frontal, medio perfil derecho y perfil derecho), de lo cual se deriva que se requieren 12×5=60 estructuras de clasificación anidadas para realizar la detección a múltiples poses y ángulos. Dado que las características HAAR pueden ser rotadas a ángulos de 90 grados finalmente los autores concluyen que solo 8 detectores son necesarios.

5


Debido al impacto sobre la velocidad de ejecución que pueden tener estos 8 detectores siendo evaluados al tiempo, los autores proponen un esquema de clasificación en donde se divide en 2 partes las estructuras de clasificación anidadas. La primera parte se encarga de detectar la pose y la segunda parte de la detección en sí.

Para medir la efectividad del algoritmo propuesto, los autores realizan dos experimentos, uno enfocado a evaluar el impacto del LUT Weak Classifier sobre un detector de rostros frontales y otro a evaluar el detector MVFD. En el primer experimento, los autores entrenan una estructura de clasificación anidada con 20000 rostros frontales y obtienen un detector con 16 etapas y 756 características HAAR. La taza de detección obtenida en la evaluación de este detector sobre un subconjunto del CMU+MIT conformado por 130 imágenes que contenían 507 rostros frontales, fue del 91% para un total de 10 falsas alarmas.

En el segundo experimento, los autores entrenan las 8 estructura de clasificación anidada necesarias para el detector MVFD. Para este entrenamiento se usan 10000 rostros de medio perfil y 14000 rostros de perfil. La taza de detección obtenida en una evaluación de este detector sobre imágenes de perfil de la base de datos CMU fue del 84.8 % de para un total de 34 falsas alarmas.

La velocidad de ejecución reportada por los autores para imágenes de 320x240 pixeles usando un computador Pentium 4 de 2.4 GHZ, fue de 55 frames por segundo para el detector frontal y de 12.5 frames por segundo para el detector MVDF.

High-Performance Rotation Invariant Multiview Face Detection (Huang, Ai, Li, & Lao, 2007)

En ese artículo se presenta un detector facial MVFD (Rotation invariant multiview face detection) que a diferencia de esquemas anteriores no está basado ni en características HAAR y ni en clasificación en cascada. La nueva estructura de clasificación propuesta por los autores es un árbol de decisión que paulatinamente divide el problema de la detección MVFD en 5 poses, y justo en el nodo final de cada rama, se separa cada pose en 3 ángulos de rotación distintos, con lo cual se tienen en total 15 vistas posibles. La clasificación en cada nodo, a diferencia de enfoques anteriores produce un vector de salida binaria de 3 componentes, el cual indica la dirección del nodo hijo que debe seguirse en el árbol (perfil izquierdo, perfil derecho o frontal). El clasificador en cada nodo es un conjunto de Weak Learns combinados por medio de un algoritmo propuesto por los autores denominado Vector Boosting, el cual es una generalización de Adaboost para el

6


caso de n clases. Para construir cada Weak Learn se adopta una idea similar a la propuesta por (Bo Wu et al., 2004), en donde cada característica es evaluada sobre un conjunto de imágenes de entrenamiento y su rango de salida particionado para ser mapeado a una salida deseada. En el caso de SPEARSE FEATURE la salida deseada asignada para cada rango, es un vector constante que minimiza la función de error del algoritmo Vector Boosting, los autores mencionan que dicho vector constante puede ser hallado usando Newton-step.

Para el entrenamiento los autores usaron 30000 rostros frontales, 25000 de medio perfil y 20000 de completo perfil. Este entrenamiento tardo 3 semanas en un computador Pentium 4 de 3 ghz. Uno de los tantos resultados reportado por los autores se muestra en la curva ROC de la Figura 2.3 en donde se ha evaluado el detector sobre la base de datos CMU. Las velocidad de procesamiento reportada para imágenes de 320x240 pixeles es de 10 frames por segundo (usando el mismo computador, usado en el entrenamiento).

Figura 2.3 Curva ROC reportada por (Huang et al., 2007) al evaluar su detector facial sobre la base de datos CMU.

Face Detection using SURF Cascade (J. Li, Wang, & Zhang, 2011)

En este artículo se presenta un algoritmo de detección facial basado en el descriptor SURFT y la estructura de clasificación en cascada. Inicialmente los autores varían las posibles configuraciones del descriptor SURFT para ventanas de análisis entre 12x12 y 40x40 pixeles. En total, y bajo ciertas restricciones, ellos concluyen que en una ventana de análisis de 40x40 solo pueden existir 396 configuraciones. Cada una de estas configuraciones, se evalúa entonces sobre un conjunto de imágenes de entrenamiento, y la repuesta obtenida es usada como la entrada de un modelo de regresión logística que busca ajustarse a la clase “rostro” “no rostro”.

7


Una vez que se han ajustado los 396 modelos (Weak Learns), los autores eligen los mejores para su combinación usando un proceso similar al de Adaboost, la diferencia aquí radica en que el criterio de parada no es el error de clasificación, sino un valor máximo de convergencia en la curva AUC (integral de la curva ROC). Los autores repiten este proceso de selección y combinación de modelos logísticos múltiples veces en un esquema de entrenamiento similar al usado por (Viola & Jones, 2001), obteniendo así, un conjunto de clasificadores (Strong Learns) con un orden de complejidad creciente que van siendo organizados en una estructura de clasificación en cascada.

Este detector ha sido implementado en el lenguaje de programación C++ y sus rutinas de entrenamiento paralelizadas con OPENMP. Para el entrenamiento, los autores han usado 39000 rostros, este, ha sido ejecutado en un computador 3.2GHz Core-i7 CPU y ha tardado 47 minutos en converger a un clasificador con 8 etapas y 334 Weak Learns. Los resultados obtenidos al evaluar el detector en la base de datos FDDB son mostrados en la Figura 2.4. La velocidad de ejecución más alta reportada por los autores del detector ejecutándose sobre un computador Intel Atom de 1.6GHz es de, 30.1 fps y sobre un computador Core-i7 CPU de 3.2GHz, de 90.5 fps.

(a) (b)Figura 2.4 Evaluación del detector de (J. Li et al., 2011) en la base de datos FDDB. (a) ROC generada con Score discreto. (b) ROC generada con Score continúo.

En (Shengcai, Jain, & Li, 2012) se presenta un novedoso detector robusto a los cambios de postura, iluminación y oclusión, así como a la iluminación y baja resolución de la imagen.

Los autores proponen una nueva caracteristica denominada NPD (Normalized Pixel Difference), la cual tienen la propiedad de ser invariantes a la escala, iluminación y estar acotadas entre valor numérico (Específicamente en el rango [-

8


1,1]), esto debido a las propiedades algebraicas derivadas de su cálculo, , donde y son dos pixeles diferentes cualquiera.

Para la extracción de características los autores proponen un novedoso método llamado NPD (Normalized Pixel Difference), que tienen la propiedad de ser invariantes a la escala, iluminación y estar acotadas entre valor numérico (Específicamente en el rango [-1,1]), esto debido a las propiedades algebraicas derivadas de su cálculo, , donde y son dos pixeles diferentes cualquiera. La clasificación de rostros, de los no rostros, se logra por medio de varias cascadas de características NPD previamente seleccionadas con el algoritmo de AdaBoost. Además de las características NPD, esta publicación se diferencia de otras anteriores por usar el algoritmo CART (Classification and Regression Trees) (Breiman, Friedman, Olshen, & Stone, 1984) para construir el árbol de clasificación, lo que permite que rostros de diferentes poses tomen diferentes ramas en el árbol, ahorrando así tiempo en la etapa de entrenamiento ya que no habrá que etiquetar imágenes como en (Huang & Al, 2007) ya que el árbol se genera automáticamente.

Face Detection using SURF Cascade (J. Li et al., 2011)

En esta publicación los autores proponen un detector facial similar al propuesto por violaj jones pero con 2 nuevas variantes.

La caracterisitica de detección usada en esta publicación es el descriptor SURFT, los autores realizan un proceso de muestreo de

para construir el weak learn primero se contruye un modelo de probabilidad con la regresión logística

Antecedentes nacionales

Faces Detection in Digital Images Using Cascade Classifiers (Detection, Images, & Cascade, 2008)

En este artículo se presenta un algoritmo de detección facial en imágenes digitales basado en el popular algoritmo de (Viola & Jones, 2001). Los autores realizan la selección de las características HAAR relevantes usando el algoritmo Adaboost y una vez estas han sido seleccionadas, se combinan para formar una etapa de clasificación. Los autores construyen varias etapas y las organizan en lo que se conoce como clasificador en cascada.

9


En la etapa de detección, una ventana analiza las múltiples regiones de una imagen de prueba a diferentes escalas. Cada imagen producto del enventanado es entonces analizada por la cascada de clasificadores para dar un veredicto. Los autores realizan pruebas de la implementación de su algoritmo usando 50 imágenes pertenecientes a dos personas de la base de datos FEETUM. El porcentaje de fallo para la persona 1 fue del 96% y para la persona 2 del 100%. El tiempo de procesamiento promedio por imagen en la prueba con la persona 1 y con la persona 2 fue de 40.24ms y 38.45 ms respectivamente, lo cual permite deducir que en el mejor de los casos el detector funciona a 24 frames por segundo.

2.2.1 Antecedentes InternacionalesQué trabajos se destacan a nivel internacional.

2.2.2 Antecedentes NacionalesQué trabajos se destacan a nivel nacional.

2.2.3 Antecedentes RegionalesQué trabajos se destacan a nivel regional (en la ciudad o en la universidad).

2.3 Identificación personal por medio de imágenes

2.4 Detección facial basada en clasificadores en cascada, algoritmos boosting y características NPD

2.4.1 Esquema general

Los métodos de detección facial basados en algoritmos boosting y clasificación en cascada son en esencia un clasificador binario pero que a diferencia de algoritmos de clasificación como las redes neuronales o máquinas de soporte vectorial, presentan ciertas particularidades en su arquitectura y método de entrenamiento que los hacen más adecuados para resolver el problema de la detección facial. Se iniciara esta exposición teórica mencionando los 4 componentes esenciales que deben definirse para la construcción de un detector facial basado en estos clasificadores:

La característica El weak classifier (clasificador debil) El strong learn (clasificador fuerte) La arquitectura de clasificación, generalmente clasificación en cascada

10


Una vez se han definido estos 4 componentes, la siguiente tarea es relacionarlos en una estructura jerárquica como la mostrada en la Figura 2.5, para esto se siguen los siguientes pasos:

Extracción del mejor conjunto de características Construcción de los weak classifiers a partir de las características

seleccionadas Construcción de un conjunto de strong classifiers a partir de los weak learns Construcción del clasificador final a partir del conjunto de strong clasifiers

Una vez que el clasificador ha sido construido, puede usarse para analizar las múltiples regiones de una imagen de prueba, a diferentes escalas.

Figura 2.5 Estructura jerárquica de un detector facial basado en algoritmos boosting y clasificación en cascada

2.4.2 Característica

En detección facial, una característica es una función o regla matemática que codifica alguna estructura de interés de la imagen, en un número o vector. Generalmente estas son definidas para una imagen rectangular de determinado tamaño, esto se debe a que así puede definirse un espacio finito de características. No todas las características pertenecientes a un espacio son útiles, por lo que estas deben pasar por un proceso de selección donde se escoja las que mejor codifiquen las imágenes de interés, en este caso rostros. Una característica muy popular en detección facial es la HAAR, usada por (Viola & Jones, 2001), (Lienhart & Maydt, 2002) y (Bo Wu et al., 2004), esta genera un

11


espacio de más de 180000 características si se define para una ventana rectangular de tamaño 24×24 pixeles. En particular en este trabajo de grado, se utilizan las características NPD descrita en la siguiente subsección.

2.4.2.1 Características NPD

Las características NPD son un conjunto de funciones propuestas por (Liao, Jain, & Li, 2012) para codificar la información de imágenes de rostros. Estas características miden la diferencia relativa entre los valores de dos pixeles de una imagen. Matemáticamente una característica NPD, puede ser escrita como:

f ( x , y )=(x− y )x+ y Ecuación

2.1

Donde x , y ≥0 son los valores de intensidad de dos pixeles en una imagen, y f (0,0) se define como 0 para evitar la indeterminación en la coordenada (0,0). La Figura2.6 muestra la representación de una característica NPD siendo evaluada sobre una imagen, nótese como la dirección del vector apunta hacia el pixel de mayor intensidad.

Figura 2.6 Ejemplo de cómo puede interpretarse la evaluación de una característica NPD en una imagen.

La Error: Reference source not found presenta algunas propiedades importantes discutidas a continuación:

Antisimetrica: La función que representa una característica NPD es anti simétrica, esto matemáticamente significa que:

f ( x , y )=−f ( y , x )Ecuación

2.2

Lo anterior implica que tanto f ( x , y ) como f ( y , x ) en esencia extraen la misma información sobre una imagen, por lo cual, podemos reducir el conjunto de

12


características NPD posibles, al definir un orden único en el cual estas son generadas. Supongamos entonces que tenemos una ventana de análisis de tamaño n×n, esta puede ser representada como un vector p-dimensional donde p=n×n, ahora si calculamos todas las posibles combinaciones geométricas que una característica NPD f (x i , y i ) pude tener, bajo la restricción de que las coordenadas (i , j) en la ventana de análisis sean elegidas de tal forma que 1≤i ≤ j≤n×n, el resultado será d=p (p+1)/2. En un sencillo ejemplo, si se calcula el total de características NPD de una ventana de análisis de 20×20 pixeles, el resultado será 79800, lo cual es un conjunto muy reducido comparado con las más de 180000 características HAAR existentes en una ventana de análisis de 24x24 en el detector de (Viola & Jones, 2001).

Invariancia a la escala: dado un escalar a≠0, la invariancia a la escala se define como:

f (ax ,ay )=f (x , y) Ecuación 2.3

Esta propiedad hace que las características NPD sean invariantes a pequeños cambios de iluminación.

Acotada: Dado que la características NPD se evalúan para valores x , y ≥0, f (x , y ) estará acotada entre [−1,1].

2.4.3 Weak learn

En la teoría de máquinas de aprendizaje se conoce como clasificador débil o weak classifier a un clasificador cuyo desempeño es mejor que una clasificación aleatoria (es decir un error menor a 0.5)(Freund & Schapire, 1995). Ejemplos de clasificadores débiles son el perceptron, decisión stump, reglas simples de probabilidad, arboles de decisión etc. En la Figura 2.7 se muestra el ejemplo de un clasificador débil, clasificando los datos de una región denominada D1, nótese como este no separa adecuadamente las dos clases, mas sin embargo su error de clasificación (0.3) es menor a de 0.5.

13


Figura 2.7 Ejemplo de un clasificador débil (derecha) clasificando una región denominada D1(izquierda). Tomado y adaptado de (Corso, n.d.).

En lo que concierne a la detección facial, un Weak Learn es construido a partir de una o varias características elementales, y su ajuste, se logra por medio del entrenamiento con un conjunto de imágenes de “rostros” y “no rostros”. La salida de este clasificador entonces debe tener una interpretación directa, por ejemplo: 1 para rostro y -1 para no rostro; positivo para rostro y negativo para no rostro etc.

En la siguiente subsección se describirá la construcción de un clasificador débil basado en regresión de árbol y características NPD.

2.4.3.1 Weak classifier a partir de características NPD

En la literatura sobre detección facial, existen características mucho más robustas que las características NPD, por ejemplo (Viola & Jones, 2001) , (Lienhart & Maydt, 2002) y (Bo Wu et al., 2004) construyen un clasificador debil a partir de una sola característica HAAR. Similarmente (J. Li et al., 2011) construye un solo clasificador debil a partir de un solo descriptor SURFT. Lo anterior, es posible porque por que en parte la característica usada extrae bastante información de la región de análisis. Al usar características NPD sin embargo, el proceso de construcción del clasificador débil no es tan sencillo, pues no basta con una sola característica ya que la zona de análisis (2 pixeles) no es muy representativa. Debido a esto, (Liao et al., 2012) proponen construir un clasificador débil, no de una sola característica NPD, sino de un conjunto de ellas, combinándolas en un árbol de regresión CART(Classification And Regression Trees)(Breiman, Friedman, Olshen, & Stone, 1984).

En la estructura de regresión de árbol propuesta por (Liao et al., 2012), cada nodo interior alberga una característica NPD y un umbral de división, y cada nodo terminal alberga un valor de predicción. Cuando una imagen es presentada al nodo raíz del árbol, esta se evalúa usando la característica NPD correspondiente y el resultado es comparado con el umbral de división; Si dicho resultado es menor, el próximo nodo en evaluar la imagen será el nodo derivado izquierdo, en caso

14


contrario, el próximo nodo en analizar la imagen será el nodo derivado derecho. El procedimiento anterior es repetido hasta llegar a algún nodo terminal, entonces la salida del árbol de regresión será el valor de predicción almacenado en dicho nodo.

Ahora bien, la característica NPD y el umbral de división en cada nodo intermedio del árbol, así como el valor de predicción asignado en cada nodo terminal, no son escogidos arbitrariamente; los primeros se seleccionan para dividir las clases rostro/no rostro, de tal forma que en cada nodo derivado la homogeneidad de las clases sea mayor, y el segundo es un valor que se calcula a partir del identificador de clase de cada imagen de entrenamiento que haya terminado en el nodo. Para explicar más a fondo el proceso de construcción del árbol de regresión a partir de características NPD, suponga que en el nodo raíz P se tiene un conjunto de n imágenes de entrenamiento I={( x1 , y1) , (x2 , y2 ) , (x3 , y3 )… (xn , yn ) }, donde y es una variable dicotómica cuyos valores son: 1 para rostro y -1 para no rostro. Supóngase ahora que evaluamos la j-esima característica NPD sobre la totalidad de imágenes del conjunto de entrenamiento, de esta forma se obtendría un conjunto de evaluaciones EV f j={f j (x1 ) , f j (x2 ) , f j (x3 )…f j ( xn ) }. La división del nodo P puede realizarse entonces, al comparar cada valor del conjunto EV f j con un umbral θ, de tal forma que las imágenes de entrenamiento cuyas evaluaciones en el conjunto EV f j sean menores a θ irán al nodo derivado izquierdo L, y en caso contrario al nodo derivado derecho R. Una vez el nodo P ha sido dividido es posible cuantificar que tan homogéneas son las clases en los nodos derivados L y R calculando una medida de impureza dada por la siguiente expresión:

E=PL SL+PRSR Ecuación 2.4

Donde PL es el porcentaje de imágenes en el nodo izquierdo, SL es la varianza entre-clases en el nodo izquierdo, PR el porcentaje de imágenes en el nodo derecho y SR es la varianza entre-clases en el nodo derecho.

Puede definirse entonces la característica NPD óptima f ' y umbral óptimo θ ' en el nodo P, como aquella combinación que bajo el proceso de división descrito hace mínima la medida de impureza, esto matemáticamente puede expresarse como un problema de optimización dado por la siguiente expresión:

( f ' , θ ' )=argminf ,θ

(E ) Ecuación 2.5

15


En un sencillo ejemplo, si la combinación umbral/característica fuese perfecta en el nodo P, al evaluarse en dicho nodo el conjunto de imágenes de entrenamiento, se enviaría a cada nodo derivado solamente imágenes perteneciente a la misma clase, con lo cual la varianza en cada nodo equivaldría a cero y por lo tanto E=0. En el caso contrario, la combinación umbral/característica con el peor desempeño, enviara a cada nodo derivado un número igual de imágenes de diferentes clases, con lo cual la varianza en cada nodo seria máxima y por lo tanto E también será máxima. En la Figura 2.8 se muestran un ejemplo de los casos anteriormente mencionados.

(a) (b)Figura 2.8 Ejemplo de clasificación en un nodo por medio de características NPD. (a) Ejemplo de un caso ideal en donde la característica NPD puede dividir de manera perfecta las clases. Note que en este caso en cada nodo derivado la varianza S será cero y por ende la entropía E también será cero. (b) Ejemplo en donde la característica NPD del nodo realiza la peor clasificación posible. Note que en este caso la varianza de las clases en cada nodo derivado será máxima y por ende la entropía también será máxima.

Un árbol de regresión completo puede ser construido solucionando para cada nodo derivado el problema de optimización de la Error: Reference source notfound. El proceso de división puede ser detenido una vez que en cada nodo exista un bajo porcentaje de imágenes, por ejemplo (Liao et al., 2012) mencionan que detuvieron el proceso de división de nodos, para cuando el nodo terminal presentaba aproximadamente 7% del total de imágenes del nodo raíz.. La Figura2.9 se muestra un ejemplo en donde se han seleccionado 4 características NPD y estas se han combinado formando un árbol de decisión.

16


Figura 2.9 Características NPD seleccionadas y combinadas usando regresión de árbol (Liao et al., 2012). (Izquierda) 4 características NPD seleccionadas en el proceso de aprendizaje. (Derecha) Características NPD adecuadamente combinadas en un árbol de decisión

Una vez que el árbol de regresión ha sido construido, la asignación de la salida en cada nodo terminal se calcula como la media de las clases en el nodo, así dado un nodo terminal Tm puede establecerse su salida como:

Cm=∑i=1

n

w i y i δ (x i∈ Am )

∑i=1

n

w i δ (x i∈ Am )Ecuación

2.6

Donde w i y y i corresponden al peso y la etiqueta de clase de la i-esima imagen x i respectivamente, Am es el conjunto de imágenes de entrenamiento que llegaron al nodo Tm, y δ ( xi∈ Am ) es 1 cuando x i pertenece a Am y 0 en caso contrario.

Aunque (Liao et al., 2012) mencionan que la selección y combinación en regresión de árbol la realizan usando CART, no exponen una metodología clara que pueda ser reproducible, razón por la cual en este trabajo de grado se propone un método de selección de características NPD y combinación en regresión de árbol basado en los conceptos matemáticos sobre arboles de regresión expuestos por (Breiman et al., 1984).

2.4.4 Strong classifier

En inteligencia artificial un strong Learn o clasificador fuerte, es un clasificador capaz de realizar una predicción muy exacta sobre un conjunto de muestras aleatorias (Freund & Schapire, 1995). Ejemplo de clasificadores fuertes son las redes neuronales, las máquinas de soporte vectorial, redes bayesianas etc. En la teoría de algoritmos boosting (Freund & Schapire, 1995), (Schapire & Schapire, 1999) y (Friedman, Hastie, & Tibshirani, 2000) un clasificador fuerte es construido

17


a partir de un conjunto de clasificadores débiles, de tal forma que la exactitud de este nuevo clasificador será igual o mayor que la de cualquier clasificador débil individual. Ejemplos de algoritmos para construir clasificadores fuertes a partir de clasificadores débiles son: adaboost, real adaboost, gente boost, logit boost etc. Estos métodos tienen como común denominador un proceso de actualización de muestras en el cual, aquellas que han sido correctamente clasificadas disminuyen sus pesos, mientras que las que aún no han sido correctamente clasificadas aumentan sus pesos. Con lo anterior se consigue que el proceso de búsqueda de clasificadores débiles, tienda a buscar aquellos capaces de clasificar correctamente, las muestras aun incorrectamente clasificadas. La figura xxx muestra un ejemplo de clasificador fuerte construido a partir de 3 clasificadores débiles usando AdaBoost, nótese como individualmente ningún clasificador débil logra clasificar correctamente las muestras, pero adecuadamente combinados, conforman un clasificador muy exacto.

Figura 2.10 Ejemplo de clasificador fuerte construido a partir de clasificadores débiles usando AdaBoost. Tomado y adaptado de (Corso, n.d.).

En la siguiente subsección se describirá el algoritmo Gentle AdaBoost, usado en este trabajo de grado para construir clasificadores fuertes, a partir de clasificadores débiles de salida real.

2.4.4.1 Gentle AdaBoost

Gentle AdaBoost(Friedman et al., 2000) es un algoritmo útil para combinar clasificadores débiles de salida real. Este, en cada iteración requiere un clasificador f m(x), que disminuya el error cuadrático, entre la predicción y la salida verdadera de cada muestra de entrenamiento. En cada iteración los pesos de cada muestra son modificados de acuerdo a la predicción realizada por el clasificador f m(x) construido; muestras bien clasificadas disminuyen su peso en la función de error, mientras que las mal clasificadas aumentan su peso, para que

18


así sean tenidas mucho más en cuenta, en las próximas iteraciones. El clasificador final puede verse como un modelo aditivo conformado por todos los clasificadores seleccionados en cada iteración. El procedimiento completo es mostrado en el Algoritmo 1.

Asigne inicialmente a cada muestra x i un peso w i=1N

Repita para m=1,2,3,4…M :(a) Encuentre la función de regresión f m(x) que disminuya la el error

cuadrático medio entre la muestra xi y su etiqueta yi(b) Actualice el Strong Learn F(X) F(X)+fm(x)(c) Actualice wi wi exp(-yi*wi) y renormalice

La salida del clasificador final sera sign(F(X))= fm(x)Algoritmo 1 Algoritmo Gentle AdaBoost propuesto por (Friedman et al., 2000) para combinar clasificadores de salida real.

2.4.5 Clasificación en cascada

Típicamente los algoritmos de clasificación usan un número de cálculos NC constante para cada muestra de análisis. Por ejemplo una red neuronal debe evaluarse en su totalidad para tomar una decisión sobre una muestra de entrada, si quisiéramos analizar una imagen mediante enventanado bajo este esquema, terminaríamos realizando un numero de cálculos muy elevado para el total de ventanas, convirtiendo este enfoque en impráctico. La solución a lo anterior, nace con el concepto de clasificación en cascada y fue uno de los grandes aportes teóricos de (Viola & Jones, 2001). Un clasificador en cascada se compone de un número K de etapas de clasificación, donde cada etapa de la cascada aumenta su complejidad (mayor número de cálculos requerido para su evaluación) y exactitud conforme aumenta de nivel. En La Figura 2.11 se muestra la estructura general de un clasificador en cascada propuesto por (Viola & Jones, 2001).

19


Figura 2.11 Estructura del clasificador en cascada propuesto por (Viola & Jones, 2001).

Esta estructura de clasificación presenta la ventaja de descartar en las primeras etapas, las regiones sencillas de la imagen, con lo cual el costo computacional de evaluación de la cascada disminuye. Para un clasificador de K etapas, con una tasa de verdaderos positivos p por etapa, el número esperado de características a evaluar por cada ventana de análisis está dado por la Ecuación 2.7 (Viola & Jones, 2001):

NC=n0+∑i=1

K

(ni∏j<i p j ) Ecuación 2.7

La tasa de falsos positivos global de un clasificador en cascada está dada por la Ecuación 2.8.

F=∑i=1

K

f i Ecuación 2.8

Donde f i es la tasa de falsos positivos de la i-esima etapa. Similarmente la tasa de detección global está dada por la Ecuación 2.30.

D=∑i=1

K

d i Ecuación 2.9

Donde d i es la tasa de detección de la i-esima etapa.

20


2.5 Reconocimiento facial basado en solución dispersa y MKD

2.5.1 Conceptos previos

2.5.1.1 Keypoints (puntos claves)

Un punto clave en una imagen es una coordenada (x , y ) caracterizada por presentar ciertas propiedades únicas respecto a otras en una vecindad cercana. Dichas propiedades pueden estar relacionadas con la presencia de esquinas, bordes, blobs u otras estructuras de interés; su detección, se realiza por medio de un operador matemático especial, algunos de los más sobresalientes en la literatura son la diferencia de gaussianas (DOG)(Lowe, n.d.), (Lowe, 2004), el laplaciano de la gaussiana(log), (Lindeberg, 1998), detector de esquinas de Harris(Mikolajczyk & Schmid, 2004) etc. Cuando una imagen es convolucionada con alguno de estos operadores, los extremos relativos de la imagen resultante indican la presencia de dichas estructuras, por ejemplo, el determinante hessiano del operador Harris presenta extremos relativos en regiones con presencia de esquinas.

2.5.1.2 Descriptor

En el problema de correspondencia entre imágenes, un descriptor es un vector que codifica la información de la región circundante a un punto clave detectado. Típicamente el radio de esta región, es un múltiplo de la escala σ a la cual se ha dado la detección, de esta manera, es posible normalizar la región respecto a una escala fija y extraer un conjunto de patrones que posteriormente se organizan en un vector, este vector es el que se conoce como descriptor. Ejemplos de descriptores son: el algoritmo SIFT (Lowe, 2004) y el algoritmo SURFT.

2.5.2 Esquema general del reconocimiento facial basado en MKD-SRC

Dada una imagen de un rostro es posible localizar sobre ella un conjunto de puntos claves o keypoints. Estos puntos clave son el resultado de analizar una imagen bajo una serie de criterios matemáticos; las zonas que cumplen estos criterios son los keypoints, las restantes son descartadas. Una vez son extraídos estos puntos claves es necesario codificar su vecindad mediante un algoritmo que en lo posible cumpla ciertos criterios de robustez a la escala, el ruido, la iluminación etc. Como resultado de esta codificación, se obtiene un vector al que

21


se denomina descriptor y contiene la información relevante alrededor de la vecindad del punto clave.

Los algoritmos para detectar puntos claves son ampliamente usados en correspondencia de imágenes, estos son conocidos como detectores. La idea de usar un detector es extraer un gran número de puntos claves que se sean repetibles e invariantes a múltiples transformaciones geométricas, fotométricas y escalares. Si un detector extrae puntos clave repetibles entonces será posible construir descriptores repetibles. En el ámbito del reconocimiento facial esta repetibilidad es deseada, debido a los múltiples cambios de pose, iluminación y expresión que puede tener un rostro.

MKD (descripción multipunto) (Liao & Jain, 2011)(Liao, Jain, & Li, 2013) es una reciente técnica usada para representar un rostro a través de un conjunto de descriptores locales del mismo. Estos descriptores son extraídos de zonas que cumplen criterios de invariancia a la escala, la rotación, la traslación e incluso (Liao et al., 2013) logra construir un conjunto descriptores invariantes a la transformación afín. A diferencia de otras técnicas holísticas o basadas en características locales, MKD no requiere que el rostro este alineado ni asume la presencia de ojos, boca u otras características faciales. MKD puede trabajar tanto en situaciones donde el rostro de entrada es completo u cuando solo es observable una parte. Un diagrama general del reconocimiento facial usando como etapa de matching SRC es mostrado en la Figura 2.12.

22


Figura 2.12 Esquema general del reconocimiento facial basado en MKD-SRC

El reconocimiento de un rostro bajo estos enfoques sigue entonces el siguiente flujo, dada una imagen de prueba, se localizan sobre ella los puntos claves, y con cada uno de ellos se construye un descriptor, de tal forma que una imagen de prueba dará como resultado múltiples puntos claves. La etapa de matching es realizada usando un algoritmo basado en SRC. Nótese que si un rostro en una imagen presenta oclusión o presenta solo una parte, el proceso de matchig en general funcionara debido a que los restantes descriptores podrán ser adecuadamente comparados.

En las siguientes secciones se describirá el algoritmo de detección de puntos claves CanAff y el descriptor GTP, ambos usados en este trabajo de grado en el sistema de reconocimiento facial.

2.5.2.1 CanAff

Uno de los detectores de puntos claves más populares es el algoritmo SIFT propuesto por (Lowe, 2004) y usado en reconocimiento facial basada en MKD-SRC por (Liao & Jain, 2011) y (Sun, Xu, Liu, Kuang, & He, 2014). Este detector presenta invariancia ante los cambios de traslación, rotación y escala; en reconocimiento facial, estas características son deseadas, sobre todo cuando se trabaja con rostros no alineados. Sin embargo, los puntos claves detectados por SIFT presentan dos problemas según (Liao et al., 2013). El primero, es que este no es invariante a la transformación afín, como consecuencia los puntos claves detectados pueden presentar poca repetibilidad ante los cambios de expresión y pose (Esto se debe a que a nivel local estos cambios pueden aproximarse a una transformación afín). El segundo, es que este solo detecta estructuras blob-like

23


(Esto es una consecuencia de usar el operador DOG en el proceso de detección de puntos claves), las cuales en general son muy pocas en un rostro, como consecuencia puede detectarse un bajo número de puntos claves, insuficientes muchas veces para discriminar entre individuos.

CanAff(Liao et al., 2013) ha sido pensado para solucionar estos dos problemas. Primero, este a diferencia de SIFT, es invariante a la transformación afín, por lo cual presenta alta repetibilidad de sus puntos claves antes los cambios de expresión y pose. Segundo, este detector busca los puntos claves sobre los bordes del rostro, esto hace que en general, encuentre un número mucho más elevado que SIFT. El flujo algorítmico de CanAff se resume a continuación:

Se extraen los bordes con el detector de canny a múltiples escalas de la imagen.

Para cada imagen resultante se busca sobre sus bordes las coordenadas que presenten extremos relativos al evaluar el operador LOG a múltiples escalas, estas coordenadas serán los puntos clave.

Para cada punto clave se busca adaptar la vecindad circular encontrada por el operador log, en una región elíptica invariante a la transformación afín usando el proceso iterativo propuesto por (Mikolajczyk & Schmid, 2004).

El procedimiento anterior puede realizarse usando el software “extract_features_64bit.ln” disponible en [cita requerida] bajo la configuración “-sedgelap -noangle”. Este software recibe como parámetro de entrada una imagen y entrega como salida un archivo de texto donde se encuentran confinadas las coordenadas y parámetros de cada región elíptica invariante a la trasformación afín. El formato de salida de cada región elíptica se muestra a continuación:

u v a b c

Cada una de estas variables son los parámetros de una elipse dada por la ecuación:

[ x ' y ' ]M [ x 'y ' ]=1Ecuación

2.10

Donde x '=x−u, y '= y−v y M=[a bb c ] .

La Figura 2.13 muestra una comparación entre los puntos claves detectados sobre un rostro usando CanAff y SIFT, nótese como mientras SIFT encierra una región

24


con un circulo múltiplo de la escala en que ha sido detectado el punto clave, CanAff encierra la región con una elipse cuyos ejes principales indican la deformación que ha sufrido la región producto de una transformación afín. También nótese como el número de puntos claves detectados por CanAff es mucho mayor a los detectados por SIFT.

Figura 2.13 Comparación de puntos clave detectados por SIFT y CanAff (Liao et al., 2013). (Izquierda) solo 37 puntos son detectados por SIFT. (Derecha) CanAff detecta 571 puntos clave (solo los primeros 150 son mostrados, porque de otra forma no se vería el rostro)

Dado que estas regiones serán usadas en un proceso de matching, cada región elíptica deberá transformarse en una región circular de referencia. Esta transformación está dada por la raíz cuadrada de la matriz M , la cual puede expresarse como sigue:

M12=PT D

12 P Ecuación

2.11

Donde P es la matrix de eigenvectores de la matrix M y D12 es una matriz cuya

diagonal son las raíces cuadradas de los eigenvalores asociados. Una vez que se ha transformado cada región elíptica en un círculo, se recortan en rectángulos de 40×40. La Figura 2.14 resume este proceso.

25


Figura 2.14 Normalización de las regiones elípticas en regiones circulares de referencia, por medio de la

transformación afín M12 inversa a la deformación M

−12 .

2.5.2.2 Descriptor GTP

GTP(patrón ternario de Gabor) es un descriptor de puntos claves propuesto por (Liao et al., 2013) para codificar las regiones afines detectadas con CanAff. Dado un conjunto de regiones rectangulares {I 1 ( x , y ) , I 2 ( x , y ) , I3 ( x , y )…I k ( x , y )…I n(x , y )} 40×40, para cada una se opera como sigue:

Normalización Z-Sore: Para compensar las variaciones de iluminación se realiza una transformación de los valores de cada pixel, de tal manera que queden contenidos en el intervalo [0,1], para esto se usa la siguiente ecuación:

INk( x , y)={ I ( x , y )k−u+3σ6σ

,∧I k ( x , y )<0

0 ,∧I k ( x , y )≥0Ecuación

2.12

Donde u y σ son la media y la desviación estándar de I k ( x , y ).

Filtro de Gabor: Con el fin de obtener información sobre los bordes se realiza la convolucion con la parte imaginaria del filtro de Gabor para múltiples ángulos. La ecuación del filtro de Gabor usada está dada por:

G ( x , y )=‖K u, v‖

2

σ2 e−‖Ku ,v‖

2‖z‖2

2σ 2

sin (‖Ku , v‖2‖z‖2 ) Ecuación

2.13

26


Donde u y v definen la orientación y la escala del kernel de Gabor, respectivamente, z=(x , y ) y K u , v se define como sigue:

Ku , v=K v(cos∅u+sin∅ u)T

Ecuación 2.14

Con K v=Kmax

f v, Kmax=

π2 , f=√2 y ∅ u=

πu8 .

Dado que la región de cada imagen I k (x , y ) es relativamente pequeña ¿) solo se usa una sola escala (v=0) y 4 orientaciones (u={0,2,4,6 }, lo que corresponde a los ángulos 0, 45, 90 y 135) con una desviación estándar σ=1. Se representan entonces estas 4 convolucion entre G ( x , y ) y I k (x , y ) como:

H i ( x , y )=Gi ( x , y )∗I k ( x , y ) ,i=0,1,2 y 3Ecuación

2.15

Donde i hace referencia a cada uno de los 4 ángulos.

LTP(Patron Ternario Local): Las 4 convoluciones H i ( x , y ) se codifican por medio de la siguiente expresión:

LTP t ( x , y )=∑0

3

3 i [ (H i ( x , y )← t )+2 (H i (x , y )>t ) ] Ecuación 2.16

Donde t es un pequeño valor, el cual debe ajustarse para que los cambios de iluminación tengan la menor incidencia posible en la codificación (los cambios de iluminación afectan la codificación debido a que la parte imaginaria del filtro de Gabor se comporta como un filtro pasa altos, por lo cual puede ser muy sensible a borde producidos por sobras de la cara). La nueva expresión LTP t ( x , y ) es una imagen 40×40 con valores confinados entre 0 y 34=81.

Histograma: Con el objetivo de transformar la información contenida en cada una de las codificaciones LTP t ( x , y ) en un vector se procede de la siguiente manera. Primero se divide LTP t ( x , y ) en 4×4 celdas, de esta manera cada celda tendrá 10×10 pixeles. Para cada una de las celdas de 10×10 pixeles se calcula un histograma, estos se concatenan formando un vector de 4 x 4 x81=1296 de longitud.

27


El proceso de construcción del descriptor GTP para una sola región afín detectada con CanAff, se ejemplifica en la Figura 2.15.

Figura 2.15 Proceso de construcción del descriptor GTP para una sola región afín detectada con CanAff.

2.5.3 MKD usando GTP

Par usar el descriptor GTP en un sistema de reconocimiento facial, primero debe construirse una base de datos de descriptores con los cuales comparar los descriptores de una imagen patrón. Dicho esto, en la fase de entrenamiento se tendrá por cada imagen un número posiblemente diferente de histogramas de longitud 1296, estos histogramas pueden ser organizados en una matriz como sigue:

D= [D1 D2 …DC ] Ecuación 2.17

Donde el DC es una matriz de 1296 filas que contiene en sus columnas los descriptores de todas las imágenes de rostros pertenecientes al individuo C.

La matriz D en general tendrá un número mucho mayor de columnas, que de filas, además, mucho de los vectores columna estarán posiblemente correlacionados debido que han sido extraídos de zonas del rostro muy similares entre individuos, como por ejemplo la frente, las mejillas etc. Lo anterior implica que es necesario realizar un proceso de reducción de dimensión que conserve solo la información relevante del conjunto de descriptores, además que al reducirse la dimensión, el proceso de matching podrá relizarse mucho más rápido. Este proceso de reducción de dimensión (Liao & Jain, 2011) al igual que (Liao et al., 2013) y (Ge, Shi, & Src, n.d.), lo realizan usando PCA. Se define a continuación la matriz de descriptores de dimensión reducida como:

28


D pca=WT D

Ecuación 2.18

Donde W es una matriz cuyos vectores columna albergan los primeros L eigenvectores asociados a los eigenvalores más altos de la matriz D. Una vez que se ha construido la matriz D pca, puede entonces usarse en un proceso de comparacion. Para esto, los descriptores Y , correspondientes a una imagen de prueba deben ser primero mapeados a este nuevo eigenespacio W :

Y pca=WT Y Ecuación

2.19

Una vez se tienen tanto los descriptores correspondientes a la base de datos (D pca

), como los correspondientes la imagen de prueba (Y pca) en términos del mismo espacio vectorial (W ), el proceso de comparación puede ser realizado.

2.5.4 SCR

Recientemente (Yang et al., 2007) y (Wright, Yang, Ganesh, Sastry, & Ma, 2009) han propuesto usar la representación lineal dispersa de una imagen en términos de una gran base de datos, para inferir su clase de pertenecía. Este método es denominado por los autores como SCR (clasificación basada en representación dispersa) y aunque originalmente ha sido expuesto para imágenes, (Liao & Jain, 2011), (Liao et al., 2013) y (Sun et al., 2014) han ampliado su uso a descriptores faciales. En esta sección se describirá la formulación de SRC para imágenes, y en la siguiente sección se describirá para descriptores (MKD-SRC). Sea un conjunto de muestras de entrenamiento Ai= [v i ,1 , v i ,2 ,…v i , ni ]∈R

m×n, y correspondientes a la i-esima clase, es posible aproximar cualquier nueva muestra y∈Rmcorrespondiente a la misma clase por medio de una combinación lineal:

y=αi , 1 vi , 1+αi , 2 vi , 2,…+αi , niv i , ni Ecuación 2.20

Dado que la clase Ai en realidad es desconocida se define a continuación la matriz que contiene la totalidad de las clases:

A=[ A1 , A2… Ai… Ak ] Ecuación 2.21

29


De tal forma que la combinación lineal de la ecuación xx puede expresarse como:

y=A x0 Ecuación 2.22

Donde x0=[0 ,…,0 , α i1 , α i2 ,…,α¿ ,0 ,…,0] es un vector disperso, cuyos coeficientes son cero, excepto para la i-esima clase.

En el caso ideal en que se pudiese obtener la solución x0, la clasificación de una nueva muestra y se limitaría solamente a revisar la posición inicial, a partir de la cual los coeficientes α son diferentes de cero. Por desgracia, en el problema de reconocimiento facial, la cantidad de imágenes de muestra en una base de datos fácilmente puede superar a la dimensión de las imágenes, con lo cual el sistema la Ax= y tendrá infinitas soluciones. Lo anterior puede solucionarse imponiendo que las soluciones sean dispersas, esto es:

x0=argmin‖x‖0 sujetoa y=AxEcuación

2.23

Donde ‖x‖0 denota la l0-norma, la cual cuenta el número de valores diferentes a cero en del vector x. Un problema que surge con la Ecuación 2.23 es que no existe un método mejor que el heurístico exhaustivo para para encontrar sus soluciones, pero se ha demostrado que si la solución x0 es suficientemente dispersa, la solución al problema con restricción de mínima norma l0, es igual a la del problema con restricción de mínima norma l1 (Wright et al., 2009):

x1=argmin‖x‖1 sujeto a y=AxEcuación

2.24

El anterior problema puede ser resuelto usando métodos de optimización convexa, en particular en este trabajo se usa el propuesto por (Y. Li & Osher, 2009).

La Figura 2.16 muestra un ejemplo en donde se busca clasificar un rostro usando la solución dispersa obtenida del problema y=Ax bajo restricción de que x tenga mínima norma l1. La matriz A está conformada por 1207 imágenes de rostros aleatoriamente seleccionados de la base de datos YALE B extendida. Nótese como los dos coeficientes más altos corresponden a la clase de pertenencia del rostro de prueba y como los demás coeficientes, o son muy pequeños, o son cero.

30


Figura 2.16 clasificación de un rostro usando la solución dispersa del sistema de ecuaciones Ax= y bajo la restricción de que x tenga norma mínima l1 (Wright et al., 2009). Los vectores columna de la matriz A están conformados por 1207 imágenes aleatoriamente seleccionadas de la base de datos YALE B extendida. Cada imagen ha sido redimensionada a un tamaño de 10×12 y concatenado para conformar un vector de 120-D. Nótese como los dos coeficientes más altos corresponden a la clase de pertenencia del rostro de prueba y , y como los demás coeficientes, o son muy pequeños, o son cero.

2.5.5 MKD-SRC usando GTP como descriptor

Como se mencionó en la anterior sección, existe una extensión de SRC para trabajar con descriptores. Esta extensión es directa y el único cambio es en el vector de prueba, el cual ya no es una imagen si no una matriz de descriptores. Basándose en (Liao et al., 2013) y usando la notación que se ha venido trabajado en el apartado de MKD puede definirse el problema de minimización l1 cuando se trabaja con descriptores como:

X=argminX

∑1

n

‖x i‖1 sujetoaY pca=D pca X Ecuación 2.25

Donde Y pca es una matriz cuyos vectores columna contienen los descriptores de una imagen de prueba, D pca simboliza la matriz de descriptores de la totalidad de la base de datos y X es una matriz cuyos vectores columna almacenan cada una de las soluciones dispersas de la ecuación dada a continuación:

x i=argminx i

‖x i‖sujeto a y pcai=D pcax i ,i=1,2,…. ,nEcuación

2.26

Una vez que se ha resuelto la Ecuación 2.26 para los n descriptores de la imagen de prueba, la clasificación puede realizarse buscando la clase c cuyos coeficientes de aporte en el vector x i minimicen el error de reconstrucción cuadrático, es decir:

Ecuación 2.27

31


c=minc (1

n∑i=1

n

‖y pcai−Dpcac δc ( xi)‖22)

Donde D pcac=WTD c son los descriptores de dimensión reducida, pertenecientes a

las imágenes de entrenamiento del individuo c, y δ c es una función que selecciona solo los coeficientes pertenecientes a la clase c y establece a cero los restantes.

2.5.6 Minimización L1 usando coordenada descendente

Hasta el momento se ha hablado de la solución dispersa de un problema de minimización l1, pero no se ha dado un algoritmo a seguir para obtener dicha solución. Aun que existe una gran variedad de métodos (Candes, Candes, Romberg, & Romberg, 2005), en este trabajo de grado en particular se usa el propuesto por (Y. Li & Osher, 2009), ya que presenta ciertas facilidades de implementación y los autores reportan tiempos muy cortos de convergencia. Este algoritmo aproxima un problema de minimizaciónl1, a un problema de regularización, dado por la ecuación:

E (u )=‖u‖1+ λ‖Au−f‖22

Ecuación 2.28

Donde f ∈ Rm, A es una matriz m×n con n>m, y λ es un factor de regularización, el cual si es muy grande, transforma la ecuación en un problema de minimización de error cuadrático, y si es muy pequeño tendera a un problema de minimización l1. La Ecuación 2.28 cumple ciertos criterios de convexidad que pueden ser aprovechados para la búsqueda de un mínimo global. Este mínimo, es buscado solucionando iterativamente la ecuación para cada coordenada u j como variable y eligiendo la que produzca el mayor decrecimiento en la función de costo E. Sea a j la j-esima columna de la matriz A, a ij el valor de la i-esima fila y j-esima columna de A y f i el i-esimo componente del vector f , el valor óptimo u j que minimiza la Ecuación 2.28 para todas las demás coordenadas fijas es:

~u j=1

‖a j‖22 shrink (β j ,

12λ ) Ecuación

2.29

Donde el operador shrink se define como:

32


shrink ( z1 , z2 )={z1−z2 ,0 ,

z1+z2 ,

z1>z2

− z1≤ z2≤z2

z1← z2

Y β j=∑iaij (f i−∑k ≠ j aikuk).

Una vez ha sido solucionada Ecuación 2.29, puede calcularse el decrecimiento de la función de costo E, al actualizar la j-esima coordenada de u. Este decrecimiento puede expresarse como sigue:

∆ E j=E (u1,…u j…,un )−E (u1 ,…~u j…,un )

¿ λ‖a j‖22 (u j−~u j )(u j+~u j−

2 β j

‖a j‖22 )+|u j|−|~u j| Ecuación

2.30

La idea del algoritmo propuesto por (Y. Li & Osher, 2009), es iterativamente encontrar las soluciones optimas u j que minimizan la ecuación de coste E (usando la Ecuación 2.29) y escoger solamente la que maximiza la Ecuación 2.30. Este valor u j es entonces actualizado en el vector u. El proceso iterativo completo es mostrado en el Error: Reference source not found.

1. Calcular inicialmente: w=(‖a1‖22 ,‖a2‖2

2…‖a j‖22...‖an‖2

2);2. Inicializar: u=0, β=AT f ;3. Iterar hasta la convergencia:4. ~u j=

1w j

shrink (β , 12 λ );

5. j=argmaxi

∆ Ei,

6. Actualizar uik +1=ui

k para i≠ j,7. u j

k +1=~u j;8. βk+1=βk−w j|u j

k−~u|(AT A )e j,9. βk+1=β j

k.Algoritmo 2 procedimiento propuesto por (Y. Li & Osher, 2009) para encontrar el vector disperso u que soluciona la Ecuación 2.28

33


2.6 ConclusionesJustifique la selección de los métodos, técnicas o procedimientos que se utilizaron como resultado del estudio consignado en el marco teórico.

34

TÍTULO DEL PROYECTO DE GRADOSoftware del sistema

3. Software del sistema

El sistema de identificación de personas por medio de imágenes del rostro, en este trabajo se compone de 2 etapas principales:

Detector facial: El detector facial es el encargado de localizar tanto las coordenadas como la escala de cada uno de los rostros humanos presentes en una imagen de prueba dada.

Reconocedor facial: El reconocedor facial estará encargado de asignar el nombre correspondiente a cada rostro detectado por el detector facial.

El esquema general del sistema se describe en la figura xxx

Figura 3.17 Sistema de identificación de personas por medio de imágenes del rostro en espectro visible

3.1 Detector facial

El detector facial implementado, está compuesto por un conjunto de etapas de clasificación organizadas en una estructura en cascada. En cada etapa de la cascada, un clasificador puede tomar una decisión independiente de las demás etapas sobre una ventana de análisis deslizante. En este esquema, una ventana será declarada como “rostro”, si todas las etapas de clasificación declaran a la ventana como “rostro”, y será declarada como “no rostro”, si alguna de las etapas de clasificación la declara como “no rostro”. El diagrama de bloques del detector es mostrado en la Figura 3.18.

35


Figura 3.18 Diagrama de bloques del detector facial. Este se compone de un numero de etapas de clasificación, donde cada etapa

Con el objetivo de representar algorítmicamente el proceso de detección facial, se definirán los siguientes términos.

Ventana de análisis: Región rectangular de interés en una imagen. Escala: Área de una ventana de análisis, en este trabajo solo se

consideraron regiones de análisis cuadradas. Se simbolizara de ahora en adelante la escala de una ventana de análisis como como Z.

Factor de escala: Número de veces por el cual crece el área de una ventana de análisis. Se simbolizara el factor de escala como K z.

Factor de paso: El factor de paso es un porcentaje de la longitud en pixeles de una arista de la ventana de análisis, en que esta podrá moverse en dirección paralela a dicha arista. Lo anterior significa que para una ventana de análisis puede definirse dos factores de escala; uno en la dirección x y otro en la dirección y. Dado que en este trabajo solo se consideran ventanas de análisis cuadradas, el factor de paso será uno solo y se simbolizara como K p.

El algoritmo implementado para detectar rostros en una imagen de tamaño m×n, se muestra como un diagrama de flujo en la Figura 3.19 y se explica a continuación:

36


Figura 3.19 Algoritmo implementado para detectar rostros en una imagen de tamaño m×n

Establecer parámetros iniciales de la ventana de análisis: Inicialmente se establece la coordenada inicial desde donde se empezara a enventanar (x , y )=(0,0), el tamaño inicial de la ventana Z=Z0, el factor de escala K z y el factor de paso K p.

Enventanar la imagen: En este paso se debe extraer de la imagen la región encerrada por la ventana de análisis de tamaño Z×Z, ubicada en la coordenada (x , y ).

Evaluar el clasificador en cascada: en este paso la región enventanada es evaluada por el clasificador en cascada, para ubicar los posibles rostros en la escala Z de analisis.

37


Desplazar la ventana en la dirección y: En este paso se debe deslizar la ventana de análisis una distancia de K P√Z en la dirección y, es decir y← y+K P√Z.

Desplazar la ventana en la dirección x: En este paso se debe deslizar la imagen una distancia de K P√Z en la dirección x, es decir x← x+KP√Z , además debe establecerse y=0 puesto que se debe evaluar nuevamente la imagen de izquierda a derecha.

Enventanar con un nuevo factor de escala: En este paso se incrementa la escala de la ventana de análisis por un factor de K z, es decir Z←K z Z, además se debe realizar el enventanado nuevamente desde la posición inicial, es decir que (x , y )=(0,0). Este paso es importante porque permite realizar nuevas búsquedas de rostros a diferentes escalas.

Es importante aclarar que más que implementarse un algoritmo de detección facial particular, se ha implementado un sistema capaz de emular la estructura de un clasificador en cascada, a partir de la información almacenada en un archivo XML, en la fase de entrenamiento. El archivo XLM contiene toda la información sobre cada etapa de clasificación, las regresiones de árbol que componen cada etapa y las características NPD de cada árbol de regresión. En la siguiente sección se describirá el algoritmo de construcción de la cascada de clasificadores, encargado también de construir este archivo.

3.1.1 Construcción y entrenamiento del clasificador en cascada

Hasta el momento se ha expuesto el funcionamiento del detector facial implementado, sin embargo no se ha ahondando en los detalles técnicos y matemáticos que hacen que este funcione. En esta sección se explicara el algoritmo para la construcción de la cascada de clasificadores mas no la construcción de cada clasificador en si (ver sección siguiente).

La idea básica en la construcción de una cascada de clasificadores, es mantener la tasa de detección global aproximadamente constante, mientras se disminuye al máximo la tasa de falsos positivos global. Esto se consigue entrenando el clasificador de cada etapa con el mismo conjunto de imágenes de “rostros”, y usando los falsos positivos de la etapa anterior, como el conjunto de imágenes de “no rostros”. Cuando el falsificador aumenta de tamaño (mas etapas), este se vuelve mucho más exacto, lo cual implica que los falsos positivos seleccionados para entrenar una nueva etapa serán cada vez más difíciles, esto resulta en que

38


cada etapa crece en orden de complejidad (mayor número de clasificadores débiles, en este caso regresiones de árbol). El diagrama de bloques del algoritmo constructor de la cascada de clasificadores se muestra en la Figura 3.20 y sus pasos son descritos a continuación:

Figura 3.20 Diagrama de bloques del algoritmo encargado de construir la cascada de clasificadores.

Inicio y enventado: Cuando se inicia la construcción de la cascada de clasificadores, no existe ninguna etapa aun construida, por lo cual el conjunto de imágenes de “no rostros”, se obtiene por medio del enventanado sobre un banco de imágenes en las cuales se tiene la certeza de que no existe ningún rostro visible. Dado que para el entrenamiento de cada clasificador se requiere que las imágenes tengan el mismo tamaño, cada imagen producto del enventanado se redimensiona a un tamaño de n×n.

Construir una nueva etapa de clasificación: La tarea de esta etapa es usar el conjunto de imágenes de rostros y no-rostros, para construir un clasificador cuya taza de falsos positivos f , no sea mayor a una tasa de falsos postivos máxima permitida f max, y su taza de detección d , no sea menor a una tasa de detección mínima permitida dmin.

39


Calcular la tasa de falsos positivos global alcanzada: Para realiza el computo de la taza de falsos positivos global alcanzada Fa en la etapa k-esima, esta etapa usa la siguiente expresión:

Fa=∏i=1

i=k

f ai

Donde f ai es la taza de falsos positivos alcanzada al finalizar el entrenamiento de la etapa de clasificación i-esima.

Evaluar el clasificador en cascada actual: Cuando la tasa de falsos positivos global alcanzada por la cascada de clasificadores aun no es menor a una taza de falsos positivos global mínimaFGmin, se deberá construir otra etapa de clasificación. Para construir esta nueva etapa, se aprovecha el hecho de que ya existe previamente un numero de etapas construidas y envés de enventanar sobre el conjunto del banco de imágenes de no-rostros, se realiza un escaneo con la cascada de clasificadores; imágenes que sean mal clasificadas (falsos positivos), conformaran el conjunto negativo (imágenes de no-rostros) de entrenamiento de la próxima etapa.

Al finalizar el entrenamiento el algoritmo habla construido un conjunto de etapas de clasificación, cada etapa estará construida por un conjunto de árboles de regresión, y estos a su vez por una característica NPD en cada nodo. Esta información se almacena en un archivo XLM para que posteriormente el sistema de detección facial pueda emular el clasificador en cascada.

3.1.2 Funcionamiento de cada etapa de clasificación

Dentro de cada etapa de clasificación existe un conjunto de árboles de regresión que toman una decisión sobre una imagen dada; algunos árboles de regresión opinaran que la imagen es un “rostro” (salida real entre 0 y 1) y otros opinaran que es un “no rostro” (salida real entre -1,0). Una vez que todos los arboles de regresión han sido evaluados, sus salidas son entonces sumadas para tomar una decisión final sobre la imagen de entrada; si dicha salida es mayor a 0, se declara a la imagen como rostro, y en caso contrario, cuando sea menor a cero, se declara a la imagen como “no rostro”. El esquema interno de una etapa de clasificación es mostrado en la Figura 3.21.

40


Figura 3.21 Esquema interno de una etapa de clasificación

Cabe aclarar que las imágenes que entran a una etapa de clasificación son las que la anterior etapa clasificado como rostros, estas imágenes pueden ser de cualquier tamaño ya que cada etapa se ha diseñado para ser invariante a la escala.

3.1.3 Construcción de los clasificadores en cada etapa

El clasificador de cada etapa se construye partiendo de un conjunto de clasificadores menos complejos, denominados “weak classifiers” en la teoría de boosting. En este trabajo de grado en particular dichos clasificadores son un conjunto de árboles de regresión que combinados adecuadamente producen un clasificador muy exacto. Para combinar los árboles de regresión se ha usado el algoritmo Gentle adaBoost, el cual se ha adaptado y modificado ligeramente para producir un clasificador acorde a una taza de detección mínima establecida, y a una taza de falsos positivos máxima establecida.

La idea básica es iterativamente construir arboles de regresión cuyas predicciones se adapten al conjunto de imágenes de entrenamiento. En cada iteración, una vez que un árbol de regresión ha sido construido, se analiza el resultado de la predicción con cada una de las imagen de entrenamiento; si una imagen es adecuadamente clasificada por el árbol de regresión su peso en la función de error deberá disminuir, por el contrario, si su clasificación ha sido errónea deberá aumentar, para que los arboles de regresión de las próximas iteraciones la tengan más en cuenta.

41


Por defecto Gente Boost, tiende a construir un clasificador cuyo error es mínimo (Falsos positivos +verdaderos negativos), sin embargo en el caso de la detección facial el interés no radica tanto en el error, sino en que el clasificador después del entrenamiento pueda clasificar adecuadamente la mayoría de los rostros mientras descarta la mayoría de los no-rostros. Lo anterior de una manera más técnica significa que el clasificador no deberá tener una taza de detección y de falsos positivos por debajo y por encima de un umbral respectivamente. Definiendo para cada clasificador de la cascada dmin como la taza de detección mínima permitida y f max como la taza de falsos positivos máxima permitida, en una determinada etapa de clasificación deberán construirse arboles de regresión hasta que el siguiente criterio se cumpla:

((d>dmin)∨ (f < f max )) Ecuación 3.31

Note que en la Figura 3.17 cuando dmin tiende a 1 y f max a cero, el criterio será igual al error de clasificación, sin embargo en detección facial con el objetivo de no ser tan restrictivos en cada etapa, el clasificador se elige de tal forma que su tasa de detección sea alta y su taza de falsos positivos no sea tan baja. En un sencillo ejemplo, si construimos un clasificador en cascada de 10 etapas de clasificación, con una taza de detección y de falsos positivos de 0.999 y de 0.2 respetivamente por etapa, aplicando la Ecuación 2.8 se obtiene que la tasa de falsos positivos global esperada será de 1,024×10−7, mientras la tasa de detección global esperada disminuye de manera imperceptible a 0.99004 aproximadamente.

Por otro lado, dado que Gentle boost busca disminuir el error de clasificación, el criterio de la Ecuación 3.31 podría parecer que no se cumple en determinada iteración, pero si se modifica el modelo de salida dado por el algoritmo Gente AdaBoost mediante un umbral como se muestra en la siguiente expresión:

F (X )=∑i=0

i=k

f (x)+u Ecuación 3.32

Puede entonces en cada iteración probarse si para determinado umbral u, el clasificador en la k-esima iteración cumple el criterio dado en la Ecuación 2.1.

3.1.4 Construcción de cada árbol de regresión (Método Propuesto)

42


De todos los pasos a seguir en la construcción de la cascada de clasificadores, este quizá es el más trascendental y laborioso. Aunque existen muchas publicaciones como (Viola & Jones, 2001), (Huang et al., 2007) y (J. Li et al., 2011), en donde se expone de una manera de tallada el método de búsqueda de las características optimas, en el caso de NPD no existe un algoritmo detallado en la única publicación existente (Liao et al., 2012), razón por la cual fue necesario realizar muchas analogías con otras publicaciones en especial con (Viola & Jones, 2001), (J. Li et al., 2011) y (Zhu & Cai, 2012), y además entender a fondo la teoría de regresión de árbol (Breiman et al., 1984) para proponer un algoritmo funcional.

En las siguientes subsecciones se describirá el proceso de evaluación y construcción de un árbol de regresión a partir de características NPD, por razones didácticas se describirá primero el proceso de evaluación y posteriormente se el proceso de construcción.

3.1.4.1 Funcionamiento del árbol

Suponiendo que se ha finalizado el proceso de construcción de un árbol de regresión su esquema típico será como el mostrado en la Figura 3.22.

Figura 3.22 Esquema típico de un árbol de regresión construido a partir de características NPD.

A excepción de los nodos terminales que solo albergan un valor numérico cm asignado en el entrenamiento (construcción), cada uno de los nodos del árbol se componen de una característica NPD y un umbral. Cuando una imagen de entrada

43


es presentada al árbol de regresión, esta primero es analizada por el nodo raíz, entonces la característica NPD es evaluada sobre la imagen y el resultado es comparado con el umbral; si dicho resultado es menor al umbral, la imagen será evaluada por el nodo derivado izquierdo, en caso contrario será evaluada por el nodo derivado derecho. El proceso de evaluación y comparación se repite una y otra vez hasta llegar a algún nodo terminal, entonces la salida del árbol de regresión para la imagen de entrada será el valor cm asignado en dicho nodo, este valor estará en el rango [−1 ,0 ) si la imagen posiblemente es un rostro y entre el rango [ 0,1 ] si la imagen posiblemente es un no rostro. En la figura xxx se define el algoritmo

3.1.4.2 Evaluación optima de la característica NPD

Evaluar una sola característica NPD no supone mayor complejidad, pues solo implica 2 restas y una división, pero tanto en la construcción del clasificador en cascada como en su evaluación, se necesitara evaluar cientos e incluso miles de características NPD, con lo cual es necesario buscar una alternativa mucho más óptima. Para solucionar esto, se propone almacenar en una tabla de traducción, todos los valores posibles, que puedan resultar de la evaluación de cualquier característica NPD sobre una imagen, y así evitar el cálculo directo cada vez que se requiera evaluar alguna característica. Supóngase que la resolución de las imágenes tanto de entrenamiento, como de evaluación, es de 8 bits, entonces por cada pixel x y y requerido para la evaluación de la característica NPD, se tendrán 256 posibles valores, bajo las anteriores condiciones la función f solo puede tener como máximo 256∗256=65536 valores diferentes, de esta forma es posible organizar un arreglo matricial (tabla de traducción) de 256∗256donde cada celda ( i , j ) almacene el valor (i− j )/ (i+ j ), así la evaluación de una característica NPD solo requiere 3 accesos a memoria; los dos accesos para leer los pixeles i y j en la imagen, y el acceso a la celda ( i , j ) (Aunque parezca que acceder a la coordenada (i , j) requiere dos accesos de memoria, realmente no es así, pues es posible organizar la matriz en zonas contiguas de memoria, con lo cual la coordenada en la matriz (i , j) se convierte en la dirección relativa 256∗i+ j).

3.1.4.3 Complejidad en la construcción del árbol

Resolver directamente el problema de optimización dado por la Ecuación 2.5 implica realizar una gran cantidad de cálculos y requiere un uso desmesurado de memoria RAM. Para argumentar esto, se desarrollara algebraicamente la ecuación

44


de entropía para el contexto de la división de un solo nodo y finalmente se expondrá más a fondo ambos problemas.

Supóngase que se tiene un conjunto de imágenes de entrenamiento I={( x1 , y1) , (x2 , y2 ) , (x3 , y3 )… (xn , yn ) } donde x son las imágenes, y y es 1 para la clase “rostro” y -1 para la clase “no rostro”. Supóngase además que se tiene un nodo P de un árbol de regresión, el cual se quiere dividir en dos nodos derivados L y R. Esta división se realizara basándose en el conjunto de evaluaciones de la característica NPD j-esima EV f j={f j (x1 ) , f j (x2 ) , f j (x3 )…f j ( xn ) } y un umbral de comparación θ, de tal forma que aquellas evaluaciones cuyos valores sean menores o iguales a θ, irán al nodo izquierdo L, mientras que las mayores irán al nodo derecho R. Una vez que se ha dividido el nodo P, es posible cuantificar que tan bien han sido separadas las clases (representadas en este caso por las evaluaciones) en los nodos derivados L y R, calculando la entropía de la división dada por la Ecuación 2.4, el desarrollo de esta ecuación es mostrado a continuación. Sea nl y nr=(n−nl) el número de imágenes en el nodo izquierdo L y derecho R después de la división del nodo P respectivamente, la media de las clases en cada nodo estará dada por:

y L=∑i=1

nl

wLi yLi Ecuación 3.33

Y

y R=∑i=1

nr

wRi yRi Ecuación 3.34

Donde y L es la media de las clases en el nodo izquierdo, y R la media de las clases en el nodo derecho, y wL y wR son los pesos renormalizados en el nodo izquierdo y derecho respectivamente. Usando y L puede expresarse la varianza de las clases en el nodo izquierdo como:

SL=∑i=1

nl

wLi ( yLi− y L)2 Ecuación 3.35

Similarmente usando y R puede expresarse la varianza de las clases en el nodo derecho como:

45


SR=∑i=1

nr

wRi ( y Ri− yR )2 Ecuación 3.36

Finalmente la ecuación de entropía para la división del nodo P usando la j-esima característica NPD y el umbral θ estará dada por:

Ep j ,θ=nLn ∑

i=1

n L

wLi ( y Li− y L)2+nRn ∑

i=1

n R

wRi ( yRi− y R )2 Ecuación 3.37

Resolver la Ecuación 3.37 directamente, es decir por el método heurístico presenta dos dificultades en la práctica:

Excesivo uso de memoria: supóngase que se quiere realizar el entrenamiento con imágenes de tamaño 20×20 pixeles, como fue explicado en la sección xxx, de esta manera tendríamos un espacio de búsqueda de 79800 características NPD. Dado que lo ideal es realizar el entrenamiento en el menor tiempo posible, se requiere cargar la mayoría de datos en memoria RAM. Dentro de los datos más importantes se encuentran las evaluaciones del conjunto de características NPD en el conjunto de imágenes de entrenamiento, sea cual fuere el algoritmo de solución, para realizar la búsqueda de las características NPD y el umbral óptimo en cada uno de los nodos de un árbol, como mínimo se necesitara cargar estos datos. Realizar lo anterior con un conjunto de entrenamiento de 20000 imágenes, implica calcular 79800*20000 evaluaciones, dado que la función f tiene salida real, como mínimo se necesitara un tipo float (4 bytes) para representar cada evaluación, por lo que para la totalidad de evaluaciones se necesitara una cantidad de memoria de 79800∗20000∗4≈5.94 gigas.

Excesiva cantidad de cálculos: Para dividir el nodo P la ecuación de entropía (ver Ecuación 3.37) deberá calcularse para todas las combinaciones de características NPD y umbrales posibles, esto con el fin de buscar la combinación óptima que la haga mínima. Por cada cálculo de la ecuación de entropía, deberá ordenarse los valores de las evaluaciones con respecto al umbral, esto con el fin de saber cuáles evaluaciones irán al nodo izquierdo L y cuales evaluaciones irán al nodo derecho R. Los valores del umbral θ que producen configuraciones únicas en los nodos derivados L y R, son los mismos valores de evaluación, pero dado que el nodo L no solo recibe los valores de evaluación menores, sino también los iguales, debe descartarse el valor de evaluación más alto con el fin de asegurar que siempre exista división. Lo anterior permite deducir que para la j-esima característica NPD, deberá calcularse la entropía para n−1 diferentes umbrales, y estos umbrales solo tomaran valores del conjunto dado por la siguiente expresión:

46


EV f j−(EV f j) ¿

Ecuación 3.38

En conclusión, para cada característica NPD se deberá evaluar la entropía dada por la Ecuación 3.37, para los n−1 diferentes umbrales θ dados por el conjunto de la Ecuación 3.38. Cada uno de estos umbrales deberá compararse con los n−1 valores de evaluación restantes dados por el conjunto EV f j−θ, esto con el fin de ubicar cada evaluación en el nodo derivado respectivo. Lo anterior significa que por cada umbral deberán realizarse n−1 operaciones de comparación, esto implica que calcular el conjunto de entropías de una sola característica NPD requiere (n−1 )2 operaciones de comparación, es decir que para la división de un solo nodo se requieren N f (n−1 )2 operaciones de comparación. Suponiendo un conjunto de 20000 imágenes de entrenamiento y un espacio de búsqueda de 79800 características NPD, el total de operaciones de comparación a realizar seria 3.1916808∗1013.

3.1.4.4 Solución al problema de memoria

Aprovechando el mecanismo de evaluación brindado por la tabla de traducción descrita en la sección 3.1.4.2, puede almacenarse la evaluación de cualquier característica NPD f en solo 16 bits. Para esto, envés de almacenar la evaluación de la característica NPD (ver Ecuación 2.1), se almacena una codificación de los valores de cada pixel (de 8 bits) x y y, la expresión usada para esto es la siguiente:

f short=x+256∗yEcuación

3.39

Puesto que f short puede representarse con solo 16 bits, los resultados de las evaluaciones de todas las características NPD en la fase de entrenamiento, podrán almacenarse en la mitad de espacio de memoria que antes se necesitaba, en particular, para el caso del ejemplo de la sección 3.1.4.3, la totalidad de memoria RAM necesaria se reduce de 5.94 gigas a 2.97 gigas.

3.1.4.5 Proceso de división del nodo

Como fue explicado previamente, realizar la división de un solo nodo de manera directa implica realizar un excesivo número de ordenaciones y cálculo de

47


entropías. Para solucionar esto, en este trabajo de grado se ha propuesto un método de división que aprovecha ciertas propiedades algebraicas de la varianza y la media, para así evaluar la esperanza de manera recursiva, además este método solo requiere ordenar los resultados de las evaluaciones de todas las característica NPD una sola vez por árbol, se ha denominado a este método SR (Search Recursive), en lo siguiente se mostrara su deducción.

Supóngase que inicialmente se realiza la evaluación de las N f características NPD sobre un conjunto ordenado de n imágenes de entrenamiento I={x1 , x2 , x3…xn }, y los resultados se organizan en una matriz que se denominara matriz de evaluaciones EV dada por la siguiente expresión:

EV=[ f 1 ( x1 ) f 1 (x2 )f 2 ( x1 ) f j (x2)

⋯f 1 (xn )f j (xn )

⋮ ⋱ ⋮f N f

( x1 ) f N f(x2) ⋯ f N f

(xn )]Cada uno de los vectores fila de la matriz EV representa la evaluación de una característica NPD sobre el conjunto de imágenes de entrenamiento. En lo siguiente, se supondrá que existe un nodo P el cual queremos dividir en dos nodos L y R, encontrando la característica NPD y el umbral optimo que mejor dividan las clases de entrenamiento representadas por sus evaluaciones, bajo el criterio de la ecuación xxx. Para realizar lo anterior, en este análisis se supondrá que existe una matriz asociada al nodo P, la cual se denominara matriz de evaluaciones ordenada, su representación está dada por la siguiente expresión:

EVOP=[ ev p1,1 ev p1,2

ev p2,1 ev p2,2

⋯ev p1 ,n

ev p2 ,n

⋮ ⋱ ⋮ev pN f , 1 ev pN f ,2 ⋯ ev pN f ,n

]Cada i-ésimo vector fila en la matriz EVOP, es el producto de ordenar de menor a mayor el i-ésimo vector fila de la matriz EV , por lo que para un valor evi , j cualquiera de la matriz EVOP, se cumple la siguiente propiedad que se denominara ordenación:

ev pi , j−1≤ev pi , j≤ev pi , j+1

La anterior propiedad es de suma importancia para la búsqueda del umbral óptimo de una característica NPD cualquiera. Dado que en la matriz EVOP los vectores fila

48


se encuentran ordenados de menor a mayor, para cualquier evi , j siempre se puede asegurar que en general, los valores a la izquierda serán menores, y a la derecha en general serán mayores. Lo anterior brinda la posibilidad de usar el mismo valor ev i , j como el umbral de comparación, y de esta manera los valores a la izquierda (incluyéndolo) representaran el nodo derivado izquierdo L y los valores a la derecha el nodo derivado derecho R. Por consiguiente, para la i-ésima característica NPD, las configuraciones posibles de tal manera que exista división en el nodo P, serán generadas por el conjunto de umbrales {ev i, 1 , ev i , 2 , ev i , 3…evi , n−1 }, nótese como se ha excluido el valor evi , n, puesto que para este umbral todas las evaluaciones quedarían perteneciendo al nodo L. Así pues, para cada fila de la matriz EVOP deberá evaluarse la entropía de cada una de las n−1 configuraciones posibles, obteniéndose un vector de entropías representado a continuación para el caso de la i-esima fila:

VE pi=[E pi, 1 , Epi , 2, Epi , 3…Epi , n−1 ]

Cada una de las componentes del vector VE pi, representa la entropía obtenida con cada uno de los n−1 umbrales de división posibles para la característica NPD i-esima, ahora si se supone que la componente mínima del vector VEpi se encuentra en la posición k , podemos expresar la entropía mínima de la división para la característica NPD i-esima como:

Epi=VE pi [k ]

Y en consecuencia, el umbral de división optimo estaría también en la misma posición, pero del vector fila i-esimo de EVOP, este es representado a continuación:

θpi=evi ,k

La entropía mínima y el umbral óptimo de división, deben calcularse para cada una de las N f características NPD, una vez se ha realizado esto, puede construirse entonces el vector de entropías mínimas VE pMIN y el vector de umbrales óptimos de división θpopt, asociados al nodo P. Estos vectores son representados a continuación:

VE pMIN= [Ep1,E p2

, Ep3…EpN f

]

θpopt=[θp1 ,θ p2 , θp3…θp N f ]

49


Cada una de las componentes del vector VE pMIN representa la entropía mínima obtenida al dividir el conjunto de imágenes de entrenamiento I en el nodo P, usando para ello la correspondiente característica NPD y su umbral óptimo de división. Si llamamos h a la posición de la componente mínima del vector VE pMIN, entonces la división optima del nodo P tendría una entropía mínima dada por EP=VE pMIN [h ], y dicha entropía se obtendría al usar la característica NPD f h y un umbral de división θp=θpopt [h ].

Si se analiza el proceso de división del nodo P hasta el momento, el procedimiento más costoso en términos computacionales es la ordenación de la matriz EV para obtener la matriz EVOP, sería deseable entonces no tener que realizar este proceso para cada nuevo nodo a dividir. Lo anterior es posible si se construyen las nuevas matrices de evaluación EVOL y EVOR asociadas a los nodos L y R respectivamente, siguiendo el algoritmo a continuación:

Note que el algoritmo xxx construye las matrices xxx y xxxx de tal forma que siguen cumpliendo la propiedad de ordenación, por lo cual tanto el nodo L como el nodo R pueden ser divididos análogamente a como se dividió el nodo P.

Algo no mencionado hasta el momento es el cálculo óptimo de la ecuación de entropía en la búsqueda del umbral óptimo por cada característica NPD. En este trabajo de grado se derivó un método que permite el cálculo del vector de entropías de manera iterativa, de tal forma que los cálculos previos son aprovechados para calcular las siguientes entropías, se expondrá a continuación este proceso para el caso de la i-esima característica NPD. Sean sy i y swi dos vectores de Rn, cuyas k-esima componentes syi ,k y swi , k están dadas por las siguientes expresiones:

sy i ,k=∑j=1

k

w oi , j yoi , j

swi , k=∑j=1

k

woi , j

50


Donde woi , j y yoi , j representan el peso y la clase (1 para rostros y -1 para no rostros) de la imagen cuya evaluación en la matriz EVOP es ev i , j. Usando las componentes de los vectores syi y swi, puede definirse la media del nodo L como:

y Li ,k=syi ,kswi , k

Y similarmente la media en el nodo R como:

y Ri ,k=sy i , n−sy i ,k+ 1

swi , n−sw i ,k +1

Note como en las ecuaciones xxx y xxx se ha usado swi para renormalizar los pesos en ambos nodos. Ahora, usando y Li , j puede calcularse la varianza (se ha usado la forma) en el nodo L como:

sLi, k=∑j=1

k

(woi , j yoi , j2 )

swi , k− y Li , k

2

Dado que yoi , j solo toma los valores 1 o -1, la ecuación xxx se reduce a:

sLi , k=∑j=1

k

w oi, j

swi , k− y Li , k

2

sLi, k=1− y Li , k2

Similarmente operando para la varianza en el nodo P se obtiene:

sRi,k=1− y Ri ,k

2

Finalmente puede expresarse la entropía de la división del nodo P usando la característica NPD i-esima y el umbral k-esimo como:

Epi , k=k∗sL i,k

+(n−k )∗sR i,k

n

Hasta el momento pareciera que la ecuación xxx no presenta ninguna ventaja con respecto a la ecuación xxx, pero si se reescribe las ecuaciones xxx y xxx como:

sy i ,k=sy i , k−1+woi , k yoi , k

51


Y

swi , k=sw i , k−1+woi , k

Puede verse que cada variable involucrada en el cálculo de la ecuación de entropía puede ser calculada de manera recursiva, por lo tanto es posible calcular el vector VE pi (ecuacion xxx) completo de manera recursiva, empezando desde k=1 hasta k=n−1.

El procedimiento completo se resume en el algoritmo xxxx

3.2 Reconocedor facial

El sistema de reconocimiento facial desarrollado en este trabajo de grado fue pensado para servir como base de desarrollo de futuros algoritmos de reconocimiento facial, reconocimiento de objetos y matching de imágenes en general. Este sistema se compone de 3 bloques fundamentales:

El descriptor abstracto, encargado de extraer una matriz de descriptores de la imagen.

La base de datos de descriptores, donde se almacenan los descriptores de cada individuo que interese reconocer en un futuro.

La etapa de clasificación basada en SRC, encargada de asignar la identidad del rostro en la imagen de prueba, basándose para ello en la comparación de sus descriptores con los de la base de datos.

El diagrama de bloques del sistema completo es mostrado en la Figura 3.23.

Figura 3.23 Sistema de reconocimiento facial implementado

El funcionamiento del sistema es como sigue, dada una imagen de prueba, se extrae un conjunto de descriptores usando para ello el descriptor abstracto. Cada uno de estos descriptores es comparado con los almacenados en la base de datos de descriptores,

52


usando para ello SCR. Basándose en esta comparación, se toma una decisión sobre la identidad del rostro en la imagen de prueba.

Cada uno de los bloques que compone el reconocedor facial, serán explicados en las siguientes subsecciones.

3.2.1 Descriptor abstracto

En este trabajo de grado, más que la implementación específica de un descriptor particular, se conceptualizo un sistema descriptor general que puede servir como interfaz para cualquier descriptor específico. Se ha denominado a este sistema “descriptor abstracto”, y la idea nace de la necesidad de probar diferentes descriptores sin tener que cambiar la implementación del sistema de clasificación SRC y el sistema encargado de manejar la base de datos de descriptores. La interfaz de este sistema se compone de 3 funciones elementales descritas a continuación:

Descriptor_base: la función descriptor base tiene la tarea de extraer un conjunto de características faciales y convertirlas en una representación matricial que se denominara “descriptores base”. Matemáticamente esta función transforma una imagen I en una matriz db, cuyos vectores columna representan cada una de las características extraídas. Muchos descriptores como SIFT, SURF, basados en LBP o GTP funcionan bajo el anterior esquema, en particular GTP, extrae un conjunto de regiones afines de la imagen y las transforma en un conjunto de vectores cuya dimensión es 1296 (ver sección xxx). Note que la descripción dada para esta función no restringe métodos de extracción de características holísticos donde la matriz dbpodría ser solo un vector que representa la totalidad de la cara. La Figura 3.24 muestra el diagrama de bloques de esta función.

Figura 3.24 Diagrama de bloques de la función descriptor-base, esta se compone de dos etapas: un algoritmo de extracción de características faciales y un algoritmo que convierte cada característica en un vector (algoritmo descriptor). La salida de esta función es una matriz db, cuyos vectores columna representan cada una de las características faciales extraídas.

Post-procesamiento: Esta función brinda la posibilidad de realizar un procesamiento extra al conjunto de descriptores que conformaran la base de datos de descriptores. Para entender la utilidad de esta función, suponga que se tiene una base de datos de imágenes de rostros de diferentes individuos, los cuales se desea reconocer en un futuro. Para ello, inicialmente extraemos los descriptores de cada imagen usando la función Descriptor_base, y organizamos dichos descriptores en un arreglo matricial similar al de la Ecuación 2.17. Aunque no existe restricción alguna en usar dicha matriz como la base de datos de descriptores, puede ser deseable realizar un procesamiento extra en miras a

53


mejorar la tasa de reconocimiento y el tiempo de reconocimiento por imagen. Este procesamiento podría involucrar por ejemplo, un proceso de reducción de dimensión (lineal o no lineal) con lo cual se obtendría una nueva matriz de descriptores cuyos vectores columna serian de una dimensión mucho menor. Otra forma en que podría cambiar la matriz de descriptores seria reduciendo el número de columnas, esto podría realizarse con el objetivo de eliminar descriptores poco informativos. Para definir esta función de una manera más precisa, suponga que se ha extraído un conjunto de descriptores base DB, de un conjunto de imágenes de rostros pertenecientes a C diferentes individuos, este conjunto se representa a continuación:

DB={Db1 , Db2, Db3…Dbj…DbC }

Cada una de las componentes del conjunto DB, es una matriz cuyos vectores columna son los descriptores base del conjunto de imágenes de un solo individuo, es decir para el j-esimo individuo se tiene que Dbj=[db( j,1 )

, db( j,2), db( j ,3)

…db( j , i )…], donde db( j, i )

son los descriptores base de la imagen i-esima, del individuo j-esimo. Note que cada matriz del conjunto DB puede tener un número diferente de columnas debido a que por cada individuo puede tenerse un número diferente de imágenes o también, por que el algoritmo usado en la función Descriptor_base puede extraer un número diferente de descriptores dependiendo de la imagen. La función Post-procesamiento entonces, transforma el conjuntoDB en un nuevo conjunto DP={D p1 , Dp2 , Dp3…D pj…D pC } tal que la j-esima componente de este conjunto D pj, es una matriz que corresponde a una nueva representación de la matriz Dbj del conjunto DB. En la definición anterior no se ha impuesto ninguna restricción sobre el número de columnas de las nuevas matrices de descriptores del conjunto DP, lo único que si deben cumplir es que, todas tengan un mismo número de filas, la razón de esto se debe a que cada uno de los vectores columna de estas matrices, conformara la matriz de la base de datos de descriptores D. También es importante puntualizar que la definición de esta función se ha realizado sobre el conjunto total de descriptores base DB, es decir no está restringida a una función que actúe sobre cada una de las componentes individuales del conjunto, o sobre los descriptores base de una imagen individual (En dicho caso dicha función se podría integrar en la función Descriptor-base), esto se debe a que muchos algoritmos de interés para un post-procesamiento podrían involucrar algoritmos de reducción de dimensión como PCA, LDA, ICA, KPCA etc., los cuales en general requieren para su aplicación que todo el conjunto de muestras en este caso descriptores base, inicialmente estén definidos. Por último, puede darse el caso en que no se requiera hacer ningún post-procesamiento a los descriptores base, este sería el caso de un algoritmo descriptor muy robusto o cuyos descriptores sean de una dimensión muy pequeña, en tal caso la función Post-procesamiento no hace nada, es decir el conjunto DB y DP serían iguales. La Figura 3.30 muestra el uso que se le da a esta función en el proceso de construcción de la base de datos de descriptores.

Descriptor-test: Esta función está pensada para extraer los descriptores Y de una imagen, en la fase de prueba. Aunque podría pensarse que esta función es redundante, debido a que la función descriptor-base podría usarse para esta tarea, debe recordarse que existe la posibilidad de realizar un post-procesamiento extra al conjunto de

54


descriptores que conformara la base de datos D, con lo cual se hace necesario realizar un procesamiento similar a los descriptores base extraídos, para transformarlos al mismo espacio vectorial. En un sencillo ejemplo, si la función post-procesamiento consiste en reducir la dimensión del conjunto de matrices de descriptores base DB usando PCA, entonces dada una imagen de prueba, deberá usarse la función Descriptor_base para extraer la matriz de descriptores base, y posteriormente, transformar cada vector columna de esta matriz, al mismo eigenespacio en el cual están representados los vectores columna de la base de datos de descriptores D, esto con el fin de permitir una adecuada comparación entre ambas matrices al usar el clasificador SRC. La Figura 3.25 muestra el diagrama de bloques de esta función.

Figura 3.25 Diagrama de bloques de la función descriptor-test, esta se compone de dos etapas: la función descriptor-base, encargada de extraer los descriptores base de la imagen; y un algoritmo que aplica un post-procesamiento a los descriptores, con el fin de llevarlos al mismo espacio vectorial, en el que están representados los descriptores de la base de datos.

3.2.2 Usando el sistema del descriptor abstracto

Como tal, el sistema del descriptor abstracto, es una caja vacía que debe llenarse con un algún algoritmo descriptor. Se ha intentado en lo posible lograr un sistema muy general que pueda servir como base para el desarrollo de futura aplicaciones tanto de reconocimiento facial, como de reconocimiento de objetos y matching entre imágenes. Dado que uno de los objetivos de este trabajo de grado es implementar un algoritmo de reconocimiento facial, debe por lo tanto implementarse un descriptor particular que pueda ser usado por el sistema del descriptor abstracto. En las siguientes subsecciones, se describirá, dos descriptores particulares implementados con el objetivo de extraer descriptores en imágenes de rostros. Al primero, se lo ha denominado “descriptor resize”, y el segundo es el descriptor GTP cuyo procedimiento algorítmico es explicado en la sección xxx.

3.2.2.1 Descriptor resize

El “descriptor resize” definido en este trabajo de grado, es un descriptor sin post-procesamiento, es decir que los descriptores base extraídos a las imágenes de la base de datos, serán los mismos que conformaran la base de datos de descriptores. El proceso realizado por la función descriptor-base y descriptor-test en este descriptor, consiste

55


en, primero, redimensionar la imagen de entrada de tamaño h×w en una nueva imagen de tamaño hr×wr tal que hr≪h y w r≪w, una vez realizado esto, se concatenan los vectores columna de la representación matricial de esta nueva imagen, obteniéndose la matriz de descriptores db, que en este caso consiste de un solo vector columna de Rhrwr. La Figura 3.26 muestra el diagrama de bloques de la función descriptor-base y descriptor-test para este algoritmo descriptor.

Figura 3.26 Diagrama de bloques de la función descriptor-base y descriptor-test para el descriptor resize.

3.2.2.2 Descriptor GTP

En este trabajo de grado, el descriptor GTP propuesto por (Liao et al., 2013) ha sido adaptado e implementado para ser usado en el sistema del descriptor abstracto. A continuación se describira cada una de las 3 funciones particulares implementadas para este descriptor.

Descriptor-base-GTP: Esta función, estará encargada de convertir una imagen, en una matriz cuyos vectores columna, son los descriptores de cada una de las regiones afines encontradas con el detector de puntos claves CanAff. Como fue explicado en la sección xxxx, a esta matriz se le denomina descriptor GTP y cada uno de sus vector columna pertenecen a R1296. La Figura 3.27 muestra el diagrama de bloques del algoritmo implementado para esta función, este se compone de 3 etapas principales. La primera, corresponde al detector de puntos clave CanAff, encargado de detectar en la imagen un conjunto de regiones afines y encerrarlas con una ellipce. La segunda, es la etapa de normalización, donde cada región elíptica detectada con CanAff, es transformada en una región circular por medio de una transformación afín (ver Ecuación 2.11) y posteriormente recortada y redimensionada a una región rectangular de tamaño 40×40. La tercera y última etapa, es el descriptor GTP, encargado de codificar cada región rectangular en un vector de 1296 componentes, obteniéndose así una matriz de descriptores, donde cada vector columna corresponde al descriptor de una región rectangular.

56


Figura 3.27 Diagrama de bloques del algoritmo implementado para la función descriptor-base-GTP.

La Figura 3.28(a) muestra una imagen perteneciente a la base de datos YALE B de tamaño 192×168 pixeles, en la cual se han detectado 873 regiones afines usando CanAff (solo son mostradas las 172 primeras elipses). Nótese como algunas regiones son encerradas por elipses que salen fuera de la imagen (elipses en rojo), estas regiones no pueden normalizarse a regiones circulares por lo que se decidió descartarlas. En la Figura3.28(b) se muestra la misma imagen con las primeras 172 de 678 regiones afines detectadas, después de descartar aquellas regiones encerradas por elipses que salen fuera de la imagen.

(a) (b)Figura 3.28 Regiones afines detectadas usando CanAff en una imagen de tamaño 192×168 pixeles, perteneciente a la base de datos YALE B (a) Primeras 172 de 873 regiones afines detectadas sin descartar las regiones encerradas por elipces que salen fuera de la imagen (b) Primeras 172 de 678 regiones afines detectadas despues de descartar las regiones encerradas por ellipces que salen fuera de la imagen.

En la Figura 3.29 se muestra el proceso de normalización de una región afín individual,

esta es transformada en una región circular por medio de la transformación lineal M12

dada en la Ecuación 2.11. Una vez que se obtiene la región circular esta debe redimensionarse de tal forma que el radio del circulo coincida con

r=√( 402 )

2

+( 402 )

2

≈28.284, de esta forma podrá extraerse de ella una región rectangular

de tamaño 40×40.

57


Figura 3.29 Proceso de normalización de una región afín individual

El procedimiento completo implementado para esta función se muestra en el algoritmo xx.

Entrada: Imagen I.Salida: Matriz de descriptores base GTP db=[db1, db2 , db3…dbn].Procedimiento:db←[ ];Usar CanAff para extraer las regiones afines encerradas por elipses que no salen fuera de la imagen:Re= {R e1 ,R e1 ,Re1…Ren};Para cada Rej∈R e hacer

R je←28.284M12 R je

; //Normalizar la región elíptica, en una región circular de radio

28.284*Extraer la región cuadrada de tamaño 40×40 circunscrita en la región circular R je

*Extraer el descriptor GTP d j de la región rectangular;*Adherir d j a los vectores columna de db;

Post-procesamiento-GTP: Dado que la dimensión de los descriptores extraídos usando GTP son de una dimensión muy alta (R1296), (Liao et al., 2013) proponen reducir su dimensión usando para ello PCA y tomando en cuenta solo los 128 primeros eigenvectores. Los detalles matemáticos del anterior proceso son explicados en la sección xxx, el algoritmo implementado para esta función se muestra en el algoritmo xxx.

Entrada: Conjunto de descriptores base DB={Db1 , Db2, Db3…DbC }.

Salida: Conjunto de descriptores procesados DP={D p1 , Dp2 , Dp3…Dpj…DpC }.Procedimiento:DP←∅ ; W←[ ]; temp←[ ]; //Inicializar el conjunto DP como vacíoUsar cada una de las matrices del conjunto DB para construir la matriz temp=[Db1 ,Db2 , Db3…DbC ];

58


Usando PCA sobre la matriz temp calcule la matriz de eigenvectores W ;W←W 1296×128; //extraer los primeros 128 eigenvectoresPara cada Dbj∈DB hacer

D pj←W T Dbj; //Reducir la dimensión de Dbj

DP←DP+ {D pj }; //Adherir al conjunto DP, la nueva matriz D pj

Fin para cadaAcumular en memoria de programa la matriz de eignevalores W para ser usada posteriormente en la fase de prueba.

Descriptor-test-GTP: Puesto que en la función Post-procesamiento-GTP se reduce la dimensión de los descriptores GTP usando PCA, para un proceso de comparación se hace necesario transformar los descriptores GTP extraídos a una imagen de prueba al mismo eigenespacio, matemáticamente esta transformación se expresa en la Ecuación2.18. El algoritmo implementado para esta función se muestra en el algoritmo xxx.

Entrada: Imagen I; Matriz de eigenvalores Wcreados por la funcion Post-procesamiento-GTPSalida: Matriz De descriptores Y .Procedimiento:Y ←[ ];Extraer la matriz de descriptores base db de la imagen de prueba I , usando la función Descriptor-base-GTP (algoritmo xxx).*Y ←W T db; //Proyectar la matriz sobre los 128 primero eigenvectores

3.2.3 Base de datos de descriptores

Habiendo definido las 3 funciones elementales del sistema descriptor abstracto, es posible describir el proceso de construcción de la base de datos de descriptores. En el sistema de reconocimiento facial desarrollado en este trabajo de grado, la base de datos está conformada por un conjunto de descriptores extraídos de cada una de las imágenes de rostros pertenecientes a C diferentes individuos que se desea reconocer. Cuando la base de datos ha sido construida, esta es una matriz D de tamaño d ×cn donde d es la dimensión de los descriptores y cn es el número de descriptores en total, una particularidad de esta matriz es que cada conjunto de descriptores pertenecientes a las imágenes de un solo individuo, se ubican en columnas contiguas. La Figura 3.30 ejemplifica el procedimiento de construcción de la base de datos de descriptores, y el algoritmo xxx muestra los pasos a seguir para su construcción.

59


Figura 3.30 Proceso de construcción de la base de datos. Inicialmente se extraen los descriptores base de cada una de las imágenes de los diferentes individuos; luego se aplica la función post-procesamiento al conjunto de matrices de descriptores base DB, de lo cual se obtiene el conjunto DP; y finalmente, se organizan cada una de las matrices de descriptores del conjunto DP, en una matriz D, que será la base de datos de descriptores.

60


Entrada: Un conjunto de imágenes de C diferentes individuos I={I 1 , I 2, I 3…I c }, donde cada componente del conjunto I puede tener un número diferente de imágenes.Salida: Base de datos de descriptores D= [D p1 , Dp2, Dp3…D pC ].

Procedimiento:D←[ ]; DB←∅ ;Para cada I j∈ I hacer

Dbj← [ ];Para cada imgi∈ I j hacer

Extraer la matriz de descriptores base db de la imagen imgi usando la función descriptor-base del sistema descriptor abstracto;

Adherir db a las matrices columna de Dbj;Fin para cada

DB←DB+ {Dbj };Fin para cadaAplicar la función post-procesamiento del sistema descriptor abstracto al conjunto DB, para obtener la matriz de descriptores procesados DP;Apilar las matrices del conjunto DP como matrices columna de la matriz D;

3.2.4 Clasificador SCR

Habiendo construido la base de datos de descriptores, es posible realizar el reconocimiento facial de una imagen de prueba dada. En el sistema implementado, una matriz de descriptores Y de tamaño d ×n es extraída de una imagen de prueba usando la función descriptor-test del sistema del descriptor abstracto. Cada uno de los n vectores columna de esta matriz, representa el descriptor de cierta característica facial medida, el problema a resolver ahora es, encontrar para cada uno de ellos, la representación dispersa (vector disperso) en términos de los descriptores de la base de datos. Una vez que las representaciones dispersas han sido halladas, se reconstruye la matriz Y , usando solo los coeficientes pertenecientes a una sola clase; aquella clase cuyos coeficientes logren el menor error de reconstrucción, será la identidad del rostro en la imagen de prueba.

El clasificador SRC está conformado por 3 etapas: Fast filtering SRC Identificación

Cada una de las etapas del clasificador SCR se describe en las siguientes subsecciones.

3.2.4.1 Fast filtering

61


La etapa fast filtering está pensada para casos en donde el número de descriptores en la base de datos puede llegar a ser considerablemente grande (nc≫100), en estos casos encontrar la representación dispersa de los descriptores Y de una imagen de prueba, puede ser un proceso computacionalmente costoso. Para solucionar este problema, la búsqueda de la representación dispersa para cada vector columna de Y , se restringe a un subconjunto de tamaño L(L≪nc) de vectores de D, con los cuales se presente mayor correlación. Para el caso del i-esimo vector columna de la matriz de descriptores Y , la correlación con los descriptores de la base de datos estará dada por:

corr i=DT y i

Donde D son los descriptores de la matriz de la base de datos D normalizados, y i es el i-esimo vector columna de la matriz de descriptores Y normalizado y corr i, es un vector de nc componentes, en el cual la componente k-esima, nos da la correlación entre el descriptor k-esimo de D, y el descriptor y i.

La información dada por las componentes del vector corr i es usada para construir una nueva matriz MLi de tamaño d ×L, cuyos vectores columna son los L descriptores de la matriz D mayormente correlacionados con el descriptor y i. El anterior procedimiento es realizado para todos los descriptores de la matriz Y , obteniéndose un conjunto de matrices ML={ML1 ,ML2 , ML3…MLn }, en donde posteriormente se buscaran las representaciones dispersas. El procedimiento completo de fast filtering es mostrado en el algoritmo xxx.

Entrada: Matriz de descriptores Y de una imagen de prueba; base de datos de descriptores D.Salida: Conjunto de matrices ML={ML1 ,ML2 , ML3…MLn }.Procedimiento:ML←∅ ; CORR←[ ]; //Inicializar el conjunto ML como vacío

CORR←DT Y ; //Calculando matriz de correlacionesPara cada vector columna corr i de CORR hacer

MLi←[ ];Obtener las L posiciones ith= {ith1 , ith2 ,ith3…ithL } del vector columna corr i, donde se presenten los L valores más altos;

MLi← [D(ith1) ,D(ith2) , D(ith3)…D(ithL) ]; //Almacenando los L vectores columna de D en las posiciones ith1 ,ith2 , ith3…ithL.ML←ML+ {MLi }; //Adherir al conjunto ML, la nueva matriz MLi

Fin para cada

3.2.4.2 SCR

62


Una vez que se ha seleccionado el conjunto de matrices ML, es posible encontrar la representación dispersa de los descriptores Y extraídos de una imagen de prueba, con un costo computacional mucho menor. Para el caso del i-esimo descriptor y i (es decir el i-esimo vector columna de Y ) la representación dispersa x i, es hallada minimizando la siguiente función de costo Ei ( x ):

Ei ( x )=‖x i‖1+λ‖MLi x i− yi‖22

Para la minimización de la función de costo se usó el Algoritmo 2, y como criterio de convergencia de este algoritmo (paso 3) se definieron 2 situaciones:

Cuando el vector disperso x tenga un número de coeficientes distintos de ceros mayor a un número NZ preestablecido, es decir cuando ‖x‖0>NZ .

Cuando hayan pasado más de 2 L iteraciones.

Minimizando la función de costo para todos los descriptores de la matriz Y , se obtiene el conjunto de representaciones dispersas X={x1 , x2 , x3…xn }, el procedimiento completo es mostrado en el algoritmo xxx.

Entrada: Matriz de descriptores Y de una imagen de prueba; conjunto de matrices de ML construidas por el algoritmo xxx.Salida: Conjunto de representaciones dispersas X={x1, x2, x3…xn }Procedimiento:X←∅ ; //Inicializar el conjunto X como vacíoPara cada vector columna y i de Y hacer

Minimizar ‖x i‖1+λ‖MLi x i− y i‖22 usando el Algoritmo 2;

X←X+{x i };Fin para cada

3.2.4.3 Identificación

El conjunto de representaciones dispersas X={x1 , x2 , x3…xn } hallado en la etapa SRC puede ser usado para reconstruir la matriz de descriptores Y , esta reconstrucción está dada por la matriz [ML1 x1 , ML2 x2 ,ML3x3…MLn xn ]. Cuando se usan todos los coeficientes de cada vector disperso, el error de reconstrucción es mínimo, sin embargo, cuando se usan solo los coeficientes pertenecientes a determinada clase, el error de reconstrucción aumenta. La etapa de identificación aprovecha esto para buscar la clase cuyos coeficientes minimicen el error de reconstrucción, y de esta manera, identificar el

63


rostro en la imagen de prueba. El error de reconstrucción para una determinada clase c puede calculase como sigue:

rc=∑i=1

n

‖y i−ML iδ c (x i )‖2

2

Donde la función δ c selecciona solo los coeficientes pertenecientes a la clase c. La identificación de la imagen de prueba puede entonces hallarse, buscando la clase c cuyos coeficientes minimizan el error de reconstrucción rc, esto es representado por la siguiente ecuación:

c=minc∑i=1

n

‖y i−MLi δ c (x i )‖2

2

La ecuación xxx es similar a la ecuación xxx usada por xxx para el proceso de reconocimiento. Algo importante observado en las primeras pruebas realizadas, fue la existencia de clases cuyos coeficientes de aporte a la reconstrucción eran todos cero, por lo cual en la ecuación xxx no se requiere buscar el mínimo para todas las C clases (individuos), sino para un conjunto de clases más reducido CR conformado por aquellas clases que por lo menos presenten en algún vector disperso del conjunto X={x1 , x2, x3…xn }, un coeficiente diferente de cero. El algoritmo xxx presenta el procedimiento completo de identificación desde que una imagen de prueba I entra al sistema de reconocimiento facial.

Entrada: imagen de prueba I ; base de datos de descriptores D pertenecientes a C clases (individuos) diferentes.Salida: Identidad c de la imagen de prueba I .Procedimiento:Extraer la matriz de descriptores Y de la imagen de prueba I usando la función descriptor-test del sistema del descriptor abstracto;Obtener el conjunto de matrices ML usando del algoritmo xx, conY y D como parámetros de entrada;Obtener el conjunto de representaciones dispersas X usando el algoritmo xx, con Y y ML como parámetros de entrada;Obtener el conjunto de t clases CR= {cr1 , cr2, cr3…cr t }, que presentan al menos un coeficiente diferente de cero en el conjunto de representaciones dispersas X ;Evaluar la ecuación xxx sobre el conjunto CR para obtener la identidad c de la imagen de prueba I .

64


Se indica el contenido de este capítulo y por qué es importante. Debe incluir un diagrama de bloques del software desarrollado. Por ejemplo:-Las funciones se explican con ayuda de diagramas de flujo simplificados.-Los códigos y nombres de las funciones se hacen referencia en el ANEXO o en CD.

3.3 Bloque 1Escriba una descripción del bloque explicando su función.



3.6 Conclusiones

65


4. Pruebas y ResultadosSe indica el contenido de este capítulo y por qué es importante. Además debe mencionarse el propósito de las pruebas.

4.1 Prueba 1

4.1.1 Descripción

4.1.2 Procedimiento

4.1.3 Resultados

4.2 Prueba 2

4.2.1 Descripción

4.2.2 Procedimiento

4.2.3 Resultados

4.3 Análisis ComparativoSe indican características, alcances y limitaciones de la solución desarrollada en el proyecto.

4.4 Conclusiones

66


5. Conclusiones Generales

67


6. Trabajos FuturosCon base en el trabajo desarrollado se plantea…

68


7. Referencias Bibliográficas

69


ANEXOA1. MANUAL DE USUARIO (Si se ha desarrollado un Software o si hay un equipo que requiere ser instalado o manipulado)

An. Anexo n: TítuloSe incluyen temas que por su extensión no pueden estar en el cuerpo principal, pero que por su importancia ameritan estar en el documento final. Por ejemplo, hojas de especificaciones, artículos, desarrollo de métodos o ecuaciones, etc, etc.

70

título del proyecto de grado (6)

Documents