Creación de una canalización de reconocimiento facial con aprendizaje profundo en Tensorflow

En mi último tutorial , aprendiste sobre las redes neuronales convolucionales y la teoría detrás de ellas. En este tutorial, aprenderá a usar una red neuronal convolucional para realizar el reconocimiento facial con Tensorflow, Dlib y Docker.

Visión general

• Introducción al reconocimiento facial
• Preprocesamiento de imágenes mediante detección y alineación facial
• Generación de incrustaciones faciales en Tensorflow
• Entrenamiento de un clasificador SVM

requisitos previos

• Comprensión básica de álgebra lineal
• Comprensión básica de las redes neuronales convolucionales
• Comprensión básica de Tensorflow

Introducción a los Sistemas de Reconocimiento Facial

El reconocimiento facial es una solución biométrica que mide las características únicas de la cara. Las aplicaciones disponibles en la actualidad incluyen el registro de vuelos , el etiquetado de amigos y familiares en las fotos y la publicidad "a la medida".

Para realizar el reconocimiento facial, necesitará una forma de representar un rostro de forma única. En 1960, Woodrow Bledsoe utilizó una técnica que consistía en marcar las coordenadas de los rasgos prominentes de un rostro. Entre estas características estaban la ubicación de la línea del cabello, los ojos y la nariz.

En 2015, los investigadores de Google publicaron un artículo, FaceNet , que utiliza una red neuronal convolucional que se basa en los píxeles de la imagen como características, en lugar de extraerlos manualmente. Logró un nuevo récord de precisión del 99,63 % en el conjunto de datos LFW .

FaceNet: en el artículo de FaceNet, se propone una arquitectura de red neuronal convolucional. Para una función de pérdida, FaceNet usa "pérdida de triplete". La pérdida de triplete se basa en minimizar la distancia de los ejemplos positivos, mientras se maximiza la distancia de los ejemplos negativos.

Ecuación de pérdida de triplete

Pérdida de triplete Aprendizaje

Conceptualmente, esto tiene sentido. Los rostros de la misma identidad deben aparecer más cerca entre sí que los rostros de otra identidad.

Incrustaciones de vectores: para este tutorial, lo importante del papel es la idea de representar una cara como una incrustación de 128 dimensiones. Una incrustación es el nombre colectivo para mapear entidades de entrada a vectores. En un sistema de reconocimiento facial, estas entradas son imágenes que contienen la cara de un sujeto, asignadas a una representación vectorial numérica.

Asignación de entrada a la fuente de incrustación

Dado que estas incrustaciones de vectores se representan en un espacio vectorial compartido, la distancia vectorial se puede utilizar para calcular la similitud entre dos vectores. En un contexto de reconocimiento facial, esta distancia vectorial se puede aplicar para calcular qué tan similares son dos caras. Además, estas incrustaciones se pueden usar como entradas de características en una tarea de clasificación, agrupación en clústeres o regresión.

Ejemplo de trazado de incrustaciones en un espacio vectorial 3D

Preprocesamiento de datos con Dlib y Docker

# Estructura del proyecto

├── Dockerfile├─ Etc│ ├── 20170511–185253│ │ ├── 20170511–185253.pb├iqu. Data├── Medium_facenet_tutorial│ ├─ija align_dlib.py│ ├─ descargar_and_extract_model.py│ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ─ __init__.py│ ├── lfw_input.py│ ├── preprocess.py│ ├── shape_predictor_68_face_landmarks.dat│ └── train_classifier.py├── requisitos.txt

Preparación de los datos

Utilizará el conjunto de datos LFW (Labeled Faces in the Wild) como datos de entrenamiento. El directorio está estructurado como se ve a continuación. Puede reemplazar esto con su conjunto de datos siguiendo la misma estructura.

# Descargar conjunto de datos lfw$ curl -O http://vis-www.cs.umass.edu/lfw/lfw.tgz # 177MB$ tar -xzvf lfw.tgz

# Estructura de directorio# ├── Tyra_Banks# │ ├── Tyra_Banks_0001.jpg# │ └── Tyra_banks_0002.jpg# ├── Tyron_garner# │ │ ├─ige_garner_0001.jpg# │ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ └ │ ├ ├ │ │ ├ ├ ├ ├ ├## └ └ └ └ └ └ └ └ │ │ │ │ │ │ │ ├ ├ ├ de.

preprocesamiento

A continuación, preprocesará las imágenes antes de pasarlas al modelo de FaceNet. El preprocesamiento de imágenes en un contexto de reconocimiento facial suele resolver algunos problemas. Estos problemas van desde diferencias de iluminación, oclusión, alineación, segmentación. A continuación, abordará la segmentación y la alineación.

