EdgeFace: Lightweight Face Recognition

• EdgeFace is a lightweight face recognition model that merges CNN and Transformer components, optimized for edge and mobile devices.
• It employs SDTA and LoRaLin to achieve efficient global context modeling and compression of linear operations while maintaining high accuracy.
• EdgeFace variants deliver state-of-the-art performance with low MFLOPs and minimal parameters, supporting applications from biometric security to humanitarian deployments.

EdgeFace most commonly denotes a lightweight face recognition model for edge and mobile devices built from a hybrid CNN–Transformer backbone derived from EdgeNeXt and augmented with low-rank linear layers, with 512-dimensional embeddings and strong accuracy under tight parameter and MFLOP budgets (George et al., 2023). In the literature provided here, the term also appears in two broader senses: as an edge-aware face parsing concept implemented by EAGRNet, which performs image-to-graph-to-pixel reasoning for semantic face parsing (Te et al., 2020), and as the root of later biometric systems and adaptations such as PolyProtect-protected humanitarian recognition pipelines and xEdgeFace for heterogeneous face recognition (Stragapede et al., 25 Aug 2025, George et al., 28 Apr 2025). A further nomenclature ambiguity exists because unrelated finite-element papers discuss “edge” and “face” elements in $H(\mathrm{curl})$ and $H(\mathrm{div})$ spaces, but those works concern geometric decomposition and serendipity virtual element spaces rather than biometric face analysis (Chen et al., 2023, Veiga et al., 2016).

1. EdgeFace as an efficient face recognition backbone

EdgeFace is a lightweight face recognition model designed specifically for edge devices and presented as a hybrid CNN–Transformer network inspired by the EdgeNeXt architecture (George et al., 2023). Its stated objective is to retain high face recognition accuracy while reducing memory footprint, computational cost, and storage relative to large-scale face recognition models that are difficult to deploy on resource-constrained hardware. The model combines convolutional processing with Split Depth-wise Transpose Attention, or SDTA, and replaces high-rank linear layers with LoRaLin low-rank linear modules.

The backbone operates on $112\times112$ aligned RGB face crops and produces 512-dimensional face features (George et al., 2023). Three principal variants are reported. EdgeFace-S uses channels $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$, has 3.65M parameters, and requires 306.11 MFLOPs. EdgeFace-XS uses channels $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$, has 1.77M parameters, and requires 154 MFLOPs. EdgeFace-XXS uses channels $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$, has 1.24M parameters, and requires 94.7 MFLOPs. Non-quantized competition model sizes are reported as 14.69 MB for EdgeFace-S and 7.17 MB for EdgeFace-XS, while quantized submissions include EdgeFace-XS-Q at 2.99 MB and EdgeFace-XXS-Q at 1.73 MB.

The architecture is hierarchical rather than ViT-style patchified. A Conv2d and LayerNorm2d stem is followed by an initial EdgeFace stage at $28\times28$, then progressive downsampling through $14\times14$, $7\times7$, and $3\times3$ resolutions (George et al., 2023). Hybrid blocks combine depthwise and pointwise convolutions with SDTA, which computes self-attention across channel dimensions using transposed query and key feature maps, following the cross-covariance idea used in XCiT. This yields global modeling with linear complexity with respect to spatial tokens, which is central to EdgeFace’s edge-device positioning.

A defining implementation choice is LoRaLin. A dense linear weight $H(\mathrm{div})$0 is approximated as $H(\mathrm{div})$1, with $H(\mathrm{div})$2, $H(\mathrm{div})$3, and $H(\mathrm{div})$4 (George et al., 2023). In EdgeFace, all linear layers in the backbone and final head are replaced by two sequential low-rank linear layers, and the rank is set by $H(\mathrm{div})$5. For the XS backbone, $H(\mathrm{div})$6 reduces parameters from 2.24M to 1.77M and MFLOPs from 196.9 to 153.9, with at most a $H(\mathrm{div})$7 drop on IJB-B and IJB-C.

This design positions EdgeFace between purely convolutional lightweight face recognition models and transformer-heavy architectures. The convolutional path supplies locality and translation-equivariant structure, SDTA supplies global contextual modeling without quadratic spatial cost, and LoRaLin compresses the densest linear operations (George et al., 2023). A plausible implication is that EdgeFace should be understood less as a single network instance than as a compact design pattern for hybrid face recognition under tight deployment constraints.

