facetorch

¿Aplicar la aplicación de demostración de espacio para la cara?

Demo de cuaderno de Google Colab

Guía del usuario, documentación, Guía de Facetorch de ChatGPT

Docker Hub (GPU)

Facetorch es una biblioteca de Python diseñada para la detección y análisis faciales, aprovechando el poder de las redes neuronales profundas. Su objetivo principal es curar modelos de análisis facial de código abierto de la comunidad, optimizarlos para un alto rendimiento usando Torchscript e integrarlos en un conjunto de herramientas de análisis de análisis versátil. La biblioteca ofrece las siguientes características clave:

1. Configuración personalizable: configure fácilmente su configuración con Hydra y sus potentes capacidades Omegaconf.

2. Entornos reproducibles: garantizar la reproducibilidad con herramientas como Conda-Lock para la gestión de dependencias y Docker para la contenedorización.

3. Rendimiento acelerado: disfrute de un rendimiento mejorado tanto en CPU como en GPU con optimización de Torchscript.

4. Extensibilidad simple: extienda la biblioteca cargando su archivo de modelo a Google Drive y agregando un archivo YAML de configuración correspondiente al repositorio.

Facetorch proporciona una solución eficiente, escalable y fácil de usar para tareas de análisis facial, que atiende a desarrolladores e investigadores que buscan flexibilidad y rendimiento.

Utilice esta biblioteca de manera responsable y con precaución. Adherirse a las pautas de ética de la Comisión Europea para la IA confiable para garantizar el uso ético y justo. Tenga en cuenta que los modelos pueden tener limitaciones y sesgos potenciales, por lo que es crucial evaluar sus resultados críticamente y considerar su impacto.

Instalar

Pypi

pip install facetorch

Condición

conda install -c conda-forge facetorch

Uso

Requisitos previos

• Estibador
• Docker componer

Docker Compose proporciona una manera fácil de construir un entorno facial en funcionamiento con un solo comando.

Ejemplo de Docker de ejecución

• CPU: docker compose run facetorch python ./scripts/example.py
• GPU: docker compose run facetorch-gpu python ./scripts/example.py analyzer.device=cuda

Verifique los datos/salida para obtener imágenes resultantes con cuadros delimitadores y puntos de referencia 3D faciales.

(Apple Mac M1) Use el emulador Rosetta 2 en Docker Desktop para ejecutar la versión de CPU.

Configurar

El proyecto está configurado por archivos ubicados en conf con el archivo principal: conf/config.yaml . Se puede agregar o eliminar fácilmente módulos de la configuración.

Componentes

FaceAnalyzer es la clase principal de facetorch, ya que es el orquestador responsable de inicializar y ejecutar los siguientes componentes:

1. Lector: lee la imagen y devuelve un objeto imagedata que contiene el tensor de imagen.
2. Detector: envoltura alrededor de una red neuronal que detecta caras.
3. Unifier: procesador que unifica los tamaños de todas las caras y los normaliza entre 0 y 1.
4. Predictor Dict: conjunto de envoltorios alrededor de las redes neuronales capacitadas para analizar las características faciales.
5. Utilizador DICT: conjunto de envoltorios alrededor de cualquier funcionalidad que requiera la salida de redes neuronales, por ejemplo, dibujando cajas limitadas o puntos de referencia facial.

Estructura

 analyzer
    ├── reader
    ├── detector
    ├── unifier
    └── predictor
            ├── embed
            ├── verify
            ├── fer
            ├── au
            ├── va
            ├── deepfake
            └── align
    └── utilizer
            ├── align
            ├── draw
            └── save

Modelos

Detector

 |     model     |   source  |   params  |   license   | version |
| ------------- | --------- | --------- | ----------- | ------- |
|   RetinaFace  |  biubug6  |   27.3M   | MIT license |    1    |

