Integración y evaluación de sistemas de reidentificación de caras usando MTCNN y FaceNet en C++

_Equation Chapter 1 Section 1 Proyecto Fin de Máster Master en Ingeniería Electrónica, Robótica y Automática Integración y evaluación de sistemas de reidentificación de caras usando MTCNN y FaceNet en C++ Autor: Ana Belén Cordobés Menguiano Tutor: Jesús Iván Maza Alcañiz Dpto. Ingeniería de Sistemas y Automática Escuela Técnica Superior de Ingeniería Universidad de Sevilla Sevilla, 2019 iii Proyecto Fin de Máster Ingeniería de Sistemas y Automática Integración y evaluación de sistemas de reidentificación de caras usando MTCNN y FaceNet en C++ Autor: Ana Belén Cordobés Menguiano Tutor: Jesús Iván Maza Alcañiz Profesor titular Dpto. Ingeniería de Sistemas y Automática Escuela Técnica Superior de Ingeniería Universidad de Sevilla Sevilla, 2019 v Proyecto Fin de Máster: Integración y evaluación de sistemas de reidentificación de caras usando MTCNN y FaceNet en C++ Autor: Ana Belén Cordobés Menguiano Tutor: Jesús Iván Maza Alcañiz El tribunal nombrado para juzgar el Proyecto arriba indicado, compuesto por los siguientes miembros: Presidente: Vocales: Secretario: Acuerdan otorgarle la calificación de: Sevilla, 2019 El Secretario del Tribunal vii A mi familia A mis maestros A mis compañeros ix Agradecimientos En este apartado me gustaría agradecer a todas aquellas personas que me han ayudado, especialmente en este año. A todos mis profesores, por su capacidad de compartir, por su entusiasmo y su comprensión. En particular a Iván Maza, por su tiempo, su paciencia, su interés. A 4i, por el tiempo dedicado, la confianza y la oportunidad que me han dado. A mis padres y a mi hermano, que siempre me han apoyado en todo lo que he querido hacer. A mi familia, por que valoran lo que hago, aun si saber en muchas ocasiones de que se trata. A mis amigos y compañeros, porque me permiten abstraerme de casi cualquier cosa y disfrutar de casi cualquier momento. Ana Belén Cordobés Menguiano Sevilla, 2019 4.2 MTCNN ................................................................................................................................................ 35 4.2.1 Proposal Network (P-Net) ........................................................................................................... 35 4.2.2 Refine Network (R-Net) ............................................................................................................... 38 4.2.3 Output Network (O-Net) .............................................................................................................. 40 4.2.4 NMS (Non-Maximum Suppression) ............................................................................................. 42 4.2.5 Funcionamiento de MTCNN ........................................................................................................ 44 4.3 Comparación entre el detector de rostros MTCNN y el basado en HOG y SVM empleado en DLIB. .. 46 5 Reconocimiento facial ................................................................................................................................ 54 5.1 FaceNet................................................................................................................................................ 55 5.1.1 Red neuronal convolucional ........................................................................................................ 55 5.1.2 Triplet Loss .................................................................................................................................. 57 5.2 Prueba de FaceNet .............................................................................................................................. 58 6 Detectores implementados ....................................................................................................................... 62 6.1 Detector MTCNN ................................................................................................................................. 63 6.1.1 JSON asociado a MTCNN ............................................................................................................. 63 6.2 Detector MTCNN junto con FaceNet. .................................................................................................. 63 6.2.1 Json asociado al detector MTCNN junto con FaceNet................................................................. 64 6.3 Fichero principal para las pruebas con MTCNN y FaceNet.................................................................. 65 6.3.1 Pruebas realizadas con distintas imágenes ................................................................................. 65 7 Conclusiones y trabajo futuro .................................................................................................................... 78 Referencias ......................................................................................................................................................... 81 xvii ÍNDICE DE TABLAS Tabla 1. Estructura de la red convolucional utilizando filtros de dimensiones 1x1. Sacada de [15]. 56 Tabla 2. Estructura de NM2 Inception, para FaceNet. Tabla sacada de [15]. 56 Tabla 3. Resultados obtenidos con el identificador de rostros para un total de 100 individuos. 72 xix ÍNDICE DE FIGURAS Ilustración 1. Conjunto extendido de filtros de Haar. 3 Ilustración 2. Cascada de clasificadores. 3 Ilustración 3. Ejemplo del cálculo del descriptor LBP. 4 Ilustración 4. Estructura del proyecto. 5 Ilustración 5. Logos de Debian (izquierda) y ubuntu (derecha). 9 Ilustración 6. Sistema de archivos del sistema operativo Ubuntu 9 Ilustración 7. CMake-GUI 10 Ilustración 8. Logo de Keras y TensorFlow. 11 Ilustración 9. Logo de GIT [41]. 11 Ilustración 10. Tipos de ramas 12 Ilustración 11. Inteligencia artificial, machine learning y deep learning. 15 Ilustración 12. Arquitectura de la red neuronal convolucional AlexNet. Imagen tomada de [21]. 15 Ilustración 13. Representación de una neurona biológica. 16 Ilustración 14. Modelo de perceptrón. 16 Ilustración 15. Clases no linealmente separables. 17 Ilustración 16. Ejemplo de funciones de activación. 17 Ilustración 17. Red neuronal de una capa con dos salidas. 18 Ilustración 18. Representación de pares entrada-objetivo. 19 Ilustración 19. Perceptrón dado el caso de aprendizaje. 20 Ilustración 20. Solución obtenida con los pesos [1 -0.7] y el parámetro bias -0.6 para el ejemplo propuesto. 21 Ilustración 21. Solución obtenida con los pesos [1 0.7] y el parámetro bias 0.3 para el ejemplo propuesto. 21 Ilustración 22. Propagación hacia atrás de los errores 22 Ilustración 23. Ejemplo del algoritmo de descenso del gradiente. 24 Ilustración 24. Overffitting (rojo) underfitting (verde) y entrenamiento adecuado (azul) 25 Ilustración 25. Evolución típica del error de entrenamiento y prueba. 26 Ilustración 26. Conversión de matriz a vector. 26 Ilustración 27. Ejemplo de convolución. 27 Ilustración 28. Función de activación PreLU. 28 Ilustración 29. Efecto de realizar la operación de Pooling con una kernel de tamaño 2x2 y desplazamiento igual a 2. 29 Ilustración 30. Estructura de una red neuronal convolucional. 30 Ilustración 31.Logo de DLIB. 32 Ilustración 32. Plantillas para el cálculo del gradiente en las direcciones X e Y 33 Ilustración 33. Representación de HOG. 33 Ilustración 34. SVM. a) Separación entre clases. b) Muestras de entrenamiento en el margen. 34 Ilustración 35. Detección de rostros utilizando el detector proporcionado por DLIB. 34 Ilustración 36. Pirámide obtenida con la función PyrDown de OpenCV. 35 Ilustración 37. Representación de una ventana de entrada a P-Net. 35 Ilustración 38. P-Net. Representación obtenida a partir de "Joint Face Detection and Alignment using MTCCN" 36 Ilustración 39. P-Net: Diagrama. 37 Ilustración 40. R-Net. Representación obtenida a partir de "Joint Face Detection and Alignment using MTCCN" 38 Ilustración 41. R-Net: Diagrama. 39 Ilustración 42. O-Net. Representación obtenida a partir de "Joint Face Detection and Alignment using MTCCN" 40 Ilustración 43. O-Net: Diagrama. 41 Ilustración 44. Múltiples soluciones a la detección de rostros cuando en la imagen solo se encuentra uno. 42 Ilustración 45. Cálculo de la IoU a partir de la unión. 42 Ilustración 46. Cálculo de la IoU a partir del área máxima 43 Ilustración 47. Diagrama NMS. 43 Ilustración 48. MTCNN. Diagrama. 44 Ilustración 49. Resultado de la aplicación de MTCNN. 45 Ilustración 50. Ejemplos de las imágenes del dataset "Youtube Faces Database". 46 Ilustración 51. Ejemplos de imágenes del Dataset "GRAZ01-persons". 47 Ilustración 52. Porcentaje de detección con el dataset “YouTube Faces Database”. 48 Ilustración 53. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset YouTube Faces Database. 49 Ilustración 54. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset YouTube Faces Database. 49 Ilustración 55. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset YouTube Faces Database. 49 Ilustración 56. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset YouTube Faces Database. 50 Ilustración 57. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset xxi YouTube Faces Database. 50 Ilustración 58. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset YouTube Faces Database. 50 Ilustración 59. Porcentaje de detección con el dataset “GRAZ01-persons”. 51 Ilustración 60. Imagen sacada del dataset “GRAZ01-persons” 52 Ilustración 61. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset GRAZ01-persons. 52 Ilustración 62. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset GRAZ01-persons. 53 Ilustración 63. Estructura del modelo de FaceNet. Imagen sacada de [15]. 55 Ilustración 64.Triplet Loss. Esquema de funcionamiento. Imagen sacada de [15]. 57 Ilustración 65. Prueba de FaceNet según el método 1. 58 Ilustración 66. Prueba de FaceNet según el método 2. 58 Ilustración 67. Imagen obtenida del dataset. 59 Ilustración 68. Detección correcta para todos los tipos de imágenes de un individuo (modelo → arriba-izquierda). 59 Ilustración 69. Detección de un individuo (izquierda) utilizando como imagen modelo (derecha) una cuyo rostro se encuentra parcialmente oculto. 60 Ilustración 70. Detección correcta en una imagen (izquierda) con el rostro parcialmente oculto a partir de la imagen con la cara modelo (derecha) situada frontalmente. 60 Ilustración 71. Detección errónea (modelo arriba-izquierda). 61 Ilustración 72. JSON del detector MTCNN. 63 Ilustración 73.JSon del detector MTCNN junto con FaceNet. 64 Ilustración 74. Fallo en las identificaciones o detecciones. 73 Ilustración 75. Conjunto de imágenes en las cuales todas las identificaciones se realizan correctamente. 74 Ilustración 76. Detección para un individuo incluyendo las variaciones del umbral. 75 Ilustración 77. Modificación de resultados variando el umbral de FaceNet. 76 xxiii Notación NN Neural Network CNN Convolutional Neural Network SVM Support Vector Machines HOG Histogram of Oriented Gradients SVM Support Vector Machine NMS Non-Maximum Suppression IoU Intersection Over Union P-Net Proposal Network R-Net Refine Network O-Net Output Network 8 2 SOFTWARE EMPLEADO En este proyecto se va a utilizar el sistema operativo Ubuntu en su versión 18.04 LTS y el lenguaje de programación C++. Para su compilación se ha utilizado la herramienta CMake, junto con los comandos make y make install. Para la implementación de la red neuronal MTCNN se ha obtenido el código de [17]. Con el objetivo de optimizar su ejecución se va a utilizar OpenBlas. Para la red neuronal FaceNet se va a usar la plataforma TensorFlow con la que se montará la red, que está previamente entrenada y cuyos parámetros se han obtenido de [18]. Además, con el objetivo de trabajar conjuntamente sobre el espacio de trabajo de la empresa 4i se ha utilizado el programa de control de versiones GIT. El hardware es lo que hace a una máquina rápida; el software es lo que hace que una máquina rápida se vuelva lenta. Craig Bruce 9 2.1 Ubuntu Como se ha indicado anteriormente, para realizar este Proyecto se ha utilizado el sistema operativo (S.O) Ubuntu en su versión estable 18.04. Ubuntu es un sistema operativo de código abierto que tiene como núcleo (kernel) la distribución Linux, a su vez basada en Debian. En la Ilustración 5 se muestran los logos de Ubuntu y Debian. Su sistema de archivos se encuentra organizado en una estructura de árbol según se observa en la Ilustración 6. Es interesante comentarla debido a que se necesita acceder a ficheros de configuración de las redes neuronales de forma adecuada, con el objetivo de que sea independiente del computador en el que sea ejecutado el programa. Sin entrar en mucho detalle, se parte de un directorio raíz (“/”), bajo el que cuelgan distintas secciones, tales como /bin, con comandos básicos de usuario, como chmod, kill, grep, ls…; /etc, con archivos de configuración, como hosts, profile...; /sbin, con binarios esenciales del sistema, como reboot, ifconfig…; /usr, con datos de soporte, solo de lectura, para aplicaciones de usuario; /home, donde se encuentran los directorios personales del usuario, y sobre la que cuelga la carpeta del proyecto; /lib, con librerías; y /opt, con aplicaciones adicionales instaladas. La ruta de un fichero es una dirección única a este mismo dentro del sistema de archivos de dicho S.O. Una ruta puede ser absoluta o relativa. Una ruta absoluta es aquella que parte del directorio raíz, y por tanto siempre comienza con “/”. Una ruta relativa parte de una determinada carpeta y, por tanto, nunca debe comenzar con “/”. Para referirnos a ficheros dentro del proyecto se van a utilizar rutas relativas, que serán pasadas a absolutas gracias a las librerías de C++ “std::filesystem::Path” y “boost::filesystem::canonical” que nos permiten, entre otras cosas, convertir una cadena en una ruta para saber si esta es absoluta y, de no serlo, la modifican para que lo sea, según el sistema de archivos del computador sobre el cual se está ejecutando. / .../opt/lib/home/usr /usr/bin /usr/include /usr/lb /usr/local /usr/share /sbin/etc/bin Ilustración 6. Sistema de archivos del sistema operativo Ubuntu Ilustración 5. Logos de Debian (izquierda) y ubuntu (derecha). 10 2.2 CMake Con el objetivo de compilar este Proyecto se van a utilizar las herramientas make, que compila el código fuente, a partir de archivos MakeFiles, creando los ejecutables asociados a la aplicación, y make install, que mueve los ficheros necesarios a un directorio adecuado. Para poder utilizar estos comandos es necesario generar los MakeFiles, motivo por el cual se utilizará la herramienta CMake [19]. CMake es una herramienta multiplataforma de código abierto diseñada para construir software, principalmente en C++. Su función, como se ha comentado, es crear archivos MakeFiles nativos automáticamente, que permitan controlar el proceso de compilación, a partir de otros ficheros de configuración. Estos últimos reciben el nombre de CMakeList.txt y se encuentran en cada uno de los directorios y subdirectorios asociados al proyecto. Además, contienen información no solo de los ficheros, sino que tambien de las librerías externas necesarias para su ejecución. En la Ilustración 7 se puede ver la interfaz de CMake. Para este proyecto, como se observa, se ha incluido la construcción de los archivos en una carpeta llamada build y su instalación en otra denominada install. Las librerías externas de encuentran en otra carpeta argo_libs_skylane_gpu, por lo que, según se especifica en los CMakeList.txt, cuando se desee buscar alguna librería, como Tensorflow_CC, se hará automáticamente sobre el directorio de dicha carpeta. Una vez se han generado los MakeFiles con esta aplicación, dentro de la carpeta build del proyecto de deberán escribir los siguientes comandos: Ilustración 7. CMake-GUI make make install 11 2.3 TensorFlow Una versión anterior a TensorFlow, DistBelief, fue creada en 2011 por Google Brain, para realizar tareas de aprendizaje automático basadas en redes neuronales. Su uso estuvo presente en múltiples sectores, ya sea para aplicaciones comerciales o de investigación. El 9 de noviembre de 2015 es lanzado TensorFlow una biblioteca de código abierto para computación numérica y, la segunda versión de DistBelief. Opera sobre diferentes plataformas como CPUs, GPUs, TPUs e incluso la placa de ordenador reducida (SBC) Raspberry Pi. Funciona con los sistemas operativos Linux de 64 bits, macOS y otras plataformas móviles con Android y iOS. Generalmente es usada con el lenguaje de programación Python, aunque también proporciona APIs para C++, Java, Haskell, Go y Rust entre otras. TensorFlow permite la construcción y el entrenamiento de redes neuronales, para lo cual realiza operaciones sobre elementos denominados tensores, que son arrays multidimensionales de datos. Keras es una biblioteca de redes neuronales de código abierto programada en Python, que permite la construcción de redes neuronales convolucionales y recurrentes. En 2017 se integra en TensorFlow, lo que permite su uso con esta última. Este hecho dio lugar a que TensorFlow pasase a ser la biblioteca más utilizada en este campo. En la Ilustración 8 se aprecia el logo de Keras (a la izquierda) y de TensorFlow (a la derecha). 2.4 OpenBLAS OpenBLAS es una biblioteca de código abierto que implementa la API BLAS y que contiene programas de algebra lineal básica optimizados para tipos de procesadores específicos. Su versión inicial se realiza en marzo de 2011 pero no se produce un lanzamiento estable hasta abril de 2019. Funciona en los sistemas operativos Linux, Microsoft Windows, macOS y FreeBSD. Se utiliza, en este proyecto, para la realización de las convoluciones ocasionadas en la red neuronal MTCNN. 2.5 Git Git [20] es un Sistema de control de versiones distribuido de código abierto pensado para trabajar conjuntamente en proyectos de diversas dimensiones. En Git se tienen dos repositorios, uno local, y que abarca a los archivos que físicamente se almacenan en el computador, y otro remoto. Generalmente, en el inicio de cualquier proyecto, se comienza copiando archivos desde el repositorio remoto hasta el local. Para ello se utiliza la siguiente instrucción: git clone <url del repositorio> Ilustración 8. Logo de Keras y TensorFlow. Ilustración 9. Logo de GIT [40]. 12 Para añadir nuevas funcionalidades al proyecto se suelen crear ramas, que nos permiten tener nuevas líneas de desarrollo independientes. Es similar a tener un espacio de trabajo idéntico, sobre el cual realizar cambios. En Git se recomienda tener 3 tipos de ramas. Estas son las que se visualizan en la Ilustración 10. Por un lado, está la rama principal, conocida como master, que debe ser estable. Consiguientemente está la rama development, donde se añaden todas las nuevas funcionalidades. Una vez que esta rama es probada y corregida se agrupa en master. Finalmente están las ramas features que contienen cada una de las nuevas funcionalidades de development por separado. Para crear una nueva rama y saltar a ella se utiliza el comando que viene a continuación: git checkout -b <nombre de la nueva rama> Además, se pueden conocer las ramas locales existentes con el comando: git branch Cuando se trabaja en el ordenador, los cambios realizados se vinculan al repositorio local. Estos no se verán reflejados en el remoto hasta que no sean subidos. Con el comando git status se pueden conocer los cambios efectuados localmente con respecto al repositorio remoto. De esta manera, pueden ser añadidos o ignorados. Además, se permite la eliminación de archivos. Los comandos usados para ello son los siguientes: git add <nombre del archivo> git checkout <nombre del archivo> git rm <nombre del archivo> Una vez han sido tratados los cambios estos deben ser confirmados, para ello se indica lo siguiente: git commit -am <mensaje explicativo> Finalmente, para subir los cambios al servidor remoto se realiza lo siguiente: git push origin <nombre de la rama> Como ya se ha indicado anteriormente, cuando una rama está correctamente comprobada, suele ser impactada con la anterior. Para ello, se utiliza el siguiente comando: git merge <nombre de la rama> Master Development Features Features Features Development Ilustración 10. Tipos de ramas 13 14 3 INTRODUCCIÓN A LAS REDES NEURONALES n este capítulo se va a dar una breve introducción a los conceptos de redes neuronales necesarios para comprender los pilares en los que se basa el trabajo realizado. Se comenzará con una descripción de las redes neuronales, así como del ámbito actual en el que se encuentran (Deep Learning) para proseguir con los conceptos pertinentes a su entrenamiento. Posteriormente, se hablará de redes neuronales convolucionales, comúnmente usadas para la detección en imágenes de personas, animales u objetos. 3.1 Redes neuronales (NN – Neural Networks) Las redes neuronales artificiales son sistemas computacionales principalmente englobados en el campo del aprendizaje profundo, o en inglés, Deep Learning. Están compuestas por un conjunto de unidades, llamadas neuronas, que realizan cálculos simples, con el objetivo de, pasadas unas ciertas capas de estas, dar una respuesta a un problema específico. En la actualidad han cobrado una gran importancia, llegándose a solucionar problemas relacionados con el reconocimiento de imágenes, de caracteres, control de vehículos y generación de trayectorias, prevención de fraudes y análisis genético, entre otros. E Las 'leyes del pensamiento' no solo dependen de las propiedades de las células cerebrales, sino del modo en que están conectadas. La sociedad de la mente (1987) 15 3.1.1 Inteligencia artificial, Machine Learning y Deep Learning. El Deep Learning o aprendizaje profundo es una metodología de aprendizaje automático (Machine Learning) perteneciente al campo de la inteligencia artificial. El objetivo de la inteligencia artificial es el de dotar a las máquinas de la capacidad de comportarse de manera inteligente utilizando diversos mecanismos y programas. Este término comienza a utilizarse en la década de los 50s, sin embargo, termina siendo un área que no aporta buenos resultados debido a la inexistencia de elementos con alta capacidad computacional y de conjuntos elevados de datos. Es en la década de 2010 cuando se considera que explota, debido al desarrollo de unidades de procesamiento gráfico (GPUs), capaces de aportar la potencia de cálculo necesaria y, a la importancia que ha cobrado el BigData. En el 2012, la red neuronal convolucional AlexNet [21], entrenada con una GPU, gana el reto ImageNet Large Scale Visual Recognition Challenge con una CNN compuesta por 5 capas convolucionales, de las cuales algunas están seguidas de una etapa de submuestreo, y tres capas fully connected (Ilustración 12). La función de activación utilizada fue la ReLU, por dar lugar a un entrenamiento más rápido que otras, como la tanh. Era capaz de detectar un total de 1000 clases, entre las que se encuentran gatos, personas, cerezas… Esto supuso un antes y un después en lo relativo a las CNN, dando lugar a que se utilizaran en otros campos, como los referidos al reconocimiento de rostros. La red neuronal FaceNet [15] permite la obtención de 128 características por rostro, gracias a lo cual, utilizando la distancia euclidea, nos permite conocer si el individuo de una imagen se corresponde con el individuo de otra. En el apartado 5.1 se explicará detalladamente su funcionamiento. El machine learning consiste en aportar esta inteligencia utilizando algoritmos que permitan a la máquina aprender a partir de un conjunto de datos agrupados en patrones, sin necesidad de que se haya realizado una programación explícita. El Deep Learning, trata de realizar todo esto, imitando el cerebro humano, es decir, la red de neuronas que tiene. Este último, por tanto, sería lo más parecido a la inteligencia humana. Ilustración 12. Arquitectura de la red neuronal convolucional AlexNet. Imagen tomada de [21]. Ilustración 11. Inteligencia artificial, machine learning y deep learning. 16 3.1.2 Inspiración biológica Las redes neuronales artificiales se inspiran en aquellas presentes en el cerebro humano, por ser este un elemento complejo, no lineal y paralelo de procesamiento de información. Estas están compuestas por una agrupación de neuronas que establecen conexiones sinápticas consistentes en un intercambio eléctrico entre el botón sináptico de una neurona y el dendrítico de otra. Cuando se produce una estimulación en una neurona esta se altera electroquímicamente, almacenando energía que, al alcanzar un determinado valor, se descarga a través del Axón, partiendo del cuerpo hasta llegar a sus neuronas vecinas, creando así una conexión. El cerebro tiene aproximadamente 100G neuronas, cada una de las cuales establece 10k conexiones. Parte de la estructura de estas está determinada en el nacimiento, mientras que otra parte se desarrolla durante el aprendizaje, momento en el que se crean nuevas conexiones y se debilitan o pierden otras. 3.1.3 El perceptrón Basándose en la idea anterior, Frank Rosenblatt presenta el 1958 el perceptrón [22], que puede ser considerado como una neurona o como la estructura de red neuronal más simple, cuyo modelo puede verse en la Ilustración 14. Este posee un número determinado de entradas (𝑋) que son análogas a las dendritas de las neuronas biológicas; para las cuales hay asociados diferentes pesos (𝑊), similares a la intensidad con la que se produce la sinapsis; una unión sumadora; una función de activación (𝑔), parecida a la realizada en el cuerpo o soma; y una salida, que modelaría el axón. Botones sinápticos Axón Núcleo Dendritas Ilustración 13. Representación de una neurona biológica. Cuerpo ෍ 𝑦ො 𝑥1 𝑊1 𝑥2 𝑊2 𝑥𝑛 𝑊𝑛 Ilustración 14. Modelo de perceptrón. 1 𝑊0 … 17 La expresión que modela la salida del perceptrón se aprecia en la Ecuación 3. 𝑦ො= 𝑔ሺ𝑤0+෍𝑥𝑖𝑤𝑖 𝑛 𝑖=1 ሻ Ecuación 3. Salida de un perceptrón. La función de activación (𝑔ሻ puede ser de muchos tipos, siendo las más comunes la función lineal (ReLU), la función sigmoide y la tangente hiperbólica (Ilustración 16). La función sigmoide mantiene la salida en el intervalo 0 y 1, y cobra especial importancia cuando se quieren obtener salidas relacionas con distribuciones de probabilidad. La función ReLU tiene como ventaja el hecho de que es sencilla de computar ya que a partir de 0 es una función lineal igual a la entrada, siendo nula en todo momento anterior. La finalidad de una función de activación es la de introducir no linealidades a la red. La importancia de esto estriba en que generalmente la separabilidad de dos clases no puede realizarse mediante una línea recta, pero si mediante una curva. Un ejemplo de esto puede verse en la Ilustración 15, donde la clase círculos y la clase triángulos no son separables mediante rectas. Ilustración 15. Clases no linealmente separables. Ilustración 16. Ejemplo de funciones de activación. 24 Si este es pequeño, el gasto computacional será elevado, dando lugar a una ineficiencia en el algoritmo. Si es grande, las variaciones serán tan grandes que será complicado que este llegue a los mínimos, dando lugar a que el algoritmo no converja. La decisión de este valor es una de las tareas más importantes del modelado de la red. 𝑤𝑛𝑒𝑤=𝑤𝑜𝑙𝑑−𝜂·𝛻𝑓 Ecuación 17. Cálculo de un nuevo punto mediante el método del descenso del gradiente. En la Ilustración 23 se enseña un ejemplo de la búsqueda de un mínimo sobre una superficie. Se comienza desde un punto inicial, y se va caminando sobre la superficie en aquella dirección contraria a la que se produce un mayor cambio ascendente, o lo que es lo mismo, a aquella indicada por el gradiente en ese punto. Ilustración 23. Ejemplo del algoritmo de descenso del gradiente. 25 3.1.6 Sobre entrenamiento y falta de entrenamiento Cuando se entrena una red neuronal el objetivo que se tiene es que esta llegue a generalizar, es decir, que no solo sepa dar una respuesta certera a aquellas entradas que ya han sido introducidas, sino que haya aprendido a resolver también aquellas que nunca probó, y de las cuales no tiene respuesta. Es en este punto en el que aparecen los conceptos de sobre entrenamiento (overfitting) y falta de entrenamiento (underfitting). La falta de entrenamiento se da cuando el modelo no se ajusta lo suficientemente bien a los datos introducidos como para que este llegue a generalizar. Por ejemplo, en la Ilustración 24 se puede ver en verde un modelo que no está bien entrenado, ya que para unos datos que dibujan una curva se ha utilizado una solución lineal, no lo suficientemente buena. Sin embargo, para una curva polinómica de orden 3, en azul en la imagen, se muestra un resultado más acorde a los datos, que podría dar soluciones mucho más adecuadas, llegando a generalizar. Al aumentar el orden del polinomio, en rojo en la imagen para uno de orden 6, se obtienen curvas que se ajustan cada vez más a los datos. Sin embargo, esto no implica que este último sea bueno, ya que la red ha llegado a aprender de los datos de entrenamiento, de tal manera que no generaliza para el resto. A esto es a lo que se le denomina overfitting, en el cual se produce un modelado del ruido. Uno de los problemas del entrenamiento de las redes neuronales es identificar el punto adecuado de entrenamiento, de manera que no se produzcan ninguno de estos dos casos. 0 1 2 3 4 5 6 7 8 9 10 0246810 12 14 16 Overfitting - Underfitting Ilustración 24. Overffitting (rojo) underfitting (verde) y entrenamiento adecuado (azul) 26 Para conocer si hay sobre entrenamiento se dividen los pares de entrada y salida de manera que se tenga un conjunto de muestras de entrenamiento (≈80%), con el que se entrenará la red tal y como se ha indicado, y otro de pruebas (≈20%), con el que simultáneamente se probará su adecuado funcionamiento. Es importante que estos datos estén bien distribuidos, de forma que datos semejantes no se encuentren solo en el primer conjunto o viceversa. En ocasiones, puede ser buena idea ordenarlos aleatoriamente, aunque esto no siempre es adecuado. Durante el entrenamiento, como se muestra en la Ilustración 25, el error generado por las muestras de entrenamiento y de las de prueba decae, siendo generalmente mayor el de estas últimas, de forma más abrupta en los primeros momentos y menos al final. Llega un momento, señalizado por un punto naranja en la imagen, en el cual el error de las muestras de entrenamiento sigue cayendo, mientras que el de las de prueba comienza a aumentar. Es en este punto cuando se considera que la red está realizando overfitting, ya que para nuevas muestras deja de ofrecer resultados adecuados por haber aprendido de aquellas de entrenamiento. Un buen resultado de entrenamiento de la red se va a encontrar, por tanto, en dicho instante. 3.2 Redes Neuronales Convolucionales (CNN – Convolutional Neural Networks) Las redes neuronales convolucionales o convolutional neural networks (CNNs), en inglés, son redes neuronales artificiales que intentan asemejar el córtex visual mamífero. En [24] son entrenadas con una GPU para la clasificación de imágenes, campo en el que son frecuentemente usadas por requerir una densidad de red menor, comprobándose los buenos resultados obtenidos. Su principal diferencia con respecto al perceptrón multicapa, anteriormente visto, es que está formada por capas convolucionales y de submuestreo alternadas, terminando con un conjunto de capas full-connected. A continuación, se van a comentar estas fases. 3.2.1 Preprocesado de los datos En la actualidad, por lo general las imágenes están compuestas por conjunto de pixeles de 8 bits, lo que implica un rango de valores entre 0 y 255. En las redes neuronales estos datos suelen normalizarse, ya sea dividiendo entre 255, en cuyo caso el nuevo rango de valores se encontraría entre 0 y 1 o realizando una substracción de la media, donde se obtiene un rango entre -1 y 1. Esto se realiza por motivos computacionales, ya que mejora la velocidad de convergencia y evita, en ocasiones, problemas con gradientes, que provocan pesos iguales a 0 o que tienden a infinito. Además, en muchas ocasiones se modifica la estructura de la matriz que determina la imagen, convirtiéndola en un vector, como se muestra en la Ilustración 26. Tiempo de entrenamiento Error Muestras de entrenamiento Muestras de prueba Ilustración 25. Evolución típica del error de entrenamiento y prueba. Overfitting 0.5 0.3 0.8 0.6 0.4 0.7 0.5 0.5 0.7 0.5 0.3 0.8 0.6 0.4 0.7 0.5 0.5 0.7 Ilustración 26. Conversión de matriz a vector. 27 3.2.2 Capa de convolución En la capa de convolución, con el objetivo de disminuir el tiempo de convergencia de la red, las entradas, es decir, el acceso al valor tratado de los pixeles, no están todas conectadas con las neuronas pertenecientes a la capa oculta. En ella, como su nombre indica, se realizan las convoluciones entre la imagen y un filtro o kernel, modelado por la matriz de parámetros, y que inicialmente tomará valores aleatorios, siendo estos modificados según el algoritmo de backpropagation. Estas consisten en productos y sumas entre dos conjuntos de datos. En la Ilustración 27 se realiza una convolución entre la primera matriz, que compone los datos de entrada, y un filtro de Sobel, muy utilizado en visión por computador para la detección de bordes. Esta es efectuada utilizando un factor de salto en x e y (𝑆𝑥,𝑆𝑦) igual a 1, es decir, se hará un recorrido de un espacio en x cada vez que se realice un producto, y una vez no se pueda avanzar más, se realizará el salto en y, volviendo al inicio en x. Para el primero, centrado en la posición 𝑥=2 e 𝑦=2 se tienen el siguiente resultado: 0.3∗1+0.1∗−1+0.2∗2+0∗−2+0.4∗1+0.2∗−1=0.8 La dimensión de la capa de la red neuronal dependerá del tamaño de la entrada, del tamaño del filtro, del factor de salto y del número de filtros que se empleen. Por ejemplo, para MTCNN, que se verá más adelante, su primera red tiene como entrada una imagen RGB de tamaño 12𝑥12 y se utilizan 10 filtros de tamaño 3𝑥3, lo que da como resultado una salida de 10𝑥10𝑥10. A esta convolución debe de aplicársele un desplazamiento y la función de activación, que para las CNN se suele ser de tipo ReLU, aunque para el caso de MTCNN se utiliza la PreLU, similar a esta última con la diferencia de que para valores anteriores a 0 su valor no es nulo, manteniéndose en una recta, como la dibujada en la Ilustración 28. 0.3 0 0.1 0.2 0 0.2 0 0 0.1 0.1 0.4 0.1 0.2 0.1 0.2 0.6 0.2 0 0 0.5 0.5 0 0 0.5 0.6 1 0 -1 2 0 -2 1 0 -1 0.8 -0.4 -0.1 1.2 0.1 -0.6 1.9 -0.1 -1.6 ∗ = Ilustración 27. Ejemplo de convolución. 28 Ilustración 28. Función de activación PreLU. 29 3.2.3 Submuestreo con Max-Pooling Si se continua con el caso de la red MTCNN, se puede inferir que para una imagen de tamaño muy reducido (12𝑥12𝑥3 pixeles) se necesita un número elevado de neuronas en la capa de entrada (432 neuronas). Si, además, como se mostró más atrás, se utilizan 10 filtros de dimensiones 3𝑥3, tras la convolución de esta primera capa se obtienen 103 salidas. Cuando el tamaño de la imagen aumenta también lo hace la densidad de la capa, provocando que el gasto de cómputo sea muy alto. Es por ese motivo que se utiliza una capa de submuestreo en las primeras capas de la red. Para ello hay distintos métodos, pero el más conocido es el Max-Pooling, que consiste en pasar un filtro, de determinadas dimensiones y factor de salto, cuyo resultado será el valor más alto de todos los datos que comprenda. De esta manera, se queda con aquellas características que son más importantes. Por ejemplo, en la Ilustración 29 se utiliza un kernel de tamaño 2𝑥2 y desplazamiento 2. La primera iteración que realiza abarca la matriz [0 1 0 1] cuyo valor máximo es 1, dando lugar a que el primer dato de la salida sea un 1. Al producirse el desplazamiento se enfoca en [0 0 1 0], ocasionando un 1 en la salida. Si se continua, se obtiene el resultado mostrado. Con esta técnica se ha pasado de una matriz de dimensiones 8𝑥8 a otra de 4𝑥4, minimizando el coste de cómputo. Para la primera etapa de MTCNN se había comentado que se obtenía una salida en la convolución de tamaño 10𝑥10𝑥10. Al aplicar el submuestreo de la Ilustración 29 este se disminuye a 5𝑥5𝑥10. 3.2.4 Capa Full-Connected La capa Full-Connected es una capa densamente conectada, con todas sus entradas vinculadas con los parámetros de la red, que suele encontrarse en las últimas etapas de una CNN. Su principal función es como clasificador, es decir, determina la clase a la que pertenece la entrada introducida una vez tiene la salida de las capas que le preceden. En la Ilustración 17 se muestra este tipo de capas. 0 1 0 0 0 2 1 1 0 1 1 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 1 0 0 1 0 1 2 0 3 0 4 0 0 0 0 5 0 6 8 0 0 1 0 3 0 1 0 1 0 2 0 0 1 0 1 5 1 1 1 2 1 1 1 0 1 2 5 8 0 2 3 1 5 Ilustración 29. Efecto de realizar la operación de Pooling con una kernel de tamaño 2x2 y desplazamiento igual a 2. 30 3.2.5 Esquema de una red neuronal convolucional Como se ha ido comentando en los apartados anteriores, una red neuronal convolucional está compuesta por diversas capas. Hay que indicar, que en ocasiones se toman como diferentes aquellas que son de convolución y de submuestreo, sin embargo, para este proyecto se considerarán como una propia, por no tener, esta última, parámetros de peso o sesgo. Por lo tanto, se puede decir que en una red neuronal se parte de una entrada, que por lo general debe ser preprocesada, y se pasa a un número determinado de capas de convolución, que a su vez tienen, o no, asociado un submuestreo, probablemente según el algoritmo de Max Pooling. Finalmente, una vez ha obtenido un vector de características asociado a la entrada, gracias a una capa Fully Connected se obtiene la salida de la red. En la Ilustración 30 puede verse ejemplificado este proceso. Hay que indicar, que la salida aportará un valor indicativo de la confianza que tiene la red de que dicha entrada pertenezca a la clase determinada por ella misma. Convolución + PreLu Max Pooling … Fully Connected 𝑷𝒈𝒂𝒕𝒐 𝑷 𝒑𝒆𝒓𝒓𝒐 𝑷𝒑á𝒋𝒂𝒓𝒐 𝑷 𝒄𝒂𝒃𝒂𝒍𝒍𝒐 Ilustración 30. Estructura de una red neuronal convolucional. 31 32 4 DETECCIÓN DE ROSTROS Visualizo una época en la que (los humanos) seremos a los robots lo que los perros son para nosotros. Claude Shannon ara obtener descriptores de un rostro que nos permitan su identificación es inicialmente necesario obtener la zona en la que este se encuentra dentro de la imagen. Para ello, existen diversas técnicas, comentadas previamente en el apartado 1.2. Hoy en día, la mayoría de los enfoques se basan en el uso de redes neuronales convolucionales, que obtienen buenos resultados incluso ante situaciones de cambios de iluminación, oclusión, caras no dispuestas frontalmente o gesticulación. En este proyecto se van a comparar dos técnicas, por un lado, una propuesta por DLIB, y proporcionada por 4i, que se basa en el uso de HOG junto con SVM; por otro, MTCNN, que hace uso de redes neuronales convolucionales. Los archivos network.cpp y network.h, mencionados en el apartado 1.3, se encargan de la implementación de esta red neuronal. 4.1 DLIB DLIB ofrece un conjunto de herramientas implementadas en el lenguaje de programación C++ con algoritmos de aprendizaje automático como redes neuronales, máquinas de vectores de soporte (SVM) o algoritmos de agrupamiento, entre el que se encuentra k-means. Ofrece una licencia de código abierto, o en inglés Open Source, para cualquier tipo de aplicación, utilizándose en multitud de campos, ya sea de tipo industrial, comercial o académico. En la Ilustración 31 aparece el logo de DLIB. P Ilustración 31.Logo de DLIB. 33 Para la detección de rostros DLIB ofrece varias soluciones. Por ejemplo, se implementan clasificadores en cascada AdaBoost junto con las características de Haar, técnica basada en [2]. Otro método se orienta hacia el aprendizaje profundo, empleando para ello una red neuronal convolucional (CNN). Finalmente, también se implementa un algoritmo que hace uso de HOG (Histogram of Oriented Gradients) como descriptor junto con SVM (Support Vector Machine). Este último ha sido empleado en el proyecto, siendo el programa tomado de la empresa 4i para compararlo con el detector y alineador de rostros MTCNN. A continuación, se va a comentar de manera superficial en que consiste el descriptor HOG y el clasificador SVM. El histograma de gradientes orientados (HOG) es un descriptor de características utilizado en visión por computador para la clasificación de texturas y la detección de objetos y personas, entre otros. Para su obtención se divide la imagen en celdas, de tamaño determinado. Para cada una de ellas se calcula el histograma de gradientes, que representa la distribución del módulo dentro de la misma según su orientación, calculada en el rango 0º- 180º. Con el objetivo de que sea invariante a cambios de iluminación, el histograma es normalizado. La agrupación de los valores obtenidos genera un vector de características, denominado descriptor, que modela el elemento presente en la imagen. Para representarlo se utilizan los valores más significativos calculados en la celda, como puede verse en la Ilustración 33. Una máquina de vectores de soporte (SVM) es un algoritmo de clasificación lineal cuya frontera de decisión está delimitada por un hiperplano. Cuando se tienen dos clases linealmente separables, donde el número de hiperplanos que las divide es infinito, en SVM la solución generada se corresponde con aquella que Ilustración 33. Representación de HOG. Ilustración 32. Plantillas para el cálculo del gradiente en las direcciones X e Y 40 4.2.3 Output Network (O-Net) O-Net es una red neuronal convolucional utilizada en la tercera etapa de MTCNN con el objetivo de obtener la salida de MTCNN, refinando más los resultados anteriores obtenidos y consiguiendo 5 puntos característicos del rostro humano. En la Ilustración 42 se muestra un esquema de su arquitectura. La entrada es una imagen RGB, relativa a las ventanas contenedoras de rostros obtenidas en la etapa anterior, de tamaño igual a 48𝑥48𝑥3 pixeles. Está compuesta por 4 convoluciones de tamaño seguidas de un desplazamiento, una función PreLu y, a excepción de la última, capas de agrupación (Pooling) de tamaño 3𝑥3. Con ello se obtienen agrupaciones de datos agrupados en matrices de tamaño 3𝑥3𝑥128. A estos se le aplica una capa Fully Connect, con la que se obtienen vectores con 256 características, a las que se le aplican separadamente 3 capas Fully Connect, dando lugar a vectores de tamaño igual a 2, a 4 y a 10, con la confianza de la ventana, su posición y las coordenadas de los 5 puntos característicos de los rostros encontrados. En la Ilustración 43 se muestra un diagrama con las etapas de esta red. Input Size 𝟒𝟖𝒙𝟒𝟖𝒙𝟑 𝟐𝟑𝒙𝟐𝟑𝒙𝟑𝟐 𝟏𝟎𝒙𝟏𝟎𝒙𝟔𝟒 𝟑𝒙𝟑𝒙𝟏𝟐𝟖 𝟏𝟎 𝟒 𝟐 Conv: 3x3 MP: 3x3 Conv: 3x3 Conv: 2x2 𝑭𝑪 𝑩𝑩𝑹 𝑭𝑳𝑳 FC: Face Classification BBR: Bounding Box Regression FLL: Facial Landmark Localization MP: Max Pooling Conv: Convolution O-Net MP: 3x3 𝟐𝟓𝟔 𝟒𝒙𝟒𝒙𝟔𝟒 Conv: 3x3 MP: 3x3 Fully Connect Ilustración 42. O-Net. Representación obtenida a partir de "Joint Face Detection and Alignment using MTCCN" 41 Tratamiento de datos Convolución 1 Desplazamiento + PReLu 1 Agrupación (Pooling) Tratamiento de datos Convolución 2 Desplazamiento + PReLu 2 Agrupación (Pooling) Tratamiento de datos Convolución 3 Desplazamiento + PReLu3 Agrupación (Pooling) Tratamiento de datos Convolución 4 Desplazamiento + PReLu4 Full Connect 1 Desplazamiento + PreLu4 Fully Connect 2.1 Desplazamiento SoftMax Fully Connect 2.2 Desplazamiento Fully Connect 2.3 Desplazamiento Ilustración 43. O-Net: Diagrama. 42 4.2.4 NMS (Non-Maximum Suppression) En visión por computador, cuando se realizan tareas de detección, ya sea de objetos, personas o animales, es frecuente encontrar varias ventanas que definen la posición en la que se encuentra un mismo elemento dentro de la imagen. A pesar de que ninguna de estas regiones puede considerarse un falso positivo, este resultado no es beneficioso, ya que de él se infiere que sobre dicha representación se han encontrado varios objetos, aun cuando solo hay uno. Para solucionar este problema se utiliza NMS (Non-Maximum Suppression). En la Ilustración 44 puede apreciare este efecto, llegándose a detectar 3 rostros cuando tan solo hay uno en la primera imagen. Sin embargo, en la segunda se encuentra una, ya que se ha aplicado dicho algoritmo. En este proyecto, la NMS se apoya de la intersección sobre la unión (IoU). La IoU compara el área que se superpone entre dos rectángulos, que se considera contienen el objeto, y la unión de ambos. En la Ilustración 45 se muestra esquemáticamente dicho concepto. Hay que indicar que esta funcionalidad también posibilita otro método para calcular la IoU que consiste en variar el denominador de manera que este sea igual al área menor de ambos rectángulos. Este método se muestra en la Ilustración 46. Ilustración 44. Múltiples soluciones a la detección de rostros cuando en la imagen solo se encuentra uno. Ilustración 45. Cálculo de la IoU a partir de la unión. 43 Como las detecciones que hace cada una de las redes neuronales tienen asignada una confianza también nos valemos de esta para determinar aquellas zonas que se consideran como solución. El algoritmo que va a utilizarse ordena, de menor a mayor, los elementos que se han obtenido según su puntuación. Saca los últimos, es decir, aquellos con mayor confianza, y compara si este ha sido ya suprimido. De no haberlo sido, es “eliminado” y comparado con el resto de los cuadros. Para ello, se calcula el rectángulo superpuesto entre ambos para obtener la IoU. En caso de ser esta mayor a un valor umbral, lo que indica que ambas contienen el mismo objeto o señalan el mismo espacio, la comparada es eliminada. Cuando se han tratado todos los rectángulos se puede considerar que los comparados son aquellos que contienen el objeto. En la Ilustración 47 se muestra el diagrama que modela dicho algoritmo. Ilustración 46. Cálculo de la IoU a partir del área máxima Sí No Ordenar Score (ASC) Sacar el último Order < 0 Existe = 0 Cada cuadro Cálculo de IoU IoU > Umbral Eliminar cuadro (order = -1) ¿Último? Ilustración 47. Diagrama NMS. … Sí No 44 4.2.5 Funcionamiento de MTCNN Una vez se han comentado en los apartados anteriores las herramientas utilizadas por MTCNN para realizar su detección, vamos a mencionar el flujo de trabajo que realiza. Inicialmente, como se ha comentado, se obtiene una pirámide de imágenes, de manera, que la de menor tamaño de 12𝑥12𝑥3 pixeles. A cada imagen se le pasa la red neuronal P-Net, que nos aporta las ventanas es las que se encuentran los rostros junto con su confianza. A estas soluciones se le aplica el algoritmo NMS con el objetivo de eliminar ventanas redundantes sobre cada imagen. Con todas las soluciones, se vuelve a aplicar el algoritmo NMS y un refinado, eliminando no solo las ventanas sobrantes en una imagen, si no que tambien cohesionando las soluciones iguales dadas en diferentes imágenes escaladas. NMS - Refinado Para cada ventana: Redimensiónar -> 48x48 O-Net Filtrado por umbral NMS - Refinado Para cada ventana: Redimensionar -> 24x24 R-Net Filtrado por umbral NMS - Refinado Para cada imagen: P-Net NMS Escalado (obtención de la pirámide) Ilustración 48. MTCNN. Diagrama. 45 Posteriormente, se modificará el tamaño de cada ventana encontrada, de manera que pase a ser de 24𝑥24x3 pixeles. A estas, se le aplicará la red R-Net, que nos dará las ventanas de una manera más fina junto con su confianza. Solo pasarán a la siguiente etapa aquellas que superen un determinado umbral, en este caso, igual a 0.7. Los resultados obtenidos pasarán por el algoritmo NMS y un refinado. Análogamente, cada solución se vuelve a escalar, consiguiendo un tamaño igual a 48𝑥48𝑥3 pixeles. Sobre ellas, se aplica la red O-Net, cuyas soluciones vuelven a ser filtradas en función de un umbral igual a 0.7. Finalmente, a los resultados finales se les vuelve a aplicar el algoritmo NMS y una etapa de refinado. Con ello, se obtienen no solo las ventanas en las que se encuentran rostros, sino que tambien 5 puntos característicos de dicha cara. En la Ilustración 49 se puede apreciar el resultado de aplicar dicha red neuronal. Ilustración 49. Resultado de la aplicación de MTCNN. 46 4.3 Comparación entre el detector de rostros MTCNN y el basado en HOG y SVM empleado en DLIB. Para comparar ambos detectores de rostros se han utilizado dos bases de datos. La primera de ellas es YouTube Faces Database [25],que contiene imágenes obtenidas de frames de un total de 3425 videos de 1595 personas diferentes. Además, viene complementada con documentos de texto en los que se indica el recuadro contenedor del rostro que se presenta. Un ejemplo de estas son las mostradas en la Ilustración 50. Aunque las imágenes contenidas en este dataset no son sencillas, por contener rostros que presentan oclusiones y por la calidad de estas, se ha utilizado otro banco de imágenes cuyas fotografías han sido tomadas en la calle. Este segundo dataset es GRAZ01-persons con 460 imágenes, en las cuales no todas ellas contienen rostros. En una imagen puede haber una o más personas, de las cuales no tiene por qué estar presente la cara y, de estarlo, es posible que sea poco visible. Un ejemplo de estas son las mostradas en la Ilustración 51. Ilustración 50. Ejemplos de las imágenes del dataset "Youtube Faces Database". 47 Ilustración 51. Ejemplos de imágenes del Dataset "GRAZ01-persons". 48 Para el primer banco de imágenes (Youtube Faces Database), al tenerse el recuadro que delimita los rostros, se ha programado un algoritmo, que mediante la intersección sobre la unión (IoU) nos permite establecer si la solución obtenida, de existir, es válida. Con el algoritmo MTCNN se ha establecido el umbral de IoU en el 80%. Se han encontrado un total de 446648 rostros positivos de los 621126 totales, es decir, el éxito es del 71.9%. Utilizando el algoritmo de detección de DLIB, con un umbral del 80% se obtienen resultados bastante malos, ya que para un total de 27000 rostros solo se detectan 4322 positivos (16%). Con esta tendencia claramente, al realizar todo el proceso el resultado no iba a variar drásticamente, por lo que se ha decidido disminuir la IoU al 50%. En dicho caso, se han encontrado 98325 rostros de los 162000 estudiados, lo que representa un 60,7%. En el mismo experimento, para las mismas 27000 que se examinaron con la IoU del 80% se han conseguido 17884 detecciones (66.23%). Claramente, eso indica que los cuadros contenedores dados por DLIB varían con respecto a las soluciones dadas por el dataset de manera mucho más significativa de lo que lo hace MTCNN. En la Ilustración 52 se muestra un gráfico con los resultados obtenidos en los experimentos. En la Ilustración 53 se muestra una de las detecciones realizadas sobre el banco de imágenes Youtube Faces Database. En ella, el algoritmo MTCNN encuentra adecuadamente el rostro, mientras que DLIB no. Hay que indicar que la calidad de la imagen es reducida, y que el rostro está parcialmente difuso debido a las gafas que posee el hombre. Un resultado similar se aprecia en la Ilustración 54. 71,9 84,41 16 60,7 0 10 20 30 40 50 60 70 80 90 IoU 80% IoU 50% Porcentaje de detección con el dataset "YouTube Faces Database" MTCNN DLIB Ilustración 52. Porcentaje de detección con el dataset “YouTube Faces Database”. 49 En la Ilustración 55 se ha vuelto a presentar el mismo experimento sobre otra imagen. En este caso, MTCNN solo encuentra uno de los rostros, ya el otro tiene pocas características visibles. DLIB también aporta una solución, que en este caso se corresponde con un falso positivo. En la Ilustración 56 se puede apreciar como ambos detectores encuentran el rostro. Sin embargo, el recuadro respectivo a la solución otorgada por MTCNN representa una mejor solución que el dado por la de DLIB. Es uno de los motivos por el cual ha sido necesario aumentar el IoU para tener mejores resultados. Ilustración 53. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset YouTube Faces Database. Ilustración 54. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset YouTube Faces Database. Ilustración 55. Resultados obtenidos con MTCNN y DLIB respectivamente usando una imagen del dataset YouTube Faces Database. 56 Tabla 1. Estructura de la red convolucional utilizando filtros de dimensiones 1𝑥1. Sacada de [15]. Tabla 2. Estructura de NM2 Inception, para FaceNet. Tabla sacada de [15]. 57 5.1.2 Triplet Loss Uno de los conceptos más relevantes de FaceNet es el de la triple pérdida (Triple Loss) según la cual es entrenada la red neuronal convolucional. Una imagen, con esta red, se proyecta en un espacio euclideo ddimensional y restringido a una hiperesfera. Lo que se pretende es que una determinada imagen 𝑥𝑖𝑎, denominada ancla (anchor), se encuentre a una distancia menor de imagen positiva 𝑥𝑖𝑝, que de otra negativa 𝑥𝑖𝑛 (Ilustración 64). El objetivo de esto es el de aumentar la capacidad discriminativa que tendrá la CNN. En la Ecuación 18 se muestra la ecuación que modela este proceso, en ella, 𝛼 es un umbral entre los pares positivos y negativos y 𝑇 el conjunto de todas las posibles tripletas en el conjunto de entrenamiento. La pérdida se minimiza cuando se cumple la Ecuación 19. ‖𝒇(𝒙𝒊𝒂−𝒇(𝒙𝒊𝒑))‖𝟐𝟐+𝜶<‖𝒇(𝒙𝒊𝒂−𝒇ሺ𝒙𝒊𝒏ሻ)‖𝟐𝟐,∀(𝒇ሺ𝒙𝒊𝒂ሻ,𝒇ሺ𝒙𝒊𝒑),𝒇ሺ𝒙𝒊𝒏ሻሻ ∈ 𝑻 Ecuación 18. Tripletas 𝐿= ෍[‖𝑓(𝑥𝑖𝑎−𝑓(𝑥𝑖𝑝))‖22−‖𝑓(𝑥𝑖𝑎−𝑓ሺ𝑥𝑖𝑛ሻ)‖22+𝛼] 𝑁𝑖+ Ecuación 19. Minimización de la pérdida. El uso de todo el conjunto completo de tripletas provoca que la convergencia de la red sea muy lenta, muchas de ellas no aportando positivamente en el entrenamiento. Por esta razón es importante elegir bien qué tripletas se utilizan. Para ello, el enfoque utilizado fue el de escoger para cada imagen aquella otra imagen positiva con la cual la distancia fuese máxima y una negativa con respecto a la cual la distancia fuese mínima. El problema que esto conlleva es la dificultad de calcular dichas distancias en todo el conjunto de entrenamiento, además del efecto negativo ocasionado por rostros mal etiquetados o representados que entrarían a formar parte de las tripletas. Como solución se generan pequeños lotes con muestras positivas y negativas, calculando las distancias entre ese reducido número de imágenes. Ilustración 64.Triplet Loss. Esquema de funcionamiento. Imagen sacada de [15]. 58 5.2 Prueba de FaceNet Con el objetivo de probar el funcionamiento del algoritmo de reidentificación de rostros se han realizado varios programas sencillos en Python. Para ello, se ha utilizado el banco de imágenes YouTube Faces Database. Este está compuesto por imágenes sacadas de 3425 videos de dicha plataforma de 1595 personas. Se siguieron distintos criterios para realizar las comparaciones. En primer lugar, para un total de 158305 imágenes sacadas de este dataset se buscó aquella en la que aparecía la persona que más se la asemejaba. Si ambas se correspondían con la misma persona se consideraba como un acierto. Como es de esperar, los resultados obtenidos con este enfoque fueron muy buenos. Esto se debe a que, al estar las imágenes sacadas de frames de un mismo video, la diferencia entre el rostro de imágenes consecutivas es pequeña, generando un acierto. Para sacar estos datos solo se tuvieron en cuenta aquellas identificaciones que ya había generado previamente un acierto en lo relativo al problema de detección de rostros. De esta manera, aquellos casos en los que este problema fallase no han sido considerados como error. El número de rostros identificados correctamente, como puede verse en la Ilustración 65, es igual a 158268. Por tanto, el porcentaje de detecciones correctas es igual al 99.9766%. Posteriormente, se decidió utilizar tan solo a aquellas personas que tenían imágenes sacadas de varios videos, de manera que un conjunto pudiese utilizarse solo como modelo. De esta forma, las imágenes con las que se buscaban correspondencias no se comparaban con una que ha sido tomada del mismo video y, por tanto, que se le parece considerablemente. Los resultados en este caso cayeron, siendo la tasa de acierto considerablemente más baja. Como puede verse en la Ilustración 66, el número de rostros identificados correctamente es igual a 21092, para un total de 82675. Por tanto, el porcentaje de detecciones correctas es igual al 25%. Al ver el efecto que tenía sobre las imágenes el proceso de identificación del individuo se pudo observar cómo, debido a distintos factores, como pueden ser oclusiones, cambios en las expresiones, mala iluminación o desenfoques, la tasa de acierto disminuía considerablemente, siendo este decremento mayor cuando el modelo escogido era el que sufría alguno de ellos. Si, además, el número de imágenes tomadas de dicho video era elevado, el impacto sobre el porcentaje de acierto también era mayor. En la Ilustración 67 puede verse una de las imágenes para las cuales se trata de realizar la tarea de reidentificación. Puede observarse como es una imagen compleja, incluso para el ojo humano, ya que presenta un rostro parcialmente oculto y poco nítido. 0 20000 40000 60000 80000 100000 120000 140000 160000 Método 1 Correctas Incorrectas 158200 158250 158300 158350 158400 Método 1 Correctas Total Ilustración 65. Prueba de FaceNet según el método 1. 0 20000 40000 60000 80000 100000 120000 140000 160000 Método 2 Correctas Incorrectas Ilustración 66. Prueba de FaceNet según el método 2. 59 De una manera más controlada, se han realizado una tercera prueba, escogiendo para ella la imagen modelo que define al individuo, es decir, entre las videos asociados a cada una de las personas, se ha escogido aquel en el que el rostro que aparece está en una posición más frontal y con menos oclusiones. Para esta prueba se han utilizado un total de 100 individuos, con un total de 21320 imágenes entre todos. Además, esta vez se ha evaluado el problema completo, considerando como erróneo aquel caso en el que ni siquiera se detecta un rostro. El programa que se ha utilizado es uno similar al descrito en el apartado 6.3, cuya única diferencia es que realiza pruebas de forma masiva, es decir, lee las imágenes que se encuentran en una carpeta, y sobre ellas realiza el algoritmo indicado en dicho punto. Para una mayor claridad, esta prueba será explicada en el apartado . Se puede adelantar, que el porcentaje de acierto es del 73.6%. A continuación, se van a mostrar una serie de imágenes para ejemplificar los efectos encontrados. Ilustración 68. Detección correcta para todos los tipos de imágenes de un individuo (modelo → arribaizquierda). Ilustración 67. Imagen obtenida del dataset. 60 En la Ilustración 68, se puede observar como todas las imágenes de pruebas, ilustradas mediante la representación de una por cada video, aportan la identificación correcta. Finalmente, en la Ilustración 69 se puede observar cómo se tiene un modelo (derecha) cuyo rostro se encuentra parcialmente oculto, al intentar detectar la persona que se encuentra en la imagen de prueba (izquierda) el programa nos indica que esta es desconocida. En la Ilustración 70, se parte de un modelo frontal (derecha), pero la cara con la cual se realiza la comparación (izquierda) está colocada lateralmente. A pesar de esto, se consigue detectar la identidad del individuo. Hay que comentar que también nos encontramos con una persona, sin introducir en la base de datos, identificada, certeramente, como desconocida. En la Ilustración 71 se pueden ver dos imágenes, una perteneciente al modelo (izquierda) y otra de prueba que, según indica el dataset se corresponden con el mismo individuo. Hay que indicar que las diferencias son notables y que, comprensiblemente, el algoritmo da lugar para todas las imágenes detecciones erróneas, asignándole la identidad del individuo de la Ilustración 68. Ilustración 69. Detección de un individuo (izquierda) utilizando como imagen modelo (derecha) una cuyo rostro se encuentra parcialmente oculto. Ilustración 70. Detección correcta en una imagen (izquierda) con el rostro parcialmente oculto a partir de la imagen con la cara modelo (derecha) situada frontalmente. 61 Ilustración 71. Detección errónea (modelo arriba-izquierda). 62 6 DETECTORES IMPLEMENTADOS Crear un ser artificial ha sido el sueño del hombre desde que nació la ciencia Película (A.I Inteligencia artificial) n este apartado se va a comentar detalladamente la implementación de los archivos detector_mtcnn.cpp, detector_mtcnn.h, detector_mtcnn_facenet.cpp, detector_mtcnn_facenet.h y main.cpp (del subdirectorio detector/testFacenet). Para ello, también se tendrá que mencionar cual es la filosofía del resto del espacio de trabajo. En lo que atañe al proyecto hay que tener en cuenta archivos incluidos en la carpeta Data, en concreto Data::CFace, ya que nos determinan el formato de la salida aportado por los detectores. Además, se comentará el funcionamiento de detector_manager, ya que hace de puente entre los archivos main y los propios detectores. También se tendrán que considerar los archivos .Json, almacenados en detector/cfg, que contienen la configuración de los detectores. En esta misma ubicación, aunque podría realizarse en otra indicándolo correctamente en los ficheros que se acaban de comentar, se han introducido previamente cada uno de los archivos que contienen los pesos o la configuración de las redes neuronales. Finalmente, se tendrá que comentar la existencia de un fichero principal, encargado de realizar detecciones, dentro de la carpeta detector/test. Este es similar al creado para la identificación de individuos (apartado 6.3). La principal diferencia práctica es que, cuando llama al detector vinculado con FaceNet tan solo se obtiene la estructura de datos relacionada con los descriptores asociados a los individuos que se encuentran en la imagen, y no su identificación con respecto a todos aquellos almacenados en la base de datos. Para conseguir esto se utiliza el compilado detector_facenet_test, obtenido del archivo ubicado en detector/testFacenet. E 63 6.1 Detector MTCNN Para la elaboración de este detector se ha creado una clase, llamada MTCNN, según la estructura del resto de clases pertenecientes a detectores proporcionadas por 4i. Esta está compuesta por un método encargado de realizar la inicialización de la red, que tiene como entrada un archivo .Json, descrito más adelante y la dirección absoluta a la carpeta detector. La función de este es la de obtener todas las rutas a los ficheros que contienen los pesos de las redes neuronales PNet, RNet y Onet descritas en el apartado 4.2. Además, también contiene otro método, detect, que se encarga de cargar la imagen en la cual se deben realizar las detecciones. Posteriormente se llama a la clase mtcnn y se invoca el método encargado de la detección de rostros. Para cada Bounding Box encontrado se modifica el valor de los pixeles que lo definen, pues la imagen ha cambiado de tamaño, y se almacena, junto con la probabilidad obtenida de que sea un rostro, en un puntero de tipo data::CFace. El conjunto de estos punteros es devuelto por dicho método. Para probar su funcionamiento se utiliza el compilado detector_test, aportado por 4i. A continuación, se indica la instrucción que debe ser incluida por terminal para obtener la posición de los rostros dentro de una imagen. 6.1.1 JSON asociado a MTCNN El archivo detector_mtcnn.json se utiliza para indicar el tipo de detección que se desea, “mtcnn” en dicho caso, la clase que se está buscando, “face”, y las rutas a los pesos de las redes neuronales PNet, RNet y ONet. Este puede verse en la Ilustración 72. 6.2 Detector MTCNN junto con FaceNet. Este archivo mantiene una estructura similar a la descrita en el apartado 6.1. Como ya ocurría, se tiene un método encargado de la inicialización del detector en el que se cargan las rutas correspondientes a archivos externos. Además de las comentadas anteriormente, será necesario obtener, y por tanto recibir, las vinculadas con el modelo de la red neuronal FaceNet. En este caso, se crea un Tensor de tipo flotante y tamaño conocido (160x160x3) y se lee la definición del modelo aportado, además de crear una sesión para poder utilizarlo. El método detect, recoge la imagen de la cual se quieren obtener los rostros junto con sus descriptores, instancia la red neuronal MTCNN, y detecta con ella las caras sobre dicha figura. Para cada uno de los Bounding Box encontrados se modifica su tamaño a uno predefinido, e igual al del Tensor anterior (160x160). Posteriormente se pasa a modificar los datos de entrada a la red neuronal, como se hizo con MTCNN en el apartado 4.2. Para ello se copia todo en un vector, del que se calcula la media y la desviación estándar. Con estos valores, a los valores de los pixeles de la imagen original se le realiza una sustracción de la media, dividiéndolos además por su desviación estándar. Se consigue así que siga una distribución normal. Los datos obtenidos son pasados al Tensor inicial. Para cada uno de estos tensores se ejecuta la red, con dos capas de entradas, una de las cuales tiene como entrada el tensor calculado, y otra con un nuevo tensor. La salida, correspondiente con el descriptor de cada rostro, se almacena en un vector de flotantes. Al igual que ocurría anteriormente se calcula el bounding Ilustración 72. JSON del detector MTCNN. ./detector_test --image <ruta de la imagen> --config <ruta de la carpeta contenedora del archivo .Json>/detector_mtcnn.json' --classes face 64 box real sobre la imagen de entrada y se crea un elemento, de tipo data::CFace, al que se le asocia el rectángulo real al que pertenece el rostro, un identificador, y el vector de características obtenido. Con el objetivo de probar su funcionamiento se utiliza el compilado detector_test, al igual que se hizo en el apartado 6.1. A continuación, se indica la instrucción que debe ser introducida por terminal para obtener el descriptor de cada uno de los rostros que se encuentran dentro de la imagen. 6.2.1 Json asociado al detector MTCNN junto con FaceNet El archivo detector_facenet.json se utiliza para indicar el tipo de detección que se desea, “facenet” en dicho caso, la clase que se está buscando, “face”, las rutas a los pesos de las redes neuronales PNet, RNet y ONet¸la ruta al archivo de configuración de la red FaceNet, el tamaño predefinido del tensor de entrada, así como la definición de sus capas. Este puede verse en la Ilustración 73. Ilustración 73.JSon del detector MTCNN junto con FaceNet. ./detector_test --image <ruta de la imagen> --config <ruta de la carpeta contenedora del archivo .Json>/detector_mtcnn.json' --classes face 65 6.3 Fichero principal para las pruebas con MTCNN y FaceNet Este archivo se encuentra pensado para realizar pruebas con ambas redes neuronales. Para su correcto funcionamiento es necesario que reciba como parámetros de entrada el fichero JSon al que está vinculado, y que en este caso se corresponde con el indicado en el apartado 6.2; la imagen sobre la cual se quiere realizar la detección de los individuos, el archivo JSon en el que se han almacenado los descriptores de las imágenes modelo y el valor del umbral que delimita si la distancia es suficiente para hacer una asociación. Una vez se comienza con la ejecución se instancia la clase CDetectorManager y se realiza su inicialización, pasándole como argumento de entrada el archivo JSon de configuración. El funcionamiento de este método, superficialmente, se basa en leer el fichero .json para así conocer el tipo de detector que se está utilizando. En función de esto crea un puntero a la clase asociada al detector que se encarga de realizar las operaciones pertinentes, en nuestro caso, será de tipo CDetectorMtcnnFacenet. Posteriormente, se llama al método de la inicialización de dicho descriptor. Si esta ha sido realizada con éxito se almacenan todas las clases en un vector privado perteneciente a dicha clase junto con los punteros creados. Volviendo al fichero main.cpp, el siguiente paso que se realiza es la carga de la imagen cuya ruta ha sido pasada por terminal. Tras esto, se invoca al método detect de detectorManager. Este recibe como entrada la imagen sobre la cual realizar las detecciones y una lista con las clases que se están buscando en estas. Su función se enfoca en, para cada puntero asociado a detectores (se tienen todos pues, como se ha comentado, se han almacenado junto con sus clases) y pertenecientes a una de las clases indicadas como entrada al método, llamar al método detect asociado al mismo. Este nos aportará un puntero a un resultado, de tipo data::AObject que, en nuestro caso tendrá los datos de uno de tipo data::CFace. El conjunto de todos los resultados será devuelto a la función principal. Gracias a esta salida, y a los descriptores almacenados en el .json se puede calcular la distancia euclidea, asignando a cada detección el modelo con el cual la distancia es mínima. Además, se ha incluido un valor umbral, pudiendo ser el individuo desconocido. Con el objetivo de obtener un resultado más visual en este proyecto se han añadido sobre la imagen de entrada los rectángulos contenedores de rostros, junto con el Id correspondiente a cada vinculación. Para probar su funcionamiento, en este caso, se utiliza el compilado detector_facenet_test. A continuación, se indica la instrucción que debe ser introducida por terminal para obtener la identidad de cada uno de los individuos que se encuentran en la imagen. 6.3.1 Pruebas realizadas con distintas imágenes Como se comentó en el apartado 5.2 se ha realizado una prueba utilizando los archivos comentados en esta sección. Para ello, se han calculado los descriptores de 100 imágenes modelo con el programa detector_test. Estos han sido almacenados en el fichero .Json que se comentó en 6.3. Con un programa similar a detector_facenet_test, cuya única diferencia se encuentra en que realiza un proceso masivo de identificaciones, se ha comprobado si las asignaciones entre los rostros contenidos en las imágenes de prueba y los modelos son correctas. Los resultados obtenidos pueden verse en la Tabla 3, donde se indica en la primera columna el individuo al que pertenecen, en la segunda la distribución de carpetas que contenían el conjunto de imágenes, la tercera el número de identificaciones correctas y la cuarta el número de veces en el que aparece el individuo. Finalmente, en la última fila se realiza el sumatorio de los dos últimos datos. Como se puede observar, el resultado que se ha obtenido es de 15692 rostros identificados con respecto a 21320 totales. Es decir, se ha obtenido un porcentaje de identificaciones correctas del 73.6% para este conjunto de datos. ./detector_facenet_test --image <ruta a la imagen sobre la que se desea identificar rostros> --config <ruta de la carpeta contenedora de los archivos .Json>/detector_facenet.json --descriptors <ruta de la carpeta contenedora de los archivos .Json>/facesDescriptions.json --thr 1.1 72 2 0 57 87 1 189 189 88 1 48 48 89 1 25 61 2 114 118 3 20 73 90 1 53 57 2 60 134 91 1 62 62 2 164 173 3 117 117 92 1 51 53 93 1 67 67 94 1 37 49 95 1 66 66 96 1 90 111 2 3 105 97 1 47 49 98 1 161 200 99 1 63 101 100 1 42 52 Suma 15692 21320 Tabla 3. Resultados obtenidos con el identificador de rostros para un total de 100 individuos. 73 Las imágenes que se van a indicar a continuación se corresponden con ejemplos de la prueba que acaba de comentarse. En la Ilustración 74 se pueden observar dos imágenes con dos individuos. En la primera, la mujer tiene asociada una identidad que no le pertenece. Como se verá más adelante, esto podría seguramente solucionarse modificando el valor umbral. En la segunda, solo se detecta un rostro, por lo que en este caso el error se debe a la red neuronal MTCNN. Fallos en el problema de detección de caras es otro motivo por el cual la reidentificación de individuos puede dar lugar a malos resultados. En la Ilustración 75 se muestra un conjunto de imágenes en las cuales todas las identificaciones se han realizado correctamente, incluidas las de los individuos desconocidos. Ilustración 74. Fallo en las identificaciones o detecciones. 74 En la Ilustración 76 hay un conjunto de imágenes representativo de una serie de cosas. Por un lado, la primera imagen se corresponde con el modelo del individuo. En la segunda, se realiza una correcta distinción de mismo, asignando a la otra persona la identidad de desconocida. En la tercera y en la cuarta se muestra la variación del valor umbral de FaceNet. Por un lado, en la tercera se acierta al considerar como desconocida a la enfermera, pues su rostro no se encuentra en el archivo .Json, sin embargo, no se detecta a H. Ford, quien sí que tiene el descriptor incluido en el mismo. Por otro, en la cuarta se ha aumentado el umbral, de 1.1 a 1.5, llegándose a asignar una identidad errónea a las personas. En la quinta y en la sexta se detectan los rostros adecuadamente. Estas se han incluido pues pertenecen al mismo video, y mientras que la sexta es una imagen compleja la quinta no lo es. El motivo por el que se ponen es porque no siempre las imágenes son similares dentro de la misma carpeta donde se han agrupado los frames de una grabación. Ilustración 75. Conjunto de imágenes en las cuales todas las identificaciones se realizan correctamente. 75 Similarmente, en la Ilustración 77 se puede ver el cambio en los resultados a modificar el valor umbral, siendo en el primero de los casos igual a 1.2 y en el segundo a 0.9 (valor muy restrictivo). Ilustración 76. Detección para un individuo incluyendo las variaciones del umbral. 76 Ilustración 77. Modificación de resultados variando el umbral de FaceNet. 77 78 7 CONCLUSIONES Y TRABAJO FUTURO Sólo podemos ver poco del futuro, pero lo suficiente para darnos cuenta de que hay mucho que hacer. Alan Turing Como se ha ido comentando a través de los puntos de este documento, las redes neuronales, son un método de gran importancia y utilizada a la hora de resolver distintos problemas, como aquellos vinculados con la visión por computador. En este caso, nos hemos centrado en aquellos ocasionados por la detección e identificación de rostros. Para el primero de ellos, en la actualidad existen multitud de soluciones, muchas de las cuales ofrecen resultados realmente buenos. Un ejemplo es la red neuronal MTCNN¸ la cual se trata en este proyecto. Los resultados que se han obtenido, desde el punto de vista del rendimiento, difieren bastante en función del dataset que sea usado, pasando de un 84.4% cuando se utiliza YouTube Face Database, a un 46.4%, cuando se utiliza GRAZ-01. De esto se puede inferir que aspectos como la calidad de la imagen, el tamaño del rostro dentro de la misma, posibles oclusiones y una posición no frontal pueden afectar considerablemente. Además, de esta red neuronal, se ha utilizado un detector perteneciente a la librería DLIB que utiliza como características las dadas por HOG y como clasificador SVM. El efecto encontrado al probarlo con ambos datasets era similar al visto con MTCNN, con la diferencia de que el porcentaje de clasificaciones correctas era sustancialmente peor (60.7%-16.6%). Para el segundo problema las soluciones encontradas son inferiores, aunque es un campo que en la actualidad está creciendo mucho. En este proyecto se ha utilizado la red neuronal FaceNet, que nos da un vector de 128 características con el que poder, mediante la distancia euclidea, comparar rostros. La solución ofrecida por esta tiene acoplados los problemas anteriormente mencionados para MTCNN, añadiendo además aspectos relativos a cambios de expresión, que pueden llegar a mover las características, maquillaje… Además, aunque para conjuntos de datos pequeños los resultados que se adquieren son buenos, a medida que el número de clases (rostros modelo) aumenta estos empiezan a empeorar, llegándose a identificar erróneamente a los individuos en un elevado número de casos. Como se ha comentado en el apartado 5.2, existe una gran dependencia entre el resultado obtenido y la imagen modelo escogida, siendo peor cuando esta no representa adecuadamente al individuo. Este es uno de los motivos que explica que haya tanta diferencia entre distintas pruebas realizadas 79 con FaceNet. Se tiene también que comentar que la dependencia que tiene con la correcta identificación y alineación de los rostros en la imagen conlleva a que el error que pueda tener esta tarea sea sumando al ocasionado por la red neuronal FaceNet. Como líneas futuras, será conveniente probar otro tipo de identificadores, como pueden ser los ofrecidos por DLib, junto con otro tipo de detector de rostros basado en redes neuronales, o por OpenCV, basado en Eigenfaces, Fisherfaces y Local Binary Patterns Histograms (LBP). Estos no han sido utilizados en primer lugar porque, según me he documentado, presentaban peores resultados y tiempos de ejecución. Además, otra tarea futura es la de realizar distintas pruebas sobre otros bancos de imágenes, con un número mayor de estas y rostros que no se encunetren en situaciones tan cercanas, es decir, que no estén directamente sacados de un video, para llegar a una mejor conclusión en lo referido a FaceNet. Finalmente, será de especial interés añadir información corporal, no solo dejando la identificación de una persona ligada tan solo a posibles características que tenga el rostro. 80 81 REFERENCIAS [1] “Alibaba debuts ‘smile to pay’ facial recognition payments at KFC in China – TechCrunch,” [Online]. Available: https://techcrunch.com/2017/09/03/alibaba-debuts-smile-to- pay/?guccounter=1&guce_referrer_us=aHR0cHM6Ly9lcy53aWtpcGVkaWEub3JnLw&guce_referrer_ cs=BXFu9xx1J6EEzgdNKueQVg. [2] P. Viola, M. Jones and others, “Rapid object detection using a boosted cascade of simple features,” CVPR (1), vol. 1, no. 3, pp. 511-518, 2001. [3] R. Schapire and Y. Freund, “A decision-theoretic generalization of on-line learning and an application to boosting,” in Second European Conference on Computational Learning Theory, 1995, pp. 23 -- 37. [4] T. Ahonen, A. Hadid and M. Pietik{\"a}inen, “Face recognition with local binary patterns,” in European conference on computer vision, 2004, pp. 469--481. [5] I. Kukenys and B. McCane, “Support vector machines for human face detection,” in Proceedings of the New Zealand computer science research student conference, Citeseer, 2008, pp. 226--229. [6] X. Wang, T. X. Han and S. Yan, “An HOG-LBP human detector with partial occlusion handling,” in 2009 IEEE 12th international conference on computer vision, IEEE, 2009, pp. 32--39. [7] J. a. Z. G. Xiang, “Joint Face Detection and Facial Expression Recognition with MTCNN,” in 2017 4th International Conference on Information Science and Control Engineering (ICISCE), 2017, pp. 424--427. [8] T. Matthew and P. Alex, “Eigenfaces for recognition,” Journal of cognitive neuroscience, vol. 3, no. 1, pp. 71--86, 1991. [9] P. N. Belhumeur, J. P. Hespanha and D. J. Kriegman, “Eigenfaces vs. fisherfaces: Recognition using class specific linear projection,” IEEE Transactions on Pattern Analysis \& Machine Intelligence, no. 7, pp. 711--720, 1997. [10] N. a. T. B. Dalal, “Histograms of oriented gradients for human detection,” 2005. [11] T. a. P. M. a. H. D. Ojala, “Performance evaluation of texture measures with classification based on Kullback discrimination of distributions,” in Proceedings of 12th International Conference on Pattern Recognition, IEEE, 1994, pp. 582--585.