2. Training procedure, inference pipeline, and benchmark performance

EdgeFace is trained end to end for face recognition using large-scale aligned face datasets derived from WebFace260M, specifically WebFace4M and WebFace12M, with margin-based softmax heads and PartialFC for scalable million-identity classification (George et al., 2023). Faces are pre-aligned to $H(\mathrm{div})$8, converted to tensors, normalized to $H(\mathrm{div})$9, and augmented using NVIDIA DALI with random grayscale, resizing, and blurring. The training framework is PyTorch; the optimizer is AdamW; the learning-rate schedule is polynomial decay with restarts; and distributed training is reported on 4 or 8 NVIDIA RTX 3090 GPUs with batch sizes of 256–512 per GPU.

The training head uses CosFace as the primary loss, with ArcFace considered in ablations (George et al., 2023). At inference time, the classification head is removed, the 512-D embedding is L2-normalized, and verification is performed using cosine similarity. The deployment pipeline described in the paper consists of face detection and alignment, preprocessing to $112\times112$0 with normalization to $112\times112$1, EdgeFace inference to obtain a 512-D embedding, and threshold or template-based cosine comparison.

The principal reported benchmark results establish EdgeFace as a high-performing efficient face recognition model (George et al., 2023). EdgeFace-XS, with 1.77M parameters and 154 MFLOPs, achieves $112\times112$2 on LFW, $112\times112$3 on CA-LFW, $112\times112$4 on CP-LFW, $112\times112$5 on CFP-FP, $112\times112$6 on AgeDB-30, $112\times112$7 TAR at FAR $112\times112$8 on IJB-B, and $112\times112$9 TAR at FAR $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$0 on IJB-C. EdgeFace-S, with 3.65M parameters and 306.11 MFLOPs, reaches $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$1 on LFW, $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$2 on CA-LFW, $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$3 on CP-LFW, $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$4 on CFP-FP, $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$5 on AgeDB-30, $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$6 on IJB-B, and $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$7 on IJB-C.

In the IJCB 2023 Efficient Face Recognition competition, EdgeFace-XS ranked first overall in the under-2M-parameter track, with the best accuracy rank and IJB-C leadership, while EdgeFace-S achieved the highest accuracy rank and top IJB-C TAR at FAR $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$8 in the 2–5M-parameter track, with overall combined rank 3 (George et al., 2023). The competition criteria combined accuracy, FLOPs, and model size, which is relevant because EdgeFace was explicitly optimized for multi-objective efficiency rather than accuracy alone.

The comparisons to lightweight baselines are also central. MobileFaceNet is listed at 2.0M parameters and 933 MFLOPs, with LFW $48 \rightarrow 96 \rightarrow 160 \rightarrow 304$9, IJB-B $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$0, and IJB-C $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$1, whereas EdgeFace-XS attains comparable or better accuracy with 154 MFLOPs (George et al., 2023). The paper attributes this to the interaction of CNN inductive biases, SDTA-based channel attention, and LoRaLin compression. This suggests that EdgeFace’s main contribution is architectural co-design rather than reliance on a single novel operator.

3. Deployment on edge devices and operational constraints

EdgeFace is explicitly framed as an on-device face recognition model for mobile, embedded, and robotics settings where latency, model size, and compute budget are binding constraints (George et al., 2023). The expected deployment profile stated for EdgeFace-XS is real-time suitability on CPU or ARM devices, and the quantized submissions demonstrate a further memory reduction to approximately $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$2–$32 \rightarrow 64 \rightarrow 100 \rightarrow 192$3 MB. The deployment guidance additionally mentions TensorRT on Jetson, TFLite delegates through NNAPI on Android, and CoreML on iOS.

A later humanitarian biometric systems study selects EdgeFace XS as the face feature extractor for an offline, on-device system operating on low-cost smartphones in emergency settings (Stragapede et al., 25 Aug 2025). In that context, the system requirements include strict “do-no-harm” security and privacy guarantees, offline operation, computational and time efficiency on low-cost smartphones, and no accuracy degradation when adding biometric template protection. EdgeFace is chosen because it is “explicitly designed for edge devices,” has a small memory footprint, and provides strong verification and identification accuracy compatible with recognition without cloud resources.

