Visin artificial y aprendizaje

Practica 2: Sistema Inteligentes

Alvaro Cano Rocamora

ndice

Introduccin

---------------------------------------- pag.3

La plantilla
Cara

----------------------------------------- pag.3

----------------------------------------- pag.3

ImageFilter ----------------------------------- pag.4

PlantillaPractica2SI ------------------------ pag.4
Creacin del algoritmo AdaBoost ------------------ pag.5
Hiperplano ----------------------------------- pag.5
Clasificador Dbil --------------------------- pag.6
Clasificador Fuerte ------------------------- pag.8
Adaboost ------------------------------------- pag.9
Ejecucin ----------------------------------------------- pag.12
Experimentacin -------------------------------------- pag.13
BuscadorCaras --------------------------------------- pag.17
Planteamiento y diseo ------------------- pag.17
Ejecucin ------------------------------------ pag.20
Experimentacin --------------------------- pag.21
Conclusiones -------------------------------- pag.24
Bibliografa -------------------------------------------- pag.25

Introduccin

La prctica consiste en crear un algoritmo de aprendizaje Adaboost para que pueda

adivinar si una imagen es una cara o no.
Para poder implementar el Adaboost, primero se tendr que implementar un clasificador
fuerte y los clasificadores dbiles que lo componen

El proyecto se creara con el IDE Netbeans, a partir de la plantilla que se nos proporciona.

La plantilla
La plantilla que se nos proporciona se encarga de gestionar todos los parmetros de
entrada y la base de datos.
Se compone de la clase Cara, ImageFilter y PlantillaPractica2SI, que viene a ser la
plantilla propiamente dicha, ya que apenas tendremos que aadir cdigo a ella.

Cara
Esta clase recibe una imagen, que puede no ser realmente una cara, y la transforma en
un array de enteros, que representan los pixels de la imagen en escala de grises (0 a
255).
La imagen adems es tratada con una mscara, para pasarla toda a un solo color.
A esta clase se le ha aadido

un atributo llamado peso, necesario para el

funcionamiento del clasificador dbil.

ImageFilter
Esta clase filtra las imgenes de entrada, en este caso las de la base de datos,
controlando que su extensin sea vlida. Tambin nos permite identificar el formato de
las imgenes que le pasemos al programa.

PlantillaPractica2SI

<<Dado que lo primero que tenemos que hacer es refactorizar esta clase para llamarla
Practica2SI, a partir de aqu la llamaremos as. >>
Esta es la clase principal de la primera parte de la prctica, en ella se van a invocar al
resto de clases y es donde tenemos la funcin Main().
Esta clase gestin adems los parmetros de entrada, y realiza ajustes en base a estos,
adems de ser el punto de entrada del programa y recoger la ruta a la base de datos.
La base de datos en, llamada facesDB, es un directorio compuesto por otros dos,
llamados cara y noCara. Estos contiene respectivamente una coleccin de caras y otra
de fotos de fondos, suelos,.. Y cualquier cosa distinta a una cara. Todas las imgenes
tienen un tamao de 24*24.

A partir de esta base de datos, la clase Practica2SI se encarga de crear dos listas para
el Adaboost, una de entrenamiento y otra de testeo.

Creacin del algoritmo Adaboost

El algoritmo Adaboost consta de un Clasificador fuerte, que a su vez esta constituido

por X clasificadores dbiles, cada uno con un hiperplano, por ello lo primero que
tenemos que construir es la clase Hiperplano.

Hiperplano

El hiperplano seguir la ecuacin proporcionada en el pdf de la prctica

La clase hiperplano constara de un array de enteros (tipo double)

que

representara una serie de puntos en el espacio. Como las fotos sern de 24*24 nuestro
hiperplano constara de un vector de direccin de 576 puntos. Estos puntos se generan
aleatoriamente con un Math.random().

Ahora necesitamos obtener el termino independiente C, para esto obtendremos un

punto al azar, teniendo en cuenta que al ser una escala de grises su valor tiene que
oscilar entre 0 y 255. Este punto nos permitir despejar la ecuacin y obtener C.

Por ultimo necesitamos una funcin que asigne un punto a uno de los subespacios que
crea el hiperplano, de forma que sepamos si el punto est por encima o por debajo. Esta
funcin es la que tendr que llamar despus el clasificador dbil.

La clase tambin incluye los Set y Get que permiten asignarle tantos unos puntos como
un valor C arbitrarios.
Con la clase hiperplano completa, podemos pasar a crear el clasificador dbil

