Reconocimiento facial con InterSystems Vector Search y DeepFace

El reconocimiento facial se ha convertido en el método más popular para validar la identidad de las personas, permitiendo así el acceso a sistemas, la confirmación de datos personales y documentales, y la aprobación de acciones y documentos.

Los desafíos están relacionados con el rendimiento cuando la base de datos es muy grande, la precisión y, especialmente, la privacidad de los datos biométricos faciales. Para afrontar estos retos, nada mejor que utilizar InterSystems Vector Search, ya que permite:

1. Realizar búsquedas vectoriales en millones de registros con respuestas mucho más rápidas que los métodos tradicionales.
2. Los modelos vectoriales y matemáticos utilizados por Vector Search ofrecen una alta precisión sin sacrificar el rendimiento.
3. No es necesario almacenar las imágenes de los rostros, sino únicamente los embeddings de las imágenes, lo que hace imposible la ingeniería inversa. Esto permite cumplir plenamente con el RGPD, la LGPD y otras normativas de privacidad de datos personales.

Este artículo detalla paso a paso el proceso de recopilación, procesamiento, almacenamiento y realización de búsquedas vectoriales de rostros. Se utiliza DeepFace, una biblioteca de Python muy popular para procesar rostros humanos y transformarlos en embeddings, junto con InterSystems IRIS Vector Search para realizar comparaciones vectoriales sobre los embeddings almacenados, permitiendo el reconocimiento facial en tiempo casi real.

Instalación y uso de la solución

Sigue estos pasos para instalar face-recognition (una solución de código abierto basada en DeepFace e IRIS):

1. Clona o ejecuta git pull del repositorio en cualquier directorio local.

2. $ git clone https://github.com/yurimarx/facial-matching.git
   $ cd facial-matching
   $ docker-compose build
   $ docker-compose up -d

   Nota: el paso docker-compose build requiere bastante tiempo, ya que en esta fase se descargan los modelos de DeepFace.

3. Abre la aplicación en http://localhost:8501.
4. Registra algunas personas (selecciona Cámara y Take Photo para capturar tu imagen con la cámara de tu PC o sube archivos. Haz clic en Finalize Registration para guardar a la persona en la base de datos de IRIS y en Reset form para limpiar el formulario y volver a utilizarlo):
5. 

4. Busca personas utilizando una foto o tu cámara para encontrar personas ya registradas (usa la pestaña Search/Verify):

4. Consulta todas las personas registradas en la pestaña Registered List:

Detalles sobre la implementación

1. Tabla vectorial para almacenar los embeddings:

2. Class dc.facialmatching.FacialData Extends (%Persistent, %JSON.Adaptor)
   {
   
   Property FaceVector As %Vector(%JSONINCLUDE = "none", DATATYPE = "float", LEN = 4096);
   
   Property Name As %String(MAXLEN = 100);
   
   Property Age As %Integer;
   
   Property Gender As %String;
   
   Property Ethnicity As %String;
   
   Property SSN As %String;

   La propiedad FaceVector As %Vector(%JSONINCLUDE = "none", DATATYPE = "float", LEN = 4096) permite definir el tipo de datos y la longitud del vector de embeddings. Cada modelo puede tener diferentes tipos de datos y longitudes.

3. Para transformar y guardar la imagen como un vector embebido:

4. def register():
       try:
           ssn = request.form.get('ssn')
           name = request.form.get('name')
           
           if 'image' not in request.files:
               return jsonify({"error": "Nenhum arquivo de imagem enviado"}), 400
           
           file = request.files['image']
           
           filestr = file.read()
           nparr = np.frombuffer(filestr, np.uint8)
           img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
   
           objs = DeepFace.represent(img, model_name="VGG-Face", enforce_detection=True)
           embedding = objs[0]["embedding"]
           analysis = DeepFace.analyze(img, actions=['age', 'gender', 'race'], enforce_detection=False)[0]
   
           conn = get_iris_connection()
           cursor = conn.cursor()
           
           sql = """
               INSERT INTO dc_facialmatching.FacialData 
               (SSN, Name, Age, Gender, Ethnicity, FaceVector) 
               VALUES (?, ?, ?, ?, ?, TO_VECTOR(?))
           """
           cursor.execute(sql, (
               ssn, name, int(analysis['age']), 
               analysis['dominant_gender'], analysis['dominant_race'], 
               json.dumps(embedding)
           ))
           conn.commit()
           cursor.close()
           conn.close()

5. La función DeepFace.represent(img, model_name="VGG-Face", enforce_detection=True) transforma la imagen del rostro en un vector de embeddings.
6. Para insertar el embedding en IRIS se utiliza TO_VECTOR:

7. INSERT INTO dc_facialmatching.FacialData (SSN, Name, Age, Gender, Ethnicity, FaceVector) VALUES (?, ?, ?, ?, ?, TO_VECTOR(?))

8. Para realizar una coincidencia facial, debes hacer una búsqueda vectorial:

9. 		objs = DeepFace.represent(img, model_name="VGG-Face", enforce_detection=True)
           current_vector = objs[0]["embedding"]
           
           conn = get_iris_connection()
           cursor = conn.cursor()
           
           sql = """
               SELECT TOP 1 SSN, Name, Age, Gender, Ethnicity,
                      VECTOR_DOT_PRODUCT(FaceVector, TO_VECTOR(?)) as similarity
               FROM dc_facialmatching.FacialData
               ORDER BY similarity DESC
           """
           cursor.execute(sql, (json.dumps(current_vector),))
           row = cursor.fetchone()

10. Obtén el embedding usando DeepFace.represent y utilízalo en la consulta SELECT VECTOR_DOT_PRODUCT(FaceVector, TO_VECTOR(?)).
11. ¡Disfruta de esta solución!