The humanitarian deployment uses the XS version with 1.77M parameters, 6.83MB model size, 512-dimensional real-valued embeddings, and cosine-distance matching (Stragapede et al., 25 Aug 2025). The face dataset comes from a field project in Ethiopia with 942 subjects and 2 captures each, with images mostly acquired outdoors using low-end smartphones with 8–12MP cameras. The paper does not report FLOPs, inference latency on mobile hardware, energy consumption, or preprocessing details for the pretrained EdgeFace model, but it emphasizes that the full system runs entirely offline on-device.

The practical significance of this usage is that EdgeFace is not presented merely as an academic benchmark model but as an operational feature extractor in a security-sensitive real-world pipeline (Stragapede et al., 25 Aug 2025). The comparator remains cosine distance in both the unprotected and protected domains, which facilitates modular integration with the selected biometric template protection scheme. A plausible implication is that EdgeFace’s compactness is valuable not only for latency and storage but also for preserving system simplicity under constrained trust and connectivity assumptions.

4. PolyProtect integration and humanitarian biometric security

In the humanitarian biometric system, EdgeFace embeddings are integrated with PolyProtect, a biometric template protection method that transforms the original 512-D embedding $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$4 into a lower-dimensional protected vector $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$5 using subject-specific multivariate polynomials over overlapping local windows (Stragapede et al., 25 Aug 2025). The subject-specific secrets are the ordered integer coefficient vector $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$6 and exponent vector $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$7, and cosine distance is preserved as the comparison rule in both protected and unprotected domains.

The paper parameterizes PolyProtect with window size $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$8, exponent vector $32 \rightarrow 64 \rightarrow 100 \rightarrow 192$9 as a random permutation of integers $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$0, coefficients $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$1 drawn from $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$2, and overlap $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$3 varied from 0 to 6 (Stragapede et al., 25 Aug 2025). For face embeddings, $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$4 yields 74-D protected templates and $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$5 yields 506-D protected templates. The rationale given for $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$6 is that Abel–Ruffini implies degree $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$7 for non-closed-form inversion, and that $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$8 yields 5040 possible exponent permutations, reducing the chance of collision across subjects.

The reported verification results on the Ethiopia dataset show that the unprotected EdgeFace baseline attains TMR $24 \rightarrow 48 \rightarrow 88 \rightarrow 168$9 at FMR $28\times28$0, TMR $28\times28$1 at FMR $28\times28$2, and EER $28\times28$3 (Stragapede et al., 25 Aug 2025). In the Normal scenario, PolyProtect improves over baseline in almost all metrics, with the best performance at $28\times28$4: TMR $28\times28$5 at FMR $28\times28$6, TMR $28\times28$7 at FMR $28\times28$8, and EER $28\times28$9. In the Stolen Coefficients and Exponents scenario, performance degrades, but at $14\times14$0 still reaches TMR $14\times14$1 at FMR $14\times14$2, TMR $14\times14$3 at FMR $14\times14$4, and EER $14\times14$5.

Identification is harder because the query must be transformed using all enrolled parameter sets and compared to correspondingly transformed references (Stragapede et al., 25 Aug 2025). The unprotected EdgeFace baseline reaches TPIR-1 $14\times14$6, TPIR-3 $14\times14$7, and TPIR-10 $14\times14$8. With PolyProtect at $14\times14$9, the scores are TPIR-1 $7\times7$0, TPIR-3 $7\times7$1, and TPIR-10 $7\times7$2. The paper characterizes the reduction at intermediate overlaps as often operationally acceptable.

The security analysis emphasizes a recognition–irreversibility trade-off (Stragapede et al., 25 Aug 2025). Under full disclosure per ISO/IEC 30136, single-template inversion success rate at strict matching, FMR $7\times7$3, is $7\times7$4 for $7\times7$5, rises to $7\times7$6 at $7\times7$7, and reaches $7\times7$8 at $7\times7$9. Unlinkability improves sharply relative to unprotected EdgeFace, with $3\times3$0 for the baseline and approximately $3\times3$1–$3\times3$2 for PolyProtect with naive parameter selection, with further reductions under strict parameter selection. This does not modify EdgeFace’s architecture, but it materially changes how EdgeFace embeddings can be deployed in privacy-sensitive environments.

5. Cross-spectral adaptation: xEdgeFace

xEdgeFace is a parameter-efficient cross-spectral adaptation of the EdgeFace backbone for heterogeneous face recognition across VIS–Thermal, VIS–NIR, sketch–photo, and surveillance-quality settings (George et al., 28 Apr 2025). In this formulation, EdgeFace refers to the pretrained RGB face recognition model, while xEdgeFace denotes adapted variants that learn modality-invariant features with minimal paired heterogeneous training data and without increasing inference-time complexity.