Clasificador dbil
Esta clase consta de un hiperplano, un valor de confianza y un valor de error.
El hiperplano se genera automticamente al llamar al constructor del clasificador, pero
tambin puede asignase mediante get/set.
El cometido principal de esta clase consiste en recibir una instancia de la clase Cara y
evaluarla utilizando el hiperplano. Para esto tendremos la funcin evaluacin que utiliza
la frmula:

Para evaluar los pixels de la cara con el hiperplano. Esta ecuacin nos devolver un
nmero positivo si el objeto de la clase Cara es realmente una cara, o un nmero
negativo si no lo es.

Pero dado que el hiperplano se genera al azar y puede ser mejor o peor a la hora de
discernir si una imagen es cara o no, primero tendremos que entrenar el clasificador
dbil.
Este entrenamiento consiste en ir pasndole la lista de caras dedicadas a entrenamiento
e ir comprobando el resultado que nos da el clasificador: Con cada fallo se le asigna un
error al clasificador, que consiste en la suma del peso de cada cara que falle. Este error
adems nos permitir calcular el valor de confianza: = Ln (1-/ ). Este valor es lo
que nos indicara como de eficaz es este clasificador concreto, y nos ser necesario para
la ejecucin del clasificador fuerte.

Clasificador fuerte
El clasificador fuerte consiste en una batera de clasificadores dbiles, todos entrenados
con la misma lista de caras, de forma que cada uno tendr un valor de confianza distinto
segn lo bueno que sea clasificando. El clasificador funciona evaluando con todos sus

clasificadores cada instancia de Cara que le pasemos y devolviendo su respuesta en

funcin de las respuestas de estos ltimos, de forma que si la mayora de ellos dicen
que la instancia de Cara es una cara, esa ser la respuesta que se retorna. El valor de
confianza entra en juego aqu, dado que cuanto ms alto sea este valor, ms
importancia se le dar a la decisin toma por dicho clasificador dbil.

El clasificador fuerte tambin implementa la funcin de guardado, que guarda la

instancia actual de objeto en un fichero de tipo .obj, con el estado actual del momento
del guardado.
Este es el motivo de que tanto esta clase como la clase Dbil y la clase hiperplano
implementen el interfaz Serializable, as podemos guardar el objeto y cargarlo en
cualquier otro proyecto siempre que este tenga incluido l .jar de Adaboost.

Con esto hecho podemos pasar a implementar el Adaboost

Adaboost

Adaboost no es una clase en s misma, es una funcin contenida dentro de Practica2SI

que devolver una instancia de la clase Fuerte, con la que se trabajara.
El algoritmo Adaboost funciona entrenando una serie de clasificadores dbiles con la
lista de aprendizaje para formar un clasificador fuerte.

As, el algoritmo genera la cantidad de clasificadores dbiles que le pasemos por el

parmetro numClasificadores y se seleccionara el mejor de ellos. Este clasificador dbil
se entrena con la lista de entrenamiento y se le asigna un valor de confianza. Ahora el
clasificador dbil pasara a formar parte del clasificador fuerte.
Una de las claves de Adaboost es que, despus de aadir cada clasificador dbil al
fuerte, actualizara los pesos de las caras de la lista de forma que las caras en las que
se ha fallado tengan ms relevancia y en las siguientes iteraciones se les dedique ms
atencin.
El peso se actualiza utilizando la ecuacin (siendo Z la normalizacin):

Cuando ht(i) es igual a yi el valor es positivo, con lo que el peso de la instancia Cara
incrementa, en caso contrario, al coincidir el resultado ser negativo y decrementara el
peso.
Tambin podemos ver con el seudocdigo proporcionado que en caso de que
obtengamos un error igual a 0 el bucle termina.
Finalmente Adaboost nos devolver un clasificador fuerte muy entrenado con el que
podremos empezar a clasificar las imgenes.
La llamada Adaboost la pondremos dentro de Practica2SI.init(), en la lnea 81 como nos
indica el pdf de la prctica:

Esto nos entregara el clasificador que tendremos que invocar en las lneas 111 y 123,
donde se realiza la clasificacin, primero de la lista de entrenamiento y despus de la
lista de test:

Al ejecutarlo, si todo funciona correctamente obtendramos el resultado por la salida del

Shell:

El esquema resumido en UML seria as:

Ejecucin
La entrada del programa es la clase Practica2SI, que puede recibir varios parmetros
de entrada, algunos de ellos obligatorios.
-d ruta

Este es el nico parmetro obligatorio,

tiene que contener la ruta al fichero
facesDB.

-t testrate

Este parmetro define el porcentaje de

caras que irn a parar a la lista de
aprendizaje y a la de test, por defecto est
fijado a 20%.

-T maxT

Este

parmetro

es

el

mximo

de

iteraciones que puede realizar Adaboost,

por defecto est fijado en 10.
-c numClasificadores

Es el nmero de clasificadores dbiles

que se aadirn al clasificador fuerte en
el Adaboost, por defecto son 5.

-v

Fija el verbose como activado, por

defecto

esta

desactivado

pero

se

recomiendo activarlo en cada ejecucin

La ejecucin ms bsica del algoritmo ser java Practica2SI d ruta.

Adems cabe sealar que el clasificador se guardara automticamente en la carpeta src

del proyecto.

Experimentacin y cuestiones
-Cul es el nmero de hiperplanos que se han de generar para que un clasificador
dbil funcione?
En el caso del clasificador dbil solo se necesita uno, ya que el C. dbil solo contiene
un hiperplano. Como el hiperplano es aleatorio, no se puede asegurar la eficacia.
En el caso del clasificador fuerte:

Se han utilizado series de 10, 20 y 40 hiperplanos con porcentajes de 50% y 80%

Alrededor de 20 clasificadores dbiles (20 hiperplanos) los resultados empiezan a ser
ms positivos.

-Cmo afecta el nmero de hiperplanos generados al tiempo empleado para el proceso

de aprendizaje?

Como podemos ver en la grfica el nuero de hiperplanos aumenta exponencialmente el

tiempo que tarda en completarse el algoritmo, aadiendo alrededor de 2,3 segundos por
cada 20 hiperplanos mas con los que tiene que trabajar.
-Qu importancia le daras?
Depende del uso que se le quiera dar a la ordenacin, en general dira que poca
importancia porque por norma se suele generar un clasificador adaboost una vez y
utilizarse para varias funciones o algoritmos, como por ejemplo el programa
BuscadorCaras que no necesita que se genere un clasificador nuevo cada vez.
-Se observa sobre entrenamiento?
No se llega a observar sobre entrenamiento en los rangos que he estado probando, en
la tabla se muestra un ejemplo, todas al 50%. Solo aparece el sobre entrenamiento si
se fuerza a que aparezca, introduciendo parmetros mucho ms elevados de lo
necesario.

En conclusin se puede afirmar que si bien el clasificador puede llegar a ser muy eficaz
clasificando imgenes, tiene cierta carencias: Si observamos la tasa de fallos,
encontramos que dependiendo de los hiperplanos que genere y de los parmetros de
entrada, suele rondar el 3% como mximo, pero prcticamente todos los fallos ocurren
en imgenes no caras, pero que, entendiendo que el clasificador solo ve escalas de
grises, todas la imgenes que causan error siguen un patrn de fondo oscuro y un centro
de la imagen ms claro

Programa BuscadorCaras
El objetivo de la segunda parte es utilizar nuestro clasificador fuerte obtenido con
adaboost para crear un programa que, al recibir una image, identifique y marque las
caras que encuentre.
Este proyecto solo consta de dos clases: la clase principal se llama BuscaCaras, y es la
entrada del programa, se encargara de recibir por parmetro la ruta donde este
almacenado el clasificador a utilizar y la imagen que se quiera escanear.
Despus tenemos una clase auxiliar arquetpica del estndar de Oracle, mostrarCaras,
que nos permitir mostrar la imagen en una ventana al terminar de funcionar nuestro
algoritmo.
Adems, como el proyecto carga el clasificador usando serializacion, el proyecto
Practica2SI est incluido como .jar, de forma que podemos utilizar sus clases, pero no
modificarlas.

Planteamiento y diseo
El primer paso que debemos realizar es cargar tanto el clasificador como la imagen.
El primero no tiene mayor misterio porque podemos utilizar los mtodos estndar de
carga de objetos por serializacion.

La imagen en cambio tenemos que tratarla primero, asique utilizaremos parte del cdigo
de la clase Cara, de la parte anterior de la prctica.

