Custom Face Recognition Model Training (ArcFace, Metric Learning)

Custom Face Recognition Model Training: From Dataset to Production

Imagine: your company is growing, new employees arrive daily, and key-card access is insecure. You decide to implement face recognition. But a standard Softmax classifier won't cut it — it requires retraining on every new employee. The solution is training a custom model with ArcFace loss, which can generalize to unseen identities. Our team — AI engineers with 5+ years of experience in computer vision, completed 30+ face recognition projects. We guarantee accuracy of 99.5% on LFW.

ArcFace is the industry standard: 99.5% accuracy on LFW, compact embeddings, noise robustness. It outperforms Softmax by up to 10% in open-set tasks, especially when new identities appear after deployment. Below we describe the training setup: backbone selection, margin tuning, dataset processing.

ArcFace Loss: Math and Implementation

ArcFace adds an additive angular margin m to the angle between the embedding and the corresponding class center:

import torch import torch.nn as nn import torch.nn.functional as F import math class ArcFaceLoss(nn.Module): def __init__( self, embedding_size: int = 512, num_classes: int = 10000, margin: float = 0.5, # angular margin in radians (~28.6°) scale: float = 64.0 # logit scale ): super().__init__() self.margin = margin self.scale = scale # Trainable class centers (normalized) self.weight = nn.Parameter( torch.FloatTensor(num_classes, embedding_size) ) nn.init.xavier_uniform_(self.weight) self.cos_m = math.cos(margin) self.sin_m = math.sin(margin) self.th = math.cos(math.pi - margin) # threshold for numerical stability self.mm = math.sin(math.pi - margin) * margin def forward( self, embeddings: torch.Tensor, # (B, embedding_size), L2-normalized labels: torch.Tensor # (B,) ) -> torch.Tensor: # L2-normalize weights W = F.normalize(self.weight, dim=1) # cos(θ) = emb · W^T cosine = F.linear(embeddings, W) # (B, num_classes) sine = torch.sqrt(1.0 - cosine.pow(2).clamp(0, 1)) # cos(θ + m) = cos(θ)cos(m) - sin(θ)sin(m) phi = cosine * self.cos_m - sine * self.sin_m # Numerical stability: if θ > π - m, use cosine penalty phi = torch.where(cosine > self.th, phi, cosine - self.mm) # One-hot target mask one_hot = torch.zeros_like(cosine) one_hot.scatter_(1, labels.view(-1, 1), 1) # Replace logit only for the correct class output = one_hot * phi + (1.0 - one_hot) * cosine output *= self.scale return F.cross_entropy(output, labels) 

Backbone and Embedding: Which to Choose?

InsightFace / ArcFace typically uses ResNet-50/100 or IResNet. For production on mobile devices — MobileFaceNet:

import timm def build_face_recognition_model( backbone: str = 'resnet50', # 'resnet100', 'mobilenetv3_small' embedding_size: int = 512, pretrained: bool = True ) -> nn.Module: class FaceEmbedder(nn.Module): def __init__(self): super().__init__() self.backbone = timm.create_model( backbone, pretrained=pretrained, num_classes=0, # remove classifier head global_pool='avg' ) feat_dim = self.backbone.num_features self.bn = nn.BatchNorm1d(feat_dim) self.drop = nn.Dropout(p=0.4) self.fc = nn.Linear(feat_dim, embedding_size, bias=False) self.bn2 = nn.BatchNorm1d(embedding_size) def forward(self, x: torch.Tensor) -> torch.Tensor: feat = self.backbone(x) feat = self.bn(feat) feat = self.drop(feat) emb = self.fc(feat) emb = self.bn2(emb) return F.normalize(emb, dim=1) # L2-normalization return FaceEmbedder() 

Threshold Selection for Open-Set Recognition

In production, the system encounters new people not seen in training. We use cosine similarity threshold:

import numpy as np from scipy.spatial.distance import cosine class FaceRecognitionSystem: def __init__( self, model: nn.Module, threshold: float = 0.4 # cosine distance; tuned via ROC ): self.model = model.eval() self.threshold = threshold self.gallery: dict[str, np.ndarray] = {} # id → embedding def enroll(self, person_id: str, face_image: torch.Tensor) -> None: """Register a new face in the gallery""" with torch.no_grad(): emb = self.model(face_image.unsqueeze(0)) self.gallery[person_id] = emb.cpu().numpy().squeeze() def identify( self, face_image: torch.Tensor, top_k: int = 1 ) -> list[dict]: """Search gallery — 1:N identification""" with torch.no_grad(): query_emb = self.model(face_image.unsqueeze(0)) query_np = query_emb.cpu().numpy().squeeze() distances = { person_id: cosine(query_np, gallery_emb) for person_id, gallery_emb in self.gallery.items() } sorted_matches = sorted(distances.items(), key=lambda x: x[1]) results = [] for person_id, dist in sorted_matches[:top_k]: results.append({ 'identity': person_id if dist < self.threshold else 'unknown', 'distance': float(dist), 'confidence': float(1 - dist) }) return results 

The cosine distance threshold is tuned via ROC curve on your test set. Optimal threshold is 0.35–0.45 for most enterprise scenarios. We use TAR@FAR=0.1% as the target metric.

Why ArcFace is the Industry Standard?

ArcFace produces compact clusters without the complex triplet mining of FaceNet. It maintains accuracy even on noisy datasets. More details on the loss can be found in the ArcFace paper.

Metrics and Comparison of Loss Functions

Loss function comparison:

Process and Timeline

We don't just train a model — we build a complete solution. The process includes:

1. Dataset analysis: quality assessment, quantity, recommendations.
2. Data preparation: face alignment, augmentation (flip, rotation, blur), train/val/test split.
3. Backbone and loss selection: from MobileNet to ResNet-100 based on your dataset and hardware.
4. Training: balanced sampling, monitoring via Weights & Biases.
5. Validation: TAR@FAR on your test set, ROC analysis.
6. Quantization and export: INT8/FP16 for edge, ONNX for CPU.
7. Deployment: Docker + Triton/ONNX, REST/gRPC API, documentation.

What's Included in the Work?

The deliverable includes:

• Trained model with chosen backbone and loss (ArcFace by default).
• API documentation, deployment instructions.
• Docker image with model and testing scripts.
• 3 months warranty support and updates.

Timelines:

• Fine-tuning ArcFace on corporate data — 3–5 weeks.
• Full 1:N system with gallery — 5–8 weeks.
• Custom pipeline (detection + alignment + recognition) — 8–14 weeks.

Cost is calculated based on your dataset and requirements. For example, fine-tuning a model on a dataset of 10,000 identities starts at $5,000. A full system including detection and gallery is typically under $20,000. Contact us to discuss the details.

Typical Mistakes When Training Face Recognition Models

• Using Softmax for open-set tasks — accuracy drops by 5–10%.
• Not applying L2 normalization to embeddings — metric learning does not converge.
• Forgetting face alignment — accuracy drops by 3–5%.
• Setting the threshold too low — avalanche of false positives.

If you want a consultation on your dataset, contact us. Order custom face recognition model training — we'll evaluate the project within 1 day.

Pricing: Fine-tuning starts from $5,000, full 1:N system from $15,000. Get a free estimate within 24 hours.