1. biubug6
   • Código: pytorch_retinaface
   • Documento: Deng et al. -Retinaface: localización de cara de nivel múltiple de un solo disparo en la naturaleza

Vaticinador

Aprendizaje de representación facial (inserción)

 |       model       |   source   |  params |   license   | version |  
| ----------------- | ---------- | ------- | ----------- | ------- |
|  ResNet-50 VGG 1M |  1adrianb  |  28.4M  | MIT license |    1    |

1. 1adrianb
   • Código: Representación sin supervisión de cara
   • Documento: Bulat et al. - Estrategias y conjuntos de datos previos a la capacitación para el aprendizaje de la representación facial
   • NOTA: include_tensors debe ser verdad para incluir la predicción del modelo en predicción. Logits

Verificación de la cara (verificar)

 |       model      |   source    |  params  |      license       | version |  
| ---------------- | ----------- | -------- | ------------------ | ------- |
|    MagFace+UNPG  | Jung-Jun-Uk |   65.2M  | Apache License 2.0 |    1    |
|  AdaFaceR100W12M |  mk-minchul |    -     |     MIT License    |    2    |

1. Jung-jun-uk
   • Código: UNPG
   • Documento: Jung et al. - Generación de pares negativos unificados hacia un espacio de características bien discriminatoria para el reconocimiento facial
   • (Lejos = 0.01)
   • NOTA: include_tensors debe ser verdad para incluir la predicción del modelo en predicción. Logits
2. MK-MINCHUL
   • Código: Adaface
   • Documento: Kim et al. - Adaface: margen adaptativo de calidad para el reconocimiento facial
   • <
   • <
   • <Las insignias representan modelos capacitados en un conjunto de datos 4M de Face Webface más pequeño
   • NOTA: include_tensors debe ser verdad para incluir la predicción del modelo en predicción. Logits

Reconocimiento de la expresión facial (FER)

 |       model       |      source    |  params  |       license      | version |  
| ----------------- | -------------- | -------- | ------------------ | ------- |
| EfficientNet B0 7 | HSE-asavchenko |    4M    | Apache License 2.0 |    1    |
| EfficientNet B2 8 | HSE-asavchenko |   7.7M   | Apache License 2.0 |    2    |

1. Hse-asavchenko
   • Código: reconocimiento de la emoción
   • Documento: Savchenko - Expresión facial y reconocimiento de atributos basado en el aprendizaje de varias tareas de las redes neuronales livianas
   • B2
   • B0
   • B0

Detección de la unidad de acción facial (AU)

 |        model        |   source  |  params |       license      | version |  
| ------------------- | --------- | ------- | ------------------ | ------- |
| OpenGraph Swin Base |  CVI-SZU  |   94M   |     MIT License    |    1    |

1. Cvi-szu
   • Código: Me-Graphau
   • Documento: Luo et al. -Aprendizaje del gráfico de relación de AU basado en características de borde multidimensional para el reconocimiento de la unidad de acción facial
   • ! No funciona con CUDA> 12.0

Excitación de valencia facial (VA)

 |       model       |   source   |  params |   license   | version |
| ----------------- | ---------- | ------- | ----------- | ------- |
|  ELIM AL AlexNet  | kdhht2334  |  2.3M   | MIT license |    1    |

1. KDHHT2334
   • Código: Elim
   • Documento: Kim et al. -Cocación de identidad óptima basada en el transporte para el reconocimiento de la expresión facial invariante de identidad

Detección de Deepfake (Deepfake)

 |         model        |      source      |  params  |   license   | version |
| -------------------- | ---------------- | -------- | ----------- | ------- |
|    EfficientNet B7   |     selimsef     |   66.4M  | MIT license |    1    |

1. selimsef
   • Código: dfdc_deepfake_challenge
   • Desafío: Seferbekov - Desafío de detección de Deepfake 1er Solución

Alineación facial (alinearse)

 |       model       |      source      |  params  |   license   | version |
