> For the complete documentation index, see [llms.txt](https://docs.facephi.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.facephi.com/sdks/backend-sdk/selphid/technical_documentation/technical_specifications.md). # Especificaciones técnicas ## 1. Introducción Este documento describe los requisitos técnicos para incorporar **FacePhi SelphID SDK** en tus sistemas. A continuación se detallan los componentes proporcionados y los pasos necesarios para instalar el SDK en los sistemas operativos **Windows** y **Linux**. ## 2. Especificaciones técnicas Las siguientes secciones muestran los requisitos de hardware y software recomendados para instalar el SDK en el lado del servidor. ### 2.1 Requisitos de hardware Las siguientes tablas muestran los requisitos de hardware recomendados para instalar SelphID SDK en distintos sistemas operativos: #### 2.1.1. Requisitos versión CPU Requisitos de hardware recomendados para SelphID SDK, equivalente a **AWS c5.4xlarge**: | CPU | RAM | Disco | | ----------------------------------- | ----- | --------- | | 16 vCPU Intel Xeon Platinum 3.6 GHz | 32 GB | 20 GB SSD | {% hint style="warning" %} **IMPORTANTE:** SelphID-SDK no almacena datos ni resultados de pruebas en disco. La propia instalación del SDK ocupa aproximadamente 2 GB. Prever más almacenamiento para operaciones adicionales de la lógica de negocio. {% endhint %} #### 2.1.2. Requisitos versión GPU Requisitos de hardware recomendados para SelphID SDK con aceleración GPU, equivalente a **AWS g4dn.4xlarge**: | CPU | GPU | RAM | Disco | | -------------------------- | -------------------------- | ----- | --------- | | 16 vCPU Intel Xeon 2.5 GHz | 1x NVIDIA T4 (16 GB GDDR6) | 64 GB | 20 GB SSD | {% hint style="warning" %} **IMPORTANTE:** Al igual que la versión CPU, SelphID-SDK no almacena datos ni resultados de pruebas en disco. La propia instalación del SDK-GPU ocupa aproximadamente 3 GB, más otros 2 GB aprox requeridos por los drivers NVidia y CUDA. Prever más almacenamiento para operaciones adicionales de la lógica de negocio. {% endhint %} {% hint style="warning" %} **IMPORTANTE:** La aceleración GPU solo impacta sobre el rendimiento de operaciones de **Prueba de vida pasiva**. En operaciones de extracción facial, matching 1:1 y matching 1:n no se utiliza la GPU. {% endhint %} {% hint style="warning" %} **IMPORTANTE:** Según las pruebas realizadas, la versión GPU puede alcanzar un 60% más de rendimiento en pruebas de vida pasiva con respecto a la versión CPU 8 cores (Ver [Estadísticas de rendimiento](#24-estadísticas-de-rendimiento)). Hablamos de tiempos de cómputo "puros" del SDK-C++ medido en servidor. Lógica adicional como orquestadores, servidores web o balanceadores de carga pueden opacar estas métricas reduciendo la ganancia de rendimiento percibida. {% endhint %} {% hint style="warning" %} **IMPORTANTE:** Para que la versión GPU de SelphID-SDK funcione correctamente, los drivers de NVidia/CUDA deben estar correctamente instalados y configurados en el servidor. Seguir la guía oficial para este propósito: . {% endhint %} {% hint style="warning" %} **IMPORTANTE:** La versión GPU es una optimización sobre la versión CPU, pero **no ofrece funcionalidad adicional**. A nivel operativo las versiones CPU/GPU son totalmente equivalentes. {% endhint %} ### 2.2 Requisitos de software Las siguientes tablas muestran los requisitos de software mínimos para instalar SelphID SDK en distintos sistemas operativos: #### 2.2.1 Requisitos de software de SelphID SDK | Requisitos mínimos de software | | ----------------------------------- | | Windows 11 / Windows Server 2025 | | Visual C++ 2026 x64 | | Java 1.8 (se recomienda Oracle JDK) | | .Net Framework 4.0 | #### 2.2.2 Requisitos de software de SelphID SDK (Linux Ubuntu) | Requisitos mínimos de software | | ----------------------------------------------- | | Ubuntu 18.04 o compatible | | Glib 2.27 | | GCC 7.5.0 (solo para la versión del SDK en C++) | | Java 1.8 (se recomienda Oracle JDK) | ### 2.3 Estadísticas de fiabilidad del algoritmo de reconocimiento facial A continuación se muestran varias pruebas para evaluar la fiabilidad de **SelphID SDK 6.21.0**. El objetivo es comprender el funcionamiento y el comportamiento del SDK obteniendo medidas objetivas de la fiabilidad y precisión del software de reconocimiento facial. Para ello, se han realizado experimentos con una base de datos pública ampliamente utilizada: *NIST Face Recognition Grand Challenge* ( **FRGC** ) \[1]. Los experimentos realizados muestran resultados en procesos de autenticación o verificación: * ***Verificación (1:1):*** **'¿Eres quien dices ser?':** Determina si, al comparar dos muestras biométricas (plantillas faciales), se genera una puntuación por encima de un umbral, lo que implica que el sistema ha verificado positivamente que eres quien dices ser. Estos sistemas se conocen como 1:1, ya que el patrón facial a evaluar se compara únicamente con tu plantilla facial, obteniendo una respuesta de 'sí' o 'no'. * ***Verificación (1:N):*** **'¿Quién eres?':** En este modo operativo, la muestra biométrica se compara con una lista de patrones almacenados en una base de datos. También se conoce como **1:N** porque la identidad debe localizarse correctamente entre un número **N** de patrones con identidades diferentes con los que se comparará. Se utilizan dos conjuntos de imágenes para evaluar estos modos de funcionamiento: un conjunto de prueba **(Query set)** que simula usuarios desconocidos que intentan acceder al sistema, y un conjunto de registro con usuarios legítimos previamente registrados **(Target set)** con los que se realiza la comparación. Los resultados obtenidos en estos experimentos siguen las medidas estándar definidas en la norma internacional **ISO 19795-1** \[2]. #### 2.3.1 Verificación 1:1 #### 2.3.1.1 Condiciones no controladas (FRGC Exp 4) Este experimento mide la solidez de la tecnología frente a imágenes captadas en condiciones no controladas. Los conjuntos de imágenes utilizados se extraen de la base de datos **FRGC v2.0** \[3]. La evaluación consiste en un *'target set'* de imágenes en condiciones controladas y un *'query set'* de imágenes captadas en condiciones no controladas. Son los mismos conjuntos utilizados en el **Experimento 4** predefinido en la base de datos mencionada \[4]: * El *'Target Set'* del FRGC-Experimento 4 está compuesto por 16.028 imágenes pertenecientes a 466 usuarios. * El *'Query Set'* del FRGC corresponde a un conjunto de prueba con un total de 8.014 imágenes. * El número total de comparaciones realizadas supera los 128 millones. La siguiente tabla muestra los aspectos más importantes del experimento, así como la Tasa de Coincidencia Verdadera (TMR) fijando la Tasa de Falsa Coincidencia (FMR) en 0.1 %: | Verificación en condiciones no controladas (128 M de comparaciones) | TMR con FMR = 0.1% | | ------------------------------------------------------------------- | ------------------ | | ROC I | 99.9999% | | ROC II | 99.9999% | | ROC III | 99.9999% | **Tabla 1.** Resultados del experimento utilizando imágenes en condiciones no controladas. El siguiente gráfico muestra los resultados obtenidos en el experimento mediante curvas ROC (Receiver Operating Characteristic). Se muestran tres curvas ROC que evalúan el rendimiento del algoritmo utilizando imágenes obtenidas a lo largo del tiempo. Además de la TMR con FMR=0.1%, para cada curva ROC se añadieron marcadores adicionales que destacan los puntos de aplicación de alta seguridad. {% hint style="info" %} * **ROC I:** Imágenes de Target y Query obtenidas dentro del mismo semestre. * **ROC II:** Imágenes de Target y Query obtenidas dentro del mismo año. * **ROC III:** Imágenes de Target y Query obtenidas con al menos un año de diferencia. {% endhint %} ![](/files/I38YfAV8EP5GsYzsEQq1) #### 2.3.2 Identificación 1:N **2.3.2.1 Búsqueda de sujetos en una lista** En este experimento se evaluará la fiabilidad del SDK para una aplicación de ***Identificación de Conjunto Cerrado*** (ver anotación más abajo). Para ello, se utilizará el *Experimento 1* de la base de datos FRGC 2.0. En este caso, se utilizará una única imagen para crear el patrón biométrico. El tamaño de los conjuntos de **Prueba** y **Registro** es de 16.028 muestras cada uno (257 millones de comparaciones). Para cada ejemplo del conjunto de prueba, se le pedirá al sistema que devuelva las **N** muestras biométricas del conjunto de registro que presenten mayor similitud. Deben cumplirse dos condiciones para que el sistema identifique correctamente al usuario: 1. La identidad correcta debe estar posicionada en el rango **R** (*Rank*) de la Lista de Candidatos **L** (Candidate List). 2. La similitud debe ser mayor que el umbral de seguridad **T** (Threshold). Estos umbrales corresponden a los **Umbrales de Seguridad** proporcionados por **FacePhi**. Para hacer la prueba más exigente, el Rank se ha reducido al mínimo (R=1) y se ha utilizado la lista más amplia posible, es decir, L=16.028 (se busca contra toda la base de datos). En resumen, para considerarse un acierto, la persona debe quedar posicionada en el rango de la Lista de Candidatos de toda la base de datos, lo que se conoce más ampliamente como *Rank 1 Hit Rate 4* (**Rank One** se define en la referencia \[4]). Las medidas de fiabilidad se basan en la obtención de la *Tasa de Identificación Positiva Verdadera* (TPIR) para distintos niveles de seguridad establecidos por el umbral. | Búsqueda de identidad para una lista dada | | | | ----------------------------------------- | --------------- | -------- | | Tamaño de la biometric template | 1322 bytes | | | TPIR(R=1), Rank1 | NIST FRGC Exp 1 | 98.7272% | **Tabla 2.** Rank 1 del experimento de identificación. {% hint style="info" %} **Conjunto cerrado:** El marcador corresponde a un FMR de 0.000001 (999.999 accesos denegados correctamente de 1 millón de intentos de ataque). Incluso en este caso, la TMR se sitúa en torno al 99% para ROC I. {% endhint %} ### 2.4 Estadísticas de rendimiento La siguiente figura muestra las estadísticas de rendimiento realizadas sobre SelphID SDK, en términos de los tiempos obtenidos en los siguientes módulos: * Passive liveness * Extracción de biometric templates. * Facial matching (1:1) con plantillas e imágenes. * Facial matching (1:N) con plantillas. {% hint style="warning" %} **Importante:** Para estas pruebas se ha utilizado la versión SDK C++ funcionando de forma secuencial. Por tanto presentamos unas métricas del rendimiento "puro" de la solución. No se tiene en cuenta el tiempo consumido por orquestadores, servidores web, entornos cloud de alta concurrencia y latencias. {% endhint %} {% hint style="warning" %} **Importante:** Se ha configurado el SDK para utilizar 8 hilos concurrentes para operaciones de extracción o liveness. `FACEPHI_SELPHID_FACIALEXTRACTOR_NUM_THREADS=8`, `FACEPHI_SELPHID_FACIALLIVENESS_NUM_THREADS=8`. Ver [Variables de entorno](/sdks/backend-sdk/selphid/installation/installation_instructions.md#33-variables-de-entorno). {% endhint %} Para llevar a cabo las mediciones de prueba de vida, extracción, comparación 1:1 y comparación 1:N, se utilizó un dispositivo con las siguientes características: * Intel Xeon Platinum 3.6 GHz * Procesador de 16 núcleos * 32 GB de RAM * Linux Ubuntu 18.04.6 LTS | | Extracción biométrica `(imagen 640x480)` | Comparación `(1:1)` con plantillas en bruto | Comparación `(1:1)` con imágenes `(640x480)` | | ----------- | ---------------------------------------- | ------------------------------------------- | -------------------------------------------- | | Rendimiento | 65 ms | 129 ms | 121 ms | **Figura 1.** Datos obtenidos en SelphID SDK Linux. {% hint style="info" %} En un servidor Windows, los datos obtenidos pueden variar en +-10% {% endhint %} A continuación se muestran las estadísticas de rendimiento para la prueba de vida: | | CPU 8 cores | GPU | | ----------------- | ----------- | ------ | | Imagen `640x480` | 192 ms | 165 ms | | Imagen `1280x720` | 400 ms | 249 ms | **Figura 3.** Datos obtenidos con la versión Linux de SelphID SDK. A continuación se muestran los datos de rendimiento para la creación de galerías y la identificación 1:N. | | Crear galería | Identificación | | ------------------ | ------------- | -------------- | | plantillas/segundo | 65.000 | 6.500.000 | | | | | **Figura 4.** Datos obtenidos en SelphID SDK Linux. {% hint style="info" %} En un servidor Windows, los datos obtenidos pueden variar en +-10% {% endhint %} ## 3. Detección de prueba de vida pasiva Las técnicas utilizadas por los defraudadores para suplantar a usuarios legítimos crecen constantemente y se conocen como Ataques. Dado que estas aplicaciones se integran en sistemas de seguridad críticos, es necesario dotarlas de medidas de seguridad de *Detección de Ataques de Presentación* (PAD) y *Detección de Ataques de Manipulación* (MAD), ya que resulta vital determinar si los patrones biométricos presentados a la aplicación proceden de un usuario genuino ("bona fide") o no. (Un usuario genuino sería un usuario legítimo del sistema que está presente frente a la cámara en el momento de la medición biométrica). {% hint style="warning" %} **IMPORTANTE:** Para la funcionalidad de prueba de vida pasiva de SelphID SDK, es necesario que las imágenes utilizadas tengan una resolución mínima de 720p (resolución HD), para que los resultados se ajusten a las métricas mostradas a continuación. {% endhint %} El objetivo principal es dotar a los algoritmos de reconocimiento facial del nivel de seguridad necesario para **prevenir el uso fraudulento de las características faciales de un usuario obtenidas de fotografías y/o vídeos durante la identificación, y así prevenir el fraude masivo**. La tecnología de Facephi garantiza que el patrón biométrico obtenido del rostro del usuario se ha extraído de una presentación biométrica bona fide, descartando aquellos obtenidos de un atacante que presente **papel**, **fotografías**, **vídeos**, **máscaras** y/o que inyecte **imágenes manipuladas** en el sistema de captura. Facephi ha implementado un sistema seguro y fácil de usar para **poder acceder al sistema en menos de un segundo con total seguridad**, más rápido y sencillo que memorizar una contraseña y un usuario. El equilibrio perfecto entre seguridad y facilidad de acceso. | ![Imagen de onboarding](/files/YEl5Aqnm9P3cQIHISk5B) | ![Imagen de rechazo](/files/ieqVfzeMrj25V70ttk26) | Utilizando las técnicas de Deep Learning de Facephi, esta nueva herramienta determina si la imagen procede de un acceso de usuario genuino o, por el contrario, de una reproducción mediante fotos impresas, imágenes manipuladas, desde un dispositivo móvil, tableta o pc. Esta herramienta se complementa con el sólido sistema de reconocimiento facial proporcionado en Selphi y SelphID. La principal ventaja de esta herramienta es que mejora enormemente la experiencia de usuario, ya que el usuario solo tiene que colocarse frente a la cámara y hacerse un selfie, sin necesidad de colaboración adicional. | | ---------------------------------------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | **FaceLiveness** se basa en algoritmos de Machine Learning entrenados para extraer las características contenidas en una imagen de selfie (por ejemplo, artefactos, deformaciones, textura, profundidad, reflectancia de la luz, inconsistencias de resolución, pulso sanguíneo, etc.) que permiten al módulo de clasificación discriminar entre una presentación bona fide (también conocida como genuina) y un ataque (por ejemplo, papel, foto, repetición de selfie/vídeo, máscara, etc.). Un sistema de Detección de Ataques Pasivo no requiere ninguna acción por parte del usuario y se basa completamente en técnicas de Deep Learning. Por lo tanto, no introduce fricción adicional en el proceso de verificación y autenticación, es más rápido que los sistemas activos y, al mismo tiempo, con la captura de un simple selfie (o unos pocos fotogramas extraídos de un vídeo corto), introduce una complejidad adicional en el sistema que se traduce en una mayor capacidad para detectar una amplia gama de ataques, ya sean artesanales o manipulados digitalmente. ### 3.1 Detección de ataques de presentación El sistema de Detección de Ataques de Presentación (PAD) pasivo de **Facephi** (FaceLiveness) determina si el acceso lo está realizando un usuario genuino (bona fide) o si el acceso lo está realizando un atacante que presenta un papel, foto, vídeo o máscara que representa las características biométricas del objetivo al que intenta suplantar. ### 3.2. Detección de ataques de manipulación El sistema de Detección de Ataques de Manipulación (MAD) de **Facephi** (FaceLiveness) determina si el acceso lo está realizando un usuario genuino (bona fide) o si el acceso lo realiza un atacante que inyecta en el sistema una imagen manipulada que ha sido modificada. La nueva tecnología de Facephi es capaz de prevenir: * **Manipulación por Face Swap:** Superposición del rostro de una persona sobre una foto o vídeo de otra persona. * **Rostro sintético (deepfake):** Rostro sintético generado mediante métodos de deep learning, como redes generativas antagónicas (GAN) o redes de difusión. ### 3.3. Detección de ataques de coerción A partir de la versión `6.20.0`, el motor de prueba de vida incluye soporte para la detección de ataques de coerción. Esto incluye amenazas con armas (pistolas, cuchillos), así como forzar la apertura de los ojos con las manos. Inicialmente, se trata de un **soporte experimental**, realizado de forma adicional a las pruebas FMAD y FPAD, pero que no afecta al resultado final (`Live`, `NoLive`). Por ahora, la coerción debe comprobarse mediante `NoLiveDetails::CoercionScore`. ### 3.4. Métricas basadas en ISO/IEC 30107 La **ISO/IEC 30107-1:2023** (Tecnología de la información — Detección de ataques de presentación biométrica — Parte 1: Marco de trabajo) y la **ISO/IEC 30107-3:2023** (Parte 3: Pruebas e informes) establecen los estándares para determinar las especificaciones, caracterizaciones y evaluaciones de los ataques de presentación (Tipo 1) que se producen en el sensor (ya sea en un smartphone o en una cámara de escritorio) durante la recopilación de los rasgos biométricos (por ejemplo, un selfie o un vídeo). Las métricas más importantes para evaluar el rendimiento de un sistema de Detección de Ataques de Presentación (PAD) son: **APCER - Tasa de Error de Clasificación de Presentación de Ataques:** proporción de presentaciones de ataque que utilizan la misma especie de instrumento de ataque de presentación (PAI) clasificadas incorrectamente como presentaciones bona fide por un subsistema de detección de ataques de presentación (PAD) en un escenario específico. $$ APCER\_{PAIS} = 1 - \left( \frac{1}{N\_{PAIS}} \right) \sum\_{i=1}^{N\_{PAIS}} Res\_i $$ **BPCER - Tasa de Error de Clasificación de Presentación Bona Fide:** proporción de presentaciones bona fide clasificadas incorrectamente como ataques de presentación en un escenario específico. $$ BPCER = \frac{ \sum\_{ i=1 }^{ N\_{BF} } Res\_i}{ N\_{BF} } $$ **PAI**s - Instrumento de Ataque de Presentación: característica biométrica u objeto utilizado en un ataque de presentación biométrica. Presentación **Bona fide**: presentación biométrica sin el objetivo de interferir en el funcionamiento del sistema biométrico. **Ataque de Presentación:** presentación al subsistema de captura biométrica con el objetivo de interferir en el funcionamiento del sistema biométrico. | | MUESTRAS | APCER % | | ---------------------- | -------- | ------- | | Impresión en papel | 109637 | 0.40 % | | Repetición en pantalla | 304582 | 0.12 % | | Máscara simple | 46503 | 0.01 % | | Máscara avanzada | 5184 | 0.75 % | *Tasa de Error de Clasificación de Presentación de Ataques y Manipulación (APCER) con muestras de prueba de papel, máscara y dispositivo (foto en pantalla). Métricas obtenidas como promedio entre conjuntos de datos internos y públicos.* | | MUESTRAS | BPCER % | | ----------------- | -------- | ------- | | Accesos bona fide | 396230 | 1.10 % | *Tasa de Error de Clasificación de Presentación y Manipulación Bona Fide (BPCER) con muestras de prueba genuinas* | | MUESTRAS | BPCER % | | ----------------- | -------- | ------- | | Accesos bona fide | 370671 | 6.85 % | *Tasa de Error del Detector de Coerción Bona Fide (BPCER) con muestras de prueba genuinas* ## 4. Requisitos de uso de la tecnología | Especificaciones | Requisitos recomendados | Requisitos mínimos FPAD | Requisitos mínimos FREC | | ------------------------------------- | -------------------------------- | ----------------------------------- | ------------------------- | | Resolución | 1080P | - | - | | IOD | IOD>80 | IOD>60 | IOD > 30px | | Compresión | Formato sin comprimir | JPEG con baja compresión (70%) (\*) | - | | Color | Color | Color | Escala de grises | | Pose | < 5° (Yaw, Pitch, Roll) | < 15° (Yaw, Pitch, Roll) | < 45° (Yaw, Pitch, Roll) | | Posición del rostro respecto al fondo | Imagen de token frontal completa | > 5% del ancho del rostro | > 8% del ancho del rostro | *(\*) Valores estimados* ## 5. Referencias \[1] B. P. J. Phillips, P. J. Rauss, and S. Z. Der, '**FERET (Face Recognition Technology) Recognition Algorithm Development and Test Results**', October 1996. Army Research Lab technical report 995. \[2] ISO/IEC 19795-1 standard: '**Information technology – Biometric performance testing and reporting – Part 1: Principles and framework**', 2006 \[3] P. J. Phillips, P. J. Flynn, T. Scruggs, K. W. Bowyer, J. Chang, K. Hoffman, J. Marques, J. Min, and W. Worek, ' **Overview of the Face Recognition Grand Challenge'** , 2005. IEEE Conference on Computer Vision and Pattern Recognition. \[4] PJ Phillips, et al. **'Preliminary Face Recognition Grand Challenge Results'** , 2006 - 7th International Conference on Automatic Face and Gesture Recognition.