The adaptation strategy keeps the underlying EdgeFace backbone and unfreezes only selected modules: LayerNorms, the initial convolutional stem, and optionally early stages labeled S0, S1, and S2 (George et al., 28 Apr 2025). Thermal inputs are single-channel and are replicated to three channels before entering the RGB-trained backbone; no separate modality-specific branch is introduced. The model is trained with two losses: a contrastive modality-alignment loss and a self-distillation regularizer from a frozen copy of the original pretrained model. The total objective is

$3\times3$3

with $3\times3$4 in the contrastive term and $3\times3$5 in all experiments.

The computational profile remains that of the corresponding EdgeFace backbone (George et al., 28 Apr 2025). Reported inference complexity at $3\times3$6 is 1.39 GFLOPs and 18.23M parameters for xEdgeFace–Base, 0.31 GFLOPs and 3.65M parameters for xEdgeFace–S, 0.15 GFLOPs and 1.77M parameters for xEdgeFace–XS, and 0.09 GFLOPs and 1.24M parameters for xEdgeFace–XXS. The paper contrasts these with heavy heterogeneous face recognition baselines such as CAIM, DIU, SSMB, and PDT, each at approximately 24–26 GFLOPs and 65M parameters.

The reported results indicate that parameter-efficient adaptation is effective on multiple benchmarks (George et al., 28 Apr 2025). On Tufts Face, xEdgeFace–Base with LN, ST, and S0 achieves Rank-1 $3\times3$7, VR@FAR $3\times3$8 $3\times3$9, and VR@FAR $H(\mathrm{div})$00 $H(\mathrm{div})$01. On MCXFace, the same configuration achieves AUC $H(\mathrm{div})$02, EER $H(\mathrm{div})$03, and Rank-1 $H(\mathrm{div})$04. On Polathermal it obtains $H(\mathrm{div})$05 Rank-1. On SCFace far protocol, the LN, ST configuration obtains AUC $H(\mathrm{div})$06, EER $H(\mathrm{div})$07, and Rank-1 $H(\mathrm{div})$08. On CASIA NIR-VIS 2.0, LN, ST, S0 reaches Rank-1 $H(\mathrm{div})$09, VR@FAR $H(\mathrm{div})$10 $H(\mathrm{div})$11, and VR@FAR $H(\mathrm{div})$12 $H(\mathrm{div})$13.

Ablations show that adapting LayerNorm alone is already a strong modulation point, that adding the stem and S0 improves alignment, and that adapting deeper stages can overfit when paired data are limited (George et al., 28 Apr 2025). The same paper also reports that RGB face recognition performance is largely preserved: for example, EdgeFace–Base yields LFW $H(\mathrm{div})$14, while xEdgeFace–Base adapted for VIS–Thermal yields LFW $H(\mathrm{div})$15. This suggests that the EdgeFace backbone is sufficiently stable to support spectral adaptation without catastrophic loss of standard visible-spectrum performance.

6. Comparative position among mobile face recognition models

A 2026 comparative study on FaceLiVTv2 treats EdgeFace as a representative “edge-friendly” hybrid CNN–Transformer baseline for mobile face recognition and reports direct accuracy and latency comparisons across CoreML on iPhone 15 Pro and ONNX Runtime on GPU, CPU, and Jetson AGX Orin (Setyawan et al., 10 Apr 2026). In that paper, EdgeFace-XS is listed at 1.77 M parameters and 154 MFLOPs with iPhone 15 Pro latency 5.82 ms, and EdgeFace-S at 3.6 M parameters and 306 MFLOPs with iPhone 15 Pro latency 9.89 ms.

The comparison confirms that EdgeFace remains competitive in accuracy. EdgeFace-S trained on WebFace12M is reported at LFW 99.78, CA-LFW 95.71, CP-LFW 92.56, CFP-FP 95.81, AgeDB-30 96.93, IJB-B 93.59, and IJB-C 95.63, while EdgeFace-XS reaches LFW 99.73, CA-LFW 95.28, CP-LFW 91.82, CFP-FP 94.37, AgeDB-30 96.00, IJB-B 92.67, and IJB-C 94.85 (Setyawan et al., 10 Apr 2026). Under the authors’ Glint360K retraining setup, EdgeFace-S† attains LFW 99.75, CA-LFW 95.95, CP-LFW 91.63, CFP-FP 96.13, AgeDB-30 97.48, IJB-B 93.03, and IJB-C 94.66.