Esto nos proporcionara un array de enteros con los pixels de la imagen, adems de las
medidas de estay un BufferedImage, que necesitaremos ms tarde.
El siguiente problema es que nuestro clasificador solo admite imgenes de 24*24, pero
las imgenes que aceptara BuscadorCaras pueden ser de cualquier tamao mayor.
Para solucionar esto tendremos que recorrer la imagen seccionando trozos de 24*24
que nuestro clasificador analizara. Esto no podemos hacerlo a partir del array de pixels,
pero si con BufferedImage y su clase getRGB().
Adems de esto, tenemos que tener en cuenta que las imgenes con las que se ha
entrenado al clasificador estaban tratadas con una mscara, por lo que nosotros tambin
tendremos que tratar con la misma marcara a las secciones de 24*24 que le pasemos
al clasificador:

Otro factor a tener en cuenta es que si recorremos pixel a pixel la imagen, cuando
encontremos cara, al avanzar un solo pixel es muy probable que nuestro clasificador

marque otra vez la misma cara, incluso varias veces segn la imagen, Para solucionar
esto haremos que nuestro clasificador avance 24 pixels de una vez en el eje horizontal
cuando encontremos una cara. Con todo esto, solo tenesmo que crear un doble bucle
for que recorra la imagen:

Como podemos ver, se le pasan al clasificador recuadros de 24*24 y tratados con

mascara, pero sin tratar con mascara la foto completa, solo una seccin dentro de un
array auxiliar.
As no estropeamos la foto original y podemos pintar un recuadro transparente si
encontramos una cara.
Tambin tenemos que tener en cuenta los lmites de la foto, que controlamos con un if,
dado que la imagen no tiene por qu ser divisible exactamente en secciones de 24*24.
En fotos pequeas o con caras bien separadas podemos activar una funcin que pintara
un recuadro alrededor, pero en fotos de aglomeracin no es recomendable porque
ensuciara demasiado la imagen.

Ejecucin
El programa se ejecuta de manera similar a Practica2SI:
Java BuscadorCaras d rutafoto t rutaclasificador
-d rutafoto

-> La ruta donde tenemos guardad la foto a analizar

-t rutaclasificador -> La ruta donde se tiene almacenado el clasificador

O utilizando NetBeans:

Adems es necesario incluir como librera el proyecto Practica2SI

Con esto listo, podemos pasar a ejecutar y probar el programa.

Experimentacin
Vamos a probar a introducir esta imagen

Utilizaremos un clasificador fuerte que en el anterior proyecto nos ha dado un 99,78 de

aciertos, configurado con 50 clasificadores dbiles a un ratio del 25% y 120 iteraciones.

Como podemos ver, aunque el algoritmo s reconoce caras y las marca, tambin comete
fallos y marca coas como los edificios del fondo o los globos. En general podemos
empezar a ver una pauta, ya que marca secciones de fondo oscuro con un tono ms
claro que se cruza por el centro.

Probemos ahora con una imagen ms sencilla:

Y este ser el resultado que obtenemos

Como podemos ver, aunque ha marcado las dos caras tambin ha marcado parte de
las camisetas, justamente cuando tenemos una parte oscura cruzada con una mucho
ms clara.

Conclusiones:

La conclusin que se puede obtener es que, si bien el programa s reconoce caras, est
claro que no es lo suficientemente completo como para ser realmente eficaz.
Algunas mejoras las podemos encontrar en el tema 13 de teora.
-Seleccin de caractersticas
En una imagen de 24*24 tenemos ms de 180000 posibles y tenemos que
seleccionar unas pocas, como por ejemplo el cambio de color del puente de la
nariz o los ojos.
Esto permite identificar de forma mucho ms fiable las caras que si solo nos
guiamos por el color
-Cascada de atencin
El algoritmo de Attentional Cascade consiste, a grandes rasgos, de una criba
por niveles de las distintas imgenes, utilizando clasificadores menos precisos
pero ms rpidos para seleccionar las caractersticas ms fciles de reconocer.
Aunque este mtodo es difcil de implementar los resultados son prcticamente
perfectos.

Adems, como nuestro clasificador hace una bsqueda en profundidad por la imagen,
el tiempo de ejecucin es exponencial respecto al tamao, tardando una media de 8
segundos en imgenes de 600*400.

Bibliografa

-Wikipedia.org
-Apuntes de teora temas 10 a 13
- enciclopedia_universal.esacademic.com
- http://docs.oracle.com/javase/7/docs/api/javax/imageio/ImageIO.html