Production Face Recognition System Development with ArcFace and FAISS

At a factory entrance, a camera captures an employee's face at an acute angle—the system returns a false rejection, the worker queues up, and security switches to manual verification. 80% of such incidents stem from suboptimal pipeline: the model fails under side lighting or the similarity threshold is set without accounting for real embedding variance. We design production face recognition systems that operate reliably under harsh conditions—from turnstiles to searching among millions of faces on city cameras. Over 5+ years, we have deployed 20+ systems with a False Acceptance Rate (FAR) below 1e-5 and a False Rejection Rate (FRR) under 5% on real customer data. Payback period is less than one year through access automation and reduced security workload.

Full Pipeline

import cv2
import numpy as np
from insightface.app import FaceAnalysis

class FaceRecognitionSystem:
    def __init__(self, db_path: str, threshold: float = 0.5):
        # InsightFace объединяет детекцию + alignment + embedding
        self.app = FaceAnalysis(
            providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
        )
        self.app.prepare(ctx_id=0, det_size=(640, 640))

        self.threshold = threshold
        self.face_db = self._load_database(db_path)

    def identify(self, image: np.ndarray) -> list[dict]:
        faces = self.app.get(image)
        results = []

        for face in faces:
            embedding = face.embedding  # 512-dim ArcFace embedding
            match = self._search_database(embedding)
            results.append({
                'bbox': face.bbox.astype(int).tolist(),
                'person_id': match['id'] if match else None,
                'person_name': match['name'] if match else 'Unknown',
                'similarity': match['similarity'] if match else 0.0,
                'verified': match['similarity'] > self.threshold if match else False
            })
        return results

    def _search_database(self, query_emb: np.ndarray) -> dict | None:
        # Cosine similarity поиск
        similarities = np.dot(self.face_db['embeddings'], query_emb) / (
            np.linalg.norm(self.face_db['embeddings'], axis=1) *
            np.linalg.norm(query_emb)
        )
        best_idx = np.argmax(similarities)
        best_sim = similarities[best_idx]

        if best_sim < self.threshold:
            return None
        return {
            'id': self.face_db['ids'][best_idx],
            'name': self.face_db['names'][best_idx],
            'similarity': float(best_sim)
        }

Choosing an Embedding Model

ArcFace (InsightFace) is the industry standard. LFW accuracy: 99.83%, IJB-C TAR@FAR=1e-4: 96.5% (see InsightFace Benchmark). Embedding size: 512 dimensions. FaceNet (Google) is an earlier model still popular. LFW: 99.65%. Embedding size: 128 or 512 dimensions. MagFace is an improved ArcFace with a scalable margin. IJB-C: 97.1%. For edge devices: MobileFaceNet—1MB, runs on mobile, LFW: 99.5%. Model selection depends on the task: for maximum accuracy choose MagFace, for speed on mobile—MobileFaceNet.

Scaling the Face Database

For small databases (< 10k faces), brute-force cosine similarity works instantly. For large databases—approximate nearest neighbor (ANN). FAISS IVFFlat: search among 1M faces in < 1ms on CPU—1,000 times faster than brute force for databases from 100k faces. The architecture allows horizontal scaling: adding new nodes without service interruption.

import faiss

class FaceDatabase:
    def __init__(self, dimension: int = 512):
        # FAISS IVF индекс для million-scale баз
        quantizer = faiss.IndexFlatIP(dimension)  # Inner Product = cosine sim
        self.index = faiss.IndexIVFFlat(quantizer, dimension, 100)
        self.index.nprobe = 10  # качество vs скорость поиска

    def add_faces(self, embeddings: np.ndarray):
        # Нормализуем для cosine similarity через IP
        faiss.normalize_L2(embeddings)
        if not self.index.is_trained:
            self.index.train(embeddings)
        self.index.add(embeddings)

    def search(self, query: np.ndarray, k: int = 5):
        faiss.normalize_L2(query.reshape(1, -1))
        similarities, indices = self.index.search(query.reshape(1, -1), k)
        return similarities[0], indices[0]

Handling Low-Quality Images

A real-world system must handle blurry, partially occluded, and poorly lit faces. Before identification, we assess face quality using FaceQNet or BRISQUE. Images below the threshold are rejected. Additionally, we employ anti-spoofing (MiniFASNet, CDCN) to protect against photographs and screens. For maximum security, we use 3D liveness detection via IR camera or depth sensor.

Anti-Spoofing: Protection Against Fakes

Face Anti-Spoofing (FAS) is mandatory in production systems. Without it, an attacker could present a photo or video. We integrate MiniFASNet—a lightweight model that runs in real time. For high-security scenarios, we add 3D verification. Savings from preventing incidents can reach 2 million rubles per year for a large facility.

Legal and Ethical Considerations

A face recognition system must comply with legislation: GDPR in the EU, 152-FZ in Russia. Biometric data is a special category of personal data. Mandatory: explicit informed consent, encryption of the embedding database with AES-256-GCM, access logging, and the right to deletion. We include legal auditing in every project.

Additional security measures: role-based access control, regular log audits, ISO 27001 certification.

What Is Included in the Work?

• Requirements analysis: 1:1 verification or 1:N identification, database scale, target hardware.
• Collection of a test dataset from real conditions (lighting, camera angles, cameras).
• Selection and tuning of the embedding model and anti-spoofing.
• Building the database and tuning the similarity threshold.
• Integration, load testing, FAR/FRR monitoring.
• Documentation and operator training.
• Post-launch support.

Development Stages

1. Requirements audit
2. Model selection and dataset collection
3. Pipeline prototyping
4. Integration with hardware
5. Testing (FAR/FRR, latency p99)
6. Deployment and monitoring

Why Choose Us?

5+ years of Computer Vision experience, 20+ deployed face recognition systems. We guarantee: FAR < 1e-5 with FRR < 5% on the customer's test dataset. Contact us for a consultation on your task. Order turnkey development—we will evaluate your project within 2 days. Our technology stack: InsightFace and FAISS.