| ----------------- | ---------------- | -------- | ----------- | ------- |
|    MobileNet v2   |     choyingw     |   4.1M   | MIT license |    1    |

1. choyingw
   • Código: Synergynet
   • Desafío: Wu et al. - Synergy entre puntos de referencia 3DMM y 3D para la geometría facial 3D precisa
   • NOTA: include_tensors debe ser verdad para incluir la predicción del modelo en predicción. Logits

Descargar modelo

Los modelos se descargan durante el tiempo de ejecución automáticamente al directorio de modelos . También puede descargar los modelos manualmente desde una carpeta pública de Google Drive.

Tiempo de ejecución

Se analiza la imagen test.jpg (4 caras) (incluidos los cuadros de dibujo y los puntos de referencia, pero no ahorrando) en aproximadamente 486 ms y test3.jpg (25 caras) en aproximadamente 1845 ms (lotese_size = 8) en Nvidia Tesla T4 GPU una vez que la configuración predeterminada ( conf/config. Yaml ) de los modelos se inicia y se calienta a la imagen inicial 108080. Uno puede monitorear los tiempos de ejecución en los registros utilizando el nivel de depuración.

Tests de ejecución de JPG detallado: jpg:

 analyzer
    ├── reader: 27 ms
    ├── detector: 193 ms
    ├── unifier: 1 ms
    └── predictor
            ├── embed: 8 ms
            ├── verify: 58 ms
            ├── fer: 28 ms
            ├── au: 57 ms
            ├── va: 1 ms
            ├── deepfake: 117 ms
            └── align: 5 ms
    └── utilizer
            ├── align: 8 ms
            ├── draw_boxes: 22 ms
            ├── draw_landmarks: 7 ms
            └── save: 298 ms

Desarrollo

Ejecute el contenedor Docker:

• CPU: docker compose -f docker-compose.dev.yml run facetorch-dev
• GPU: docker compose -f docker-compose.dev.yml run facetorch-dev-gpu

Agregar predictor

Requisitos previos

1. Archivo del modelo TorchScript
2. ID del archivo del modelo de Google Drive
3. bifurcado

Facetorch funciona con modelos que se exportaron desde Pytorch a Torchscript. Puede aplicar la función Torch.jit.TRACE para compilar un modelo Pytorch como un módulo TorchScript. Verifique que la salida del modelo trazado sea igual a la salida del modelo original.

Los primeros modelos están alojados en mi carpeta pública de Google Drive. Puede enviarme el nuevo modelo para cargarme, alojar el modelo en su unidad de Google o alojarlo en otro lugar y agregar su propio objeto descargador a la base de código.

Configuración

Crear archivo Yaml

1. Cree una nueva carpeta con un nombre corto de la tarea en el Directorio de configuración de Predictor /conf/analyzer/predictor/ Siguiendo el ejemplo de Fer en /conf/analyzer/predictor/fer/
2. Copie el archivo yaml /conf/analyzer/predictor/fer/efficientnet_b2_8.yaml a la nueva carpeta /conf/analyzer/predictor/<predictor_name>/
3. Cambie el nombre del archivo YAML al modelo que desea usar: /conf/analyzer/predictor/<predictor_name>/<model_name>.yaml

Editar archivo Yaml

1. Cambie la ID de archivo de Google Drive a la ID del modelo.
2. Seleccione el preprocesador (o implemente uno nuevo basado en BasePredPreCrocessor) y especifique sus parámetros, por ejemplo, el tamaño de la imagen y la normalización en el archivo YAML para que coincidan con los requisitos del nuevo modelo.
3. Seleccione el postprocesador (o implementa uno nuevo basado en BasePredPostProcessor) y especifique sus parámetros, por ejemplo, etiquetas, por ejemplo, en el archivo YAML para que coincidan con los requisitos del nuevo modelo.
4. (Opcional) Agregue el derivado de BaseUtilizer que usa la salida de su modelo para realizar algunas acciones adicionales.