Primero, resolverá el problema de segmentación encontrando la cara más grande en una imagen. Esto es útil ya que nuestros datos de entrenamiento no tienen que recortarse para una cara antes de tiempo.

En segundo lugar, resolverá la alineación. En las fotografías, es común que una cara no esté perfectamente alineada en el centro de la imagen. Para estandarizar la entrada, aplicará una transformación para centrar todas las imágenes en función de la ubicación de los ojos y el labio inferior.

Segmentar, alinear y recortar

Configuración del entorno

Aquí, usará la ventana acoplable para instalar tensorflow, opencv y Dlib. Dlib proporciona una biblioteca que se puede utilizar para la detección y alineación facial. Estas bibliotecas pueden ser un poco difíciles de instalar, por lo que usará Docker para la instalación.

Docker es una plataforma de contenedores que simplifica la implementación. Resuelve el problema de instalar dependencias de software en diferentes entornos de servidor. Si es nuevo en Docker, puede leer más aquí . Para instalar Docker, ejecute

rizo https://get.docker.com | sh

Después de instalar Docker, creará dos archivos. Un requirements.txt para las dependencias de python y un Dockerfile para crear su entorno docker.

Para construir esta imagen, ejecute:

$ docker build -t colemurray/medium-facenet-tutorial -f Dockerfile .

# Esto puede demorar varios minutos dependiendo de su hardware # En MBP, ~ 25 minutos # La imagen se puede extraer de dockerhub a continuación

Si desea evitar compilar desde la fuente, la imagen se puede extraer de dockerhub usando:

docker pull colemurray/medium-facenet-tutorial # Recomendado

# Puede encontrar un entorno compatible con GPU aquí# nvidia-docker pull colemurray/medium-facenet-tutorial:latest-gpu

Detectar, recortar y alinear con Dlib

Después de crear su entorno, puede comenzar el preprocesamiento.

Primero descargue el predictor de hitos faciales de dlib.

$ curl -O http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2 $ bzip2 -d shape_predictor_68_face_landmarks.dat.bz2

Utilizará este predictor de puntos de referencia faciales para encontrar la ubicación de los ojos internos y los labios inferiores de una cara en una imagen. Estas coordenadas se utilizarán para centrar la imagen.

Este archivo, procedente de CMU, proporciona métodos para detectar un rostro en una imagen, encontrar puntos de referencia faciales y alinear dichos puntos de referencia.

A continuación, creará un preprocesador para su conjunto de datos. Este archivo leerá cada imagen en la memoria, intentará encontrar la cara más grande, la alineará al centro y escribirá el archivo en la salida. Si no se puede encontrar una cara en la imagen, se mostrará el registro en la consola con el nombre del archivo.

Como cada imagen se puede procesar de forma independiente, el multiprocesamiento de Python se utiliza para procesar una imagen en cada núcleo de CPU disponible.

Obtener resultados

Ahora que ha creado una canalización, es hora de obtener resultados. Como la secuencia de comandos admite el paralelismo, verá un mayor rendimiento al ejecutarse con varios núcleos. Deberá ejecutar el preprocesador en el entorno de la ventana acoplable para tener acceso a las bibliotecas instaladas.

A continuación, montará el directorio de su proyecto como un volumen dentro del contenedor acoplable y ejecutará el script de preprocesamiento en sus datos de entrada. Los resultados se escribirán en un directorio especificado con argumentos de línea de comandos.

$ docker run -v $PWD:/tutorial-facenet-media \-e PYTHONPATH=$PYTHONPATH:/tutorial-facenet-media \-it colemurray/tutorial-facenet-media python3 /tutorial-facenet-media/tutorial_facenet_media/preprocess. py \--input-dir /medium-facenet-tutorial/ data \--output-dir /medium-facenet-tutorial/output/intermediate \--crop-dim 180

El código hasta este punto se puede encontrar aquí

Revisar

Usando Dlib, detectó la cara más grande en una imagen y alineó el centro de la cara con los ojos internos y el labio inferior. Esta alineación es un método para estandarizar cada imagen para su uso como entrada de funciones.

Crear incrustaciones en Tensorflow

Ahora que ha preprocesado los datos, generará incrustaciones vectoriales de cada identidad. Estas incrustaciones se pueden usar como entrada para una tarea de clasificación, regresión o agrupación.

Descargar Pesos

Utilizará Inception Resnet V1 como su red neuronal convolucional. Primero, cree un archivo para descargar los pesos al modelo.

Mediante el uso de pesos previamente entrenados, puede aplicar el aprendizaje de transferencia a un nuevo conjunto de datos, en este tutorial, el conjunto de datos LFW:

$ docker run -v $PWD:/tutorial-de-facenet-medio \-e PYTHONPATH=$PYTHONPATH:/tutorial-de-facenet-medio \-it colemurray/tutorial-de-facenet-medio python3 /tutorial-de-facenet-medio/tutorial_de_facenet_medio/descargar_y_extraer_modelo. py \--model-dir /medium-facenet-tutorial/etc

Cargar incrustaciones

A continuación, utilizará la API de cola de Tensorflow para cargar las imágenes preprocesadas en paralelo. Mediante el uso de colas, las imágenes se pueden cargar en paralelo utilizando subprocesos múltiples. Cuando se usa una GPU, esto permite que el preprocesamiento de imágenes se realice en la CPU, mientras que la multiplicación de matrices se realiza en la GPU.

Entrenar a un Clasificador

Con la cola de entrada al cuadrado, pasará a crear las incrustaciones.

Primero, cargará las imágenes de la cola que creó. Mientras entrena, aplicará preprocesamiento a la imagen. Este preprocesamiento agregará transformaciones aleatorias a la imagen, creando más imágenes para entrenar.

Estas imágenes se alimentarán en un tamaño de lote de 128 en el modelo. Este modelo devolverá una incrustación de 128 dimensiones para cada imagen y una matriz de 128 x 128 para cada lote.

Después de crear estas incrustaciones, las usará como entradas de funciones en un clasificador SVM de scikit-learn para entrenar en cada identidad. Las identidades con menos de 10 imágenes se eliminarán. Este parámetro se puede ajustar desde la línea de comandos.

$ docker run -v $PWD:/tutorial-de-facenet-medio \-e PYTHONPATH=$PYTHONPATH:/tutorial-de-facenet-medio \-it colemurray/tutorial-de-facenet-medio \python3 /tutorial-de-facenet-medio/tutorial_de_facenet_medio/train_classifier .py \--input-dir /medium-facenet-tutorial/output/intermediate \--model-path /medium-facenet-tutorial/etc/20170511-185253/20170511-185253.pb \--classifier-path /medium -facenet-tutorial/output/classifier.pkl \--num-threads 16 \--num-epochs 25 \--min-num-images-per-class 10 \--is-train

# ~16 minutos para completar en MBP

Evaluación de los resultados

Ahora que ha entrenado al clasificador, lo alimentará con nuevas imágenes en las que no se ha entrenado. Eliminará la marca is_train del comando anterior para evaluar sus resultados.

docker run -v $PWD:/$(nombre base $PWD) \-e PYTHONPATH=$PYTHONPATH:/tutorial-facenet-medio \-it colemurray/tutorial-facenet-medio \python3 /tutorial-facenet-medio/tutorial_facenet_medio/clasificador_tren .py \--input-dir /medium-facenet-tutorial/output/intermediate \--model-path /medium-facenet-tutorial/etc/20170511-185253/20170511-185253.pb \--classifier-path /medium -facenet-tutorial/output/classifier.pkl \--num-threads 16 \--num-epochs 5 \--min-num-images-per-class 10

Después de completar la inferencia en cada imagen, verá los resultados impresos en la consola. En 5 épocas, verá una precisión de ~85,0 %. El entrenamiento @ 25 épocas dio resultados:

90,8% @ 25 épocas

Conclusión

En este tutorial, aprendió sobre la historia del aprendizaje automático y cómo implementar una canalización de última generación. Utilizaste Docker para administrar las dependencias de tu biblioteca, ofreciendo un entorno consistente que es independiente de la plataforma. Usaste Dlib para el preprocesamiento y Tensorflow + Scikit-learn para entrenar un clasificador capaz de predecir una identidad basada en una imagen.

Código completo aquí:

ColeMurray/medium-facenet-tutorial _medium-facenet-tutorial - Canalización de reconocimiento facial usando Dlib y Tensorflow_github.com

Próximos pasos:

• ¡Prueba en tu propio conjunto de datos!
• Experimente con diferentes hiperparámetros
• Entrena en otras etiquetas como el género o la edad.
• Implementar un algoritmo de agrupamiento para agrupar rostros similares

Llamada a la acción:

Si disfrutaste este tutorial, ¡síguelo y recomiéndalo!

¿Está interesado en obtener más información sobre el aprendizaje profundo/aprendizaje automático? Mira mis otros tutoriales:

- Deep Learning CNN's en Tensorflow con GPU

- Aprendizaje profundo con Keras en Google Compute Engine

- Sistemas de recomendación con Apache Spark en Google Compute Engine

Otros lugares donde me puedes encontrar:

-Twitter: https://twitter.com/_ColeMurray