Visin artificial y aprendizaje

Practica 2: Sistema Inteligentes

Alvaro Cano Rocamora

ndice

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

La plantilla ----------------------------------------- pag.3

Cara ----------------------------------------- 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

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