The same study argues that FaceLiVTv2 improves the accuracy–latency trade-off and documents substantial latency advantages over EdgeFace (Setyawan et al., 10 Apr 2026). On iPhone 15 Pro, EdgeFace-XS at 5.82 ms is compared with FaceLiVTv2-XS at 0.43 ms, and EdgeFace-S at 9.89 ms with FaceLiVTv2-S at 0.54 ms. On ONNX Runtime GPU, the reported improvements are $H(\mathrm{div})$16 for EdgeFace-XS versus FaceLiVTv2-XS and $H(\mathrm{div})$17 for EdgeFace-S versus FaceLiVTv2-S. On CPU, the improvements are $H(\mathrm{div})$18 and $H(\mathrm{div})$19, and on Jetson AGX Orin GPU they are $H(\mathrm{div})$20 and $H(\mathrm{div})$21.

These comparisons matter because they place EdgeFace in a moving baseline hierarchy rather than as a static endpoint (Setyawan et al., 10 Apr 2026). EdgeFace’s architectural principles—EdgeNeXt-style hybridization and LoRaLin compression—remain valid, but FaceLiVTv2’s Lite MHLA, RepMix reparameterization, and GDConv embedding head are reported to extract higher throughput, especially on Apple mobile hardware. At the same time, the paper explicitly notes scenarios where EdgeFace may still be preferable: when parameter budget is extremely tight, when deployment is mainly on GPU with ONNX Runtime, or when compatibility with EdgeNeXt-based pipelines and LoRaLin operators is important.

7. Terminological ambiguity and adjacent uses of the name

Although EdgeFace is now primarily associated with lightweight face recognition, the supplied literature uses the name in additional ways. One is edge-aware face parsing. The paper “Edge-aware Graph Representation Learning and Reasoning for Face Parsing” proposes EAGRNet, which encodes a facial image into a global graph representation, aggregates pixels to vertices with an edge-weighted soft assignment, reasons over region relations with a single-layer graph convolution, and reprojects vertex features back to pixel grids for sharp semantic parsing (Te et al., 2020). The details explicitly describe “EdgeFace” as edge-aware face parsing aligned with EAGRNet’s strategy.

In that formulation, the emphasis is not face recognition but pixel-wise semantic labeling of facial components such as skin, hair, eyes, brows, nose, and mouth (Te et al., 2020). The method uses a modified ResNet-101 backbone, a Pyramid Pooling Module with pooling factors $H(\mathrm{div})$22, an edge perceiving module from Conv2, Conv3, and Conv4, edge-aware graph projection, graph reasoning by spectral GCN, graph reprojection, and a boundary-attention loss. Reported performance includes Helen Overall F1 $H(\mathrm{div})$23, CelebAMask-HQ mean F1 $H(\mathrm{div})$24, and LaPa mean F1 $H(\mathrm{div})$25. This is a distinct research line from the 2023 EdgeFace face recognition model, despite the similar label.

A second ambiguity arises from finite-element literature that does not concern faces as biometric objects at all. “Geometric Decomposition and Efficient Implementation of High Order Face and Edge Elements” studies $H(\mathrm{div})$26-conforming edge elements and $H(\mathrm{div})$27-conforming face elements on simplices, including geometric decomposition, Piola mappings, local frames, DOFs, and indexing (Chen et al., 2023). “Serendipity Face and Edge VEM Spaces” extends serendipity virtual elements to $H(\mathrm{div})$28 and $H(\mathrm{div})$29 spaces in two and three dimensions (Veiga et al., 2016). In those papers, “face” and “edge” denote element types and continuity properties, not human face analysis.

For encyclopedia purposes, the most precise usage is therefore disambiguated. EdgeFace in contemporary computer vision denotes the efficient face recognition model introduced in 2023 and the family of systems built on top of it, including biometric template protection and cross-spectral adaptation (George et al., 2023, Stragapede et al., 25 Aug 2025, George et al., 28 Apr 2025). In a separate parsing context, “EdgeFace” refers to edge-aware face parsing implemented by EAGRNet (Te et al., 2020). In numerical analysis, the juxtaposition of “edge” and “face” belongs to finite-element terminology rather than to the biometric model lineage (Chen et al., 2023, Veiga et al., 2016).