Configurar pruebas

1. Agregue un nuevo predictor a los archivos principales config.yaml y todos los tests.config.n.yaml . Alternativamente, cree un nuevo archivo de configuración, por ejemplo, tests.config.n.yaml y agréguelo al archivo /tests/conftest.py .
2. Escriba una prueba para el nuevo predictor en /tests/test_<predictor_name>.py

Prueba y envío

1. Run Linting: black facetorch
2. Agregue el nuevo predictor a la tabla de modelos ReadMe.
3. Actualizar ChangeLog y versión
4. Envíe una solicitud de extracción al repositorio

Actualizar entorno

UPC:

• Agregue los paquetes con las versiones correspondientes a environment.yml File
• Bloquear el entorno: conda lock -p linux-64 -f environment.yml --lockfile conda-lock.yml
• (Alternativo Docker) Bloquear el entorno: docker compose -f docker-compose.dev.yml run facetorch-lock
• Instale el entorno bloqueado: conda-lock install --name env conda-lock.yml

GPU:

• Agregar paquetes con las versiones correspondientes a gpu.environment.yml File
• Bloquear el entorno: conda lock -p linux-64 -f gpu.environment.yml --lockfile gpu.conda-lock.yml
• (Alternativa Docker) Bloquear el entorno: docker compose -f docker-compose.dev.yml run facetorch-lock-gpu
• Instale el entorno bloqueado: conda-lock install --name env gpu.conda-lock.yml

Ejecutar pruebas + cobertura

• Ejecutar pruebas y generar cobertura: pytest tests --verbose --cov-report html:coverage --cov facetorch

Generar documentación

• Genere documentación a partir de documentos utilizando PDOC3: pdoc --html facetorch --output-dir docs --force --template-dir pdoc/templates/

Perfil

1. Ejecutar el perfil del script de ejemplo: python -m cProfile -o profiling/example.prof scripts/example.py
2. Abra el archivo de perfil en el navegador: snakeviz profiling/example.prof

La investigación destaca para aprovechar facetorch

Sharma et al. (2024)

Sharma, Paritosh, Camille Challant y Michael Filhol. "Expresiones faciales para la síntesis del lenguaje de señas utilizando FacShuman y Azee". Actas del taller del 11º Color LREC 2024 sobre la representación y procesamiento de los idiomas de signos , pp. 354–360, 2024.

Liang et al. (2023)

Liang, Cong, Jiahe Wang, Haofan Zhang, Bing Tang, Junshan Huang, Shangfei Wang y Xiaoping Chen. "Unifarn: transformador unificado para la generación de reacción facial". Actas de la 31ª Conferencia Internacional de ACM sobre Multimedia , pp. 9506–9510, 2023.

Gue et al. (2023)

Gue, Jia Xuan, Chun Yong Chong y Mei Kuan Lim. "Reconocimiento de la expresión facial como marcadores de depresión". 2023 Asia Asia de la Asociación de Signal and Information Processing Association Anual Summit (Apsipa ASC) , pp. 674–680, 2023.

Expresiones de gratitud

Me gustaría agradecer a la comunidad de código abierto y a los investigadores que han compartido su trabajo y modelos publicados. Este proyecto no hubiera sido posible sin sus contribuciones.

Citando

Si usa facetorch en su trabajo, asegúrese de acreditar adecuadamente a los autores originales de los modelos que emplea. Además, puede considerar citar la biblioteca Facetorch. A continuación se muestra una cita de ejemplo para facetorch:

 @misc{facetorch,
    author = {Gajarsky, Tomas},
    title = {Facetorch: A Python Library for Analyzing Faces Using PyTorch},
    year = {2024},
    publisher = {GitHub},
    journal = {GitHub Repository},
    howpublished = {url{https://github.com/tomas-gajarsky/facetorch}}
}

Expandir