Open-source face recognition: toolkits, shipped models and training data

This page belongs to the face recognition section. It widens the InsightFace toolkit page to the other open toolkits and to the question each of them raises: which data trained the model you downloaded.

01Which open-source face recognition toolkits exist?

Three projects account for most of what papers, libraries and products reuse. OpenFace, released by Carnegie Mellon in October 2015 under the Apache 2.0 licence, re-implemented the FaceNet idea with a smaller network and a public training set (CMU-CS-16-118). InsightFace, the toolbox behind ArcFace, RetinaFace and Partial FC, is "an open source 2D&3D deep face analysis toolbox, mainly based on PyTorch and MXNet" and took first place on the VISA track of NIST's FRTE 1:1 test on 29 October 2021 using Partial FC, by its own README (deepinsight/insightface). The DeepFace library is a Python wrapper that bundles ten recognition models and nine detectors behind one call (serengil/deepface).

02What does "open source" cover: the code, the model or the data?

Not always all three, and the InsightFace README draws the line explicitly. "The code of InsightFace is released under the MIT License. There is no limitation for both academic and commercial usage", but "the training data containing the annotation (and the models trained with these data) are available for non-commercial research purposes only", and the same applies to models the Python package downloads on its own. A 24 November 2025 note in the README routes licensing requests for the open-sourced recognition packs, buffalo_l among them, to a named mailbox. The model zoo repeats the rule at the top: "ALL models are available for non-commercial research purposes only."

OpenFace sits at the other end: Apache 2.0 for the library and a model trained on two research sets. The DeepFace library is MIT for its own code but states that "License types will be inherited when you intend to utilize those models", so a project using its ArcFace or Buffalo_L option inherits InsightFace's terms. The datasets and consent page in this section records what happened to several of the training sets these models were built from.

03Which training sets sit behind the shipped models?

Every model in the table above was trained on faces of real people gathered from the internet, and the counts come from the InsightFace datasets README. CASIA-WebFace holds 10K identities and 0.5M images; VGGFace2 9K and 3.31M; MS1M-ArcFace, also called MS1MV2, 85K and 5.8M; Glint360K 360K and 17M; the MegaFace training set 672K and 4.7M. OpenFace's 500k-image set combined CASIA-WebFace with FaceScrub, against what its authors describe as FaceNet's private 100M to 200M images and DeepFace's private 4.4M. WebFace600K, the set behind InsightFace's default pack, appears in the model zoo without a count; the same datasets README lists WebFace260M, the collection this domain once distributed and the WebFace260M paper page describes at 4M identities and 260M faces before cleaning, with a link to this site's download page.

The training set matters because the loss is shared. ArcFace's additive angular margin, described on the ArcFace page in this section, is the default loss in the InsightFace zoo, and Partial FC exists because "the memory and computing cost of the Fully Connected (FC) layer linearly scales up to the number of identities in the training set" (arXiv 2203.15565): a method for training on more identities, not a new loss.

04How much does the training set move the score?

The InsightFace model zoo publishes the cleanest answer: one IResNet-50, one loss, six training sets, scored on the same test sets. LFW accuracy runs from 99.45 (CASIA-WebFace) through 99.55 (VGGFace2), 99.83 (MS1MV2), 99.80 (MS1MV3) and 99.82 (Glint360K) to 99.80 (WebFace600K). IJB-C true accept rate at a false accept rate of one in ten thousand runs from 87.22 through 91.22, 96.14, 96.58 and 97.13 to 97.12 on the same six models. The default buffalo_l pack scores 99.83 on LFW and 97.25 on IJB-C.

Two things follow. LFW no longer separates models: a 0.38-point spread on the 6,000 pairs of the LFW pairs protocol is about 23 pairs, which is why the verification metrics explained page sends readers to a true accept rate at a fixed false accept rate. And a published score with no training set named is incomplete: the same architecture spans 9.91 points on IJB-C with nothing changed but the data. The lesson carries across to detection, where the self-blended images detector shows the training data, not the backbone, carrying most of a cross-dataset gain.

05How do the toolkits compare on the same test?

The DeepFace library's benchmarks README scores its ten wrapped models on LFW under every combination of detector, distance and alignment it offers, and the spread between models is far larger than the spread between training sets above. With RetinaFace detection, euclidean_l2 distance and alignment on, Facenet512 scores 98.4, ArcFace 96.6, Facenet 96.4, VGG-Face 95.8, SFace 92.4, GhostFaceNet 90.5, Dlib 89.1, OpenFace 69.4, DeepFace 67.7 and DeepID 64.4, against the 97.5 the README gives for humans. The same README puts the effect of detection at up to 42 percent and alignment at up to 6 percent, and with detection skipped Facenet512 falls to 92.0 and ArcFace to 56.6.

Those are the library maintainer's runs of ported weights, not the original papers' figures. OpenFace's own report gives 0.9292 ± 0.0134 on the LFW restricted protocol for its nn4.small2 model, against 0.9964 for FaceNet, 0.9735 for the DeepFace ensemble and 0.9753 for cropped human-level performance; the DeepFace library's 69.4 for its OpenFace port is a different pipeline and a different threshold rule. A score always belongs to the pipeline that produced it.

06What is not in a toolkit's README?

Three things a deployment needs are missing from the READMEs above. The InsightFace zoo prints per-group columns for its own test, but none of the three toolkits reports a breakdown on operational data of the kind NIST publishes, and the NIST's FRTE 1:1 track page explains why a submission there, not a GitHub table, is the comparable figure. The READMEs give no error rate at a false accept rate of one in a million, the operating point the MegaFace authors argued a million-scale gallery needs. And none of the three ships a liveness check inside the recognition model; the audio field's cost-weighted anti-spoofing metrics show what it costs to score a verifier and its guard together, a question the face toolkits leave to their users.