Machine Learning Diaries I, Computer Vision

Desde la última vez que asistí a una charla sobre machine learning (impartida por Paige Bailey), mi curiosidad por este campo ha crecido haciéndome investigar sobre las diferentes aplicaciones que se le pueden dar. Encontré un curso que me pareció bastante interesante: en él se hace una pequeña introducción a deep learning y una gran cobertura del tema en el aspecto teórico, además de explicar con ejemplos como funciona TensorFlow (el framework de Google de deep learning y machine learning). Después de algunas conversaciones con algunos compañeros de Solid GEAR Projects, empecé un pequeño sistema de reconocimiento facial que combina machine learning y computer vision para empezar a trastear por mí mismo.

Los lenguajes de programación más usados en proyectos de este tipo son R y Python, y dada mi experiencia en Python, la facilidad de escritura del código (que hace que me pueda centrar en los algoritmos y poder cambiarlos rápidamente), y la facilidad para poder conectar este proyecto a una API pública que podría crearse rápidamente con alguno de los múltiples frameworks que ofrece Python (Django, Flask, etc.), me hicieron decidirme por Python.

Flujo de un sistema de machine learning

Lo primero que hay que saber es qué flujo sigue el sistema para reconocer una cara (en este post sólo vamos a tratar la primera parte, que comprende desde conseguir las imágenes hasta el preprocesado de las mismas para que sean comprensibles para el sistema de machine learning):

  1. Conseguir las imágenes (pueden ser de internet o recibir datos desde una cámara, en este caso veremos cómo recibir datos desde la cámara).
  2. Detectar las caras dentro de la imagen (sólo nos quedaremos con la más grande).
  3. Encuadrar la cara y detectar los puntos de referencia (son 68 que representan las facciones de la cara).
  4. Rectificar la posición de la cara en la foto para que las facciones coincidan con las de los puntos de referencia.

Con esto ya tendríamos las imágenes listas para que el sistema sea entrenado.

Así que vamos a ello: vamos a utilizar una biblioteca de Python llamada OpenCV que nos ayudará a obtener imágenes de la cámara, y la biblioteca Dlib para procesarlas y hacer los cambios necesarios para corregir la posición y el tamaño de la cara, también necesitarás el fichero .dat que contiene los 68 puntos que representan las facciones, puedes encontrarlo aquí.

import cv2
import sys
import time
import dlib
import openface


def main():
    """Method executed when the script is launched."""
    
    # This will allow the script to capture video from the camera.
    cam_output = cv2.VideoCapture()

    # We are going to let the camera warmup (the first 2/3 seconds there will not be image output)
    time.sleep(3000)
    
    # Start reading from the camera
    while True:
        success, image = cam_output.read()
    
        # At this point we already have the image, so we can start processing it,
        # So we may start getting the face.
        aligned_face = get_face_in_image_aligned(image)

        # Now that we have the cropped image, we may want to save it.
        if aligned_face is not None:
            cv2.imwrite('path/where/images/are/saved', 'image_name')

        # Press esc to finish reading from camera.
        if cv2.waitKey(1) == 27: 
           break

def get_face_in_image_aligned(image):
   """
   Gets the face in the image and aligns the image to focus that face.

   :param image: The image where the face will be found.
   
   :return: An image focusing the face, None if no face is detected.
   """
   
   face_detector = dlib.get_frontal_face_detector()
   predictor = dlib.shape_predictor('path/to/shape_predictor_68_face_landmarks.dat')
   face_aligner = openface.AlignDlib('path/to/shape_predictor_68_face_landmarks.dat') 
   
   try:
       # We are doing it this way because there may be more than one face and we only need one 
       detected_face_rect = enumerate(face_detector(image, 1)).next()[1]

       # Detect facial landmarks with the helping of the .dat file downloaded. 
       detected_face_landmarks = predictor(image, detected_face_rect)       

       # Align the face, also helped by the .dat file.
       aligned_face = face_aligner.align(
           534, # image size in pixels
           image,
           detected_face_rect, landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE
       )
   except:
       return None

if __name__ == '__main__':
    main()
    sys.exit(0)

En el próximo post explicaré cómo entrenar al modelo y hacer que empiece a reconocer las caras.

Otros artículos interesantes

11 de Febrero: Día Internacional de la Mujer y la Niña en la Ciencia

PWA: La nueva generación de aplicaciones web

Integrando DialogFlow en Android. Creamos nuestro primer ChatBot.

Deja un comentario

Responsable » Solidgear.
Finalidad » Gestionar los comentarios.
Legitimación » Tu consentimiento.
Destinatarios » Los datos que me facilitas estarán ubicados en los servidores SolidgearGroup dentro de la UE.
Derechos » Podrás ejercer tus derechos, entre otros, a acceder, rectificar, limitar y suprimir tus datos.

By completing the form you agree to the Privacy Policy

This site uses Akismet to reduce spam. Learn how your comment data is processed.