FaceNet: A Unified Embedding for Face Recognition and Clustering

“FaceNet: A Unified Embedding for Face Recognition and Clustering” by Florian Schroff, Dmitry Kalenichenko and James Philbin of Google was presented at the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) in June 2015, three months after a first version appeared on arXiv. It trained a convolutional network to map a tightly cropped face image directly to a 128-dimensional, unit-length embedding, so that squared Euclidean distance between two embeddings measures how likely the faces are to be the same person. The training signal was a triplet loss on an anchor, a positive of the same identity and a negative of another, with negatives chosen online inside very large mini-batches by a “semi-hard” rule. Trained on 100 to 200 million face thumbnails of about 8 million identities from Google’s private data, the system reported 99.63% accuracy on Labeled Faces in the Wild (LFW) and 95.12% on YouTube Faces DB. The task, its pipeline and its benchmarks are covered in face recognition, and the loss and its mining strategies as understood today in triplet loss; this article covers the paper as published. The CVPR text and the three arXiv versions differ in places, most visibly in an appendix on “harmonic embeddings” that only arXiv v2 and v3 contain; details are attributed to the version that has them.

Problem

The paper frames the state of the art as two strands of deep face recognition from 2014, both of which learned their representation by classifying identities. DeepFace (Taigman et al., 2014) aligned each face to a generic 3D shape model, trained a network to classify the 4,030 identities of an internal set of 4.4 million faces, and used a hidden layer as the face descriptor; FaceNet attributes its best LFW result, 97.35%, to an ensemble of three networks with different alignments and colour channels combined by a non-linear SVM; in DeepFace that three-network ensemble gives 97.15%, and 97.35% comes after adding a Siamese network and four more networks trained from different random seeds. The DeepID line of Sun, Wang and Tang classified about 10,000 celebrities from many face patches (Sun, Wang & Tang, 2014), then added a verification term to the identification loss (DeepID2; Sun et al., 2014), and its DeepID2+ version reported 99.47% ± 0.12 on LFW and 93.2% ± 0.2 on YouTube Faces with 25 networks (Sun, Wang & Tang, 2015). FaceNet describes these systems as multi-stage: a network, then PCA, a Joint Bayesian model or SVMs on top.

The authors’ objection was to the indirectness of using an intermediate “bottleneck” layer of a classifier: one has to hope that a layer trained to separate the training identities generalizes to new people, and such layers usually have thousands of dimensions, which the PCA step then reduces by what the paper calls a linear transformation that one network layer could learn. They also point out that the verification loss of DeepID2 is a loss on pairs, which pulls all faces of one identity toward a single point, whereas a triplet constraint only asks that each identity’s faces stay a margin away from other identities, allowing them to “live on a manifold”. The authors state that they did not compare the two losses directly. A similar triplet loss had been used by Wang et al. (2014), with Philbin as a co-author, for ranking images by fine-grained similarity; FaceNet describes its own loss as based on large margin nearest neighbors (LMNN; Weinberger, Blitzer & Saul, 2005). The background is set out in metric learning.

Contribution

The abstract and introduction claim:

1. A direct embedding. A deep network trained end to end so that its $\ell_2$-normalized output is the representation, with squared $\ell_2$ distance as the similarity; verification becomes thresholding a distance, recognition a k-nearest-neighbour classification, and clustering an off-the-shelf algorithm such as k-means or agglomerative clustering.
2. Triplet training with online mining. Triplets of “roughly aligned” face patches, with negatives mined online by a strategy the authors describe as inspired by curriculum learning, so that triplets grow harder as the network trains.
3. Compactness. State-of-the-art accuracy with 128 bytes per face.
4. Minimal alignment. The thumbnails are tight crops of the face, with no 2D or 3D alignment beyond scale and translation.
5. Harmonic embeddings (arXiv v2 and v3 only): embeddings produced by two different networks that can be compared with each other, learned with a “harmonic triplet loss”.

The introduction also says the authors explored hard-positive mining to encourage spherical clusters for clustering; the method section instead uses all anchor–positive pairs, and no results for hard-positive mining are reported.

Method

The loss as printed

The network output $f(x) \in \mathbb{R}^d$ is constrained to the unit hypersphere, $\lVert f(x) \rVert_2 = 1$, with $d = 128$. Eq. 1 states the constraint every triplet $(x_i^a, x_i^p, x_i^n)$ in the set $\mathcal{T}$ of all possible triplets should satisfy, and Eq. 2 the hinge loss summed over triplets, with margin $\alpha = 0.2$ (§3.3). The two equations differ between versions. In the CVPR text and arXiv v1, Eq. 1 is written on the images themselves,

$$\lVert x_i^a - x_i^p \rVert_2^2 + \alpha < \lVert x_i^a - x_i^n \rVert_2^2 ,$$

while Eq. 2, the loss, is written on embeddings, $\sum_i \big[\lVert f(x_i^a) - f(x_i^p) \rVert_2^2 - \lVert f(x_i^a) - f(x_i^n) \rVert_2^2 + \alpha\big]_+$. Versions 2 and 3 on arXiv write the constraint with $f(x)$ as well, which is what the text means, and number its “for all triplets” clause separately as Eq. 2, so that every later equation number in those versions is one higher than in the CVPR text: the loss is Eq. 3 and the semi-hard condition Eq. 4. Equation numbers below are the CVPR text’s. On unit vectors, $\alpha = 0.2$ in squared distance is a cosine gap of 0.1, as derived in the triplet loss article; the squared distance ranges from 0 to 4, and Figure 1 shows pairs from the CMU PIE database whose distances a threshold of 1.1 would separate.

Triplet selection

Section 3.2 is the part of the paper later work engaged with most. The ideal hard examples would be, for each anchor, the farthest positive and the closest negative, but computing them over the whole training set is infeasible, and the paper adds that it would let mislabelled and poorly imaged faces dominate. It names two alternatives: generating triplets offline every $n$ steps with the latest checkpoint on a subset of the data, or online, by selecting hard examples within a mini-batch. The paper uses online selection:

• Batch construction. In most experiments, mini-batches of around 1,800 exemplars, sampled so that about 40 faces of each identity are present, plus randomly sampled negative faces. The paper says the batch size is set mainly by the need to find relevant hard triplets in it, although small batches tend to improve convergence under stochastic gradient descent.
• All positives. Instead of the hardest positive, every anchor–positive pair in the batch is used; without a side-by-side comparison, the authors found this more stable and slightly faster to converge early in training.
• Semi-hard negatives. Choosing the hardest negatives “can in practice lead to bad local minima early on in training”, including a collapsed model with $f(x) = 0$. The paper therefore selects negatives satisfying Eq. 3, $\lVert f(x_i^a) - f(x_i^p) \rVert_2^2 < \lVert f(x_i^a) - f(x_i^n) \rVert_2^2$, calls them semi-hard, and adds that they lie inside the margin $\alpha$. Eq. 3 itself sets no upper bound, and the paper does not say which of the qualifying negatives is taken; later work filled in these details differently, as described in triplet loss.
• Offline plus online. Combining offline triplet generation with online selection might allow smaller batches, but the experiments were “inconclusive”.

Training

The networks were trained from random initialization with stochastic gradient descent, backpropagation and AdaGrad, usually starting at a learning rate of 0.05 that was lowered to finalize the model, on a CPU cluster for 1,000 to 2,000 hours (the statement that models start from random, “similar to” GoogLeNet, is in the CVPR text and arXiv v2–v3 but not v1). The decrease in loss slowed drastically after about 500 hours, but further training still improved performance significantly. The acknowledgments thank the team behind DistBelief, the distributed training system the paper cites. All networks use rectified linear units.

The training data, “if not mentioned otherwise”, were 100 to 200 million face thumbnails of about 8 million identities. A face detector produced a tight bounding box around each face, and the crop was resized to the network’s input size, from $96 \times 96$ to $224 \times 224$ pixels. The paper says nothing else about where the images came from, how the identities were labelled or who is in them.

Architectures

Two families are compared, with “FLOPS” counted as multiply-adds (the axis label of Figure 4). The first, NN1 (Table 1), is a Zeiler–Fergus network (Zeiler & Fergus, 2014) with $1 \times 1$ convolutions inserted between its convolutional layers, as suggested by Network in Network (Lin, Chen & Yan, 2014), local response normalization, max pooling and two fully connected maxout layers; it is 22 layers deep and takes $220 \times 220$ inputs. The second family follows the Inception design of GoogLeNet, the ILSVRC 2014 winner from the same company. Table 2 gives NN2 in full: “almost identical” to GoogLeNet, with $\ell_2$ pooling (the $\ell_2$ norm over each $3 \times 3$ window, as arXiv v3 alone spells out) instead of max pooling in several modules, an average pool, a fully connected layer to 128 dimensions and $\ell_2$ normalization.

Model	Base	Input	Parameters	FLOPS
NN1	Zeiler–Fergus + $1 \times 1$ convolutions	$220 \times 220$	140M	1.6B
NN2	Inception	$224 \times 224$	7.5M	1.6B
NN3	Inception, as NN2	$160 \times 160$	not printed	not printed
NN4	Inception, no $5 \times 5$ convolutions in the higher layers	$96 \times 96$	not printed	285M
NNS1	“mini” Inception	$165 \times 165$	26M	220M
NNS2	“tiny” Inception	$140 \times 116$	4.3M	20M

Input sizes for NNS1 and NNS2 are from Table 3 of the CVPR text and arXiv v2–v3; arXiv v1 omits them. Reading Table 1, 137M of NN1’s 140M parameters are in its two fully connected maxout layers (103M and 34M), which, in our reading, accounts for the “20× fewer parameters” of the Inception models. The text gives the Inception models as 6.6M–7.5M parameters and “up to 5× fewer FLOPS (between 500M–1.6B)”, a range that does not include NN4’s printed 285M. NNS1 is described as dramatically reduced for mobile phones, yet by the printed numbers it has more parameters than NN2. The authors also report that $5 \times 5$ convolutions can be removed throughout with only a minor drop in accuracy, and that NNS2 runs at 30 ms per image on a mobile phone.

Evaluation Protocol

Section 4 defines verification at a squared-$\ell_2$ threshold $d$. With $\mathcal{P}_{\text{same}}$ and $\mathcal{P}_{\text{diff}}$ the sets of same-identity and different-identity pairs, the true accepts $\mathrm{TA}(d)$ and false accepts $\mathrm{FA}(d)$ are the pairs of each set with distance at most $d$, and

$$\mathrm{VAL}(d) = \frac{|\mathrm{TA}(d)|}{|\mathcal{P}_{\text{same}}|}, \qquad \mathrm{FAR}(d) = \frac{|\mathrm{FA}(d)|}{|\mathcal{P}_{\text{diff}}|} ,$$

so VAL at a stated FAR is the true accept rate of the ROC curve at that false accept rate. Four test sets are used:

• Hold-out test set. About one million images with the training distribution but disjoint identities, split into five sets of 200,000 images; VAL and FAR are computed on 100k × 100k image pairs per split, and the standard error is reported across the five splits.
• Personal photos. Three personal photo collections, about 12,000 images in all, with a distribution similar to training but manually verified labels; VAL and FAR are computed over all pairs.
• LFW, under the protocol for “unrestricted, labeled outside data”, reporting mean accuracy and the standard error of the mean. The paper cites only the original 2007 LFW report; the protocol is one of six defined in the 2014 update (Huang & Learned-Miller, 2014), whose rules are summarized in Labeled Faces in the Wild.
• YouTube Faces DB (Wolf, Hassner & Maoz, 2011), the same setup with pairs of videos.

Both in-house sets are private, so none of the ablations below can be reproduced or compared with other systems.

Results

Architectures and computation

Table 3 reports VAL at FAR $= 10^{-3}$ on the hold-out set, mean ± standard error over the five splits:

Model	VAL at $10^{-3}$ FAR
NN1 (Zeiler–Fergus, $220 \times 220$)	87.9% ± 1.9
NN2 (Inception, $224 \times 224$)	89.4% ± 1.6
NN3 (Inception, $160 \times 160$)	88.3% ± 1.7
NN4 (Inception, $96 \times 96$)	82.0% ± 2.3
NNS1 (mini Inception, $165 \times 165$)	82.4% ± 2.4
NNS2 (tiny Inception, $140 \times 116$)	51.9% ± 2.9

The authors conclude that the top models of the two families perform comparably, while some Inception models, NN3 in particular, keep good accuracy with far fewer FLOPS and parameters. Figure 4 plots VAL at $10^{-3}$ FAR against FLOPS for many more models and shows what the paper calls a strong correlation between computation and accuracy; for parameters, the picture is “not as clear”, since NN2 matches NN1 with a twentieth of the parameters at comparable FLOPS. The text says Figure 4 uses the personal-photos set, not the hold-out set of Table 3, and its points do not match the table: NNS2 sits at about 66% in the figure, as read from the plot, against 51.9% in the table. Figure 5 gives full ROC curves on the personal photos for NN2, NN1, NNS1 and NNS2; the authors attribute a sharp drop below $10^{-4}$ FAR to label noise, since at such rates a single mislabelled image moves the curve, and judge even NNS2 accurate enough for face clustering.

Image quality, dimensionality and data

Three ablations probe robustness and scale (Tables 4–6):

• JPEG quality and image size (NN1, first hold-out split, VAL at $10^{-3}$ FAR, which the caption calls “10E-3 precision”). VAL is 86.5% at JPEG quality 90, 85.5% at 50, 81.4% at 20 and 67.3% at 10. By image area it is 86.4% at 65,536 pixels, 85.7% at 25,600, 84.5% at 14,400, 79.5% at 6,400 and 37.8% at 1,600; the text calls the drop very small down to $120 \times 120$ thumbnails and acceptable at $80 \times 80$, although the network was trained on $220 \times 220$ inputs, and suggests that training on lower-resolution faces could extend this.
• Embedding dimensionality (NN1, hold-out set). 64 dimensions gave 86.8% ± 1.7, 128 gave 87.9% ± 1.9, 256 gave 87.7% ± 1.9 and 512 gave 85.6% ± 2.0. The authors call the differences statistically insignificant and suggest larger embeddings might need more training. They chose 128 and add that the float vector can be quantized to 128 bytes without loss of accuracy, which is the “128 bytes per face” of the abstract.
• Training data (a smaller model with $96 \times 96$ inputs, like NN2 without $5 \times 5$ convolutions, after 700 hours of training, on the personal photos). 2.6 million images gave 76.3%, 26 million 85.1%, 52 million 85.1% and 260 million 86.2%. The text states that going from millions to tens of millions of images gave a 60% relative reduction in error and that hundreds of millions still helped a little, with the gain “tapering off”. The table does not give 60% if error is read as $1 - \mathrm{VAL}$: by our arithmetic, 23.7% to 14.9% is a 37% reduction. The paper does not say how it computed the figure. The largest run exceeds the 100–200 million images of the main experiments.

LFW

On LFW the threshold on squared $\ell_2$ distance was selected on nine training folds and applied to the tenth; it came out at 1.242 for every split except the eighth (1.256). NN1 was evaluated in two modes:

1. a fixed centre crop of the LFW thumbnail: 98.87% ± 0.15;
2. crops from a proprietary face detector, described as similar to Picasa, run on the thumbnails, falling back to the LFW alignment for the two images where it failed: 99.63% ± 0.09.

The paper calls the second mode “extra face alignment” and the result “record breaking”; the LFW results page lists FaceNet at 0.9963 ± 0.0009 in its unrestricted, labeled outside data category. The authors state that the error is less than a seventh of DeepFace’s and 30% below DeepID2+’s, and that the much smaller NN3 is not statistically significantly different from NN1. Figure 6 shows every misclassified pair. In arXiv v3 its caption adds that only eight of the 13 false rejects are real errors and the other five pairs are mislabelled in LFW; v2 says “the other four”, which does not add up to 13, and the CVPR text has no such sentence. The summary adds that a similarity-transform alignment, tried during the work, “can actually improve performance slightly”, with no number given.

YouTube Faces

For each video pair the paper averages the similarity of all pairs among the first 100 frames in which its detector finds a face, giving 95.12% ± 0.39; using the first 1,000 frames gives 95.18%. FaceNet compares this with DeepFace’s 91.4%, which “also” used 100 frames per video; DeepFace in fact averaged 100 randomly sampled frame pairs, one frame from each video (Taigman et al., 2014). Against DeepID2+’s 93.2%, the paper states a 30% reduction in error, as on LFW. By our arithmetic the YouTube Faces reduction is 28% (from 6.8% to 4.88% error) and the LFW one 30% (from 0.53% to 0.37%).

Face clustering

Clustering, one of the three tasks in the title, is evaluated only qualitatively: Figure 7 shows one cluster from a user’s personal photo collection, produced by agglomerative clustering, which the authors present as showing invariance to occlusion, lighting, pose and age. No clustering metric, dataset size or comparison is reported.

Harmonic Embeddings

Appendix 7 of arXiv v2 and v3 introduces harmonic embeddings: embeddings from two models, v1 and v2, that are compatible in the sense that they can be compared with each other. The motivation given is upgrades: when v1 embeddings have been computed for a large set of images and a new model is rolled out, compatibility avoids recomputing them. To learn one, the harmonic triplet loss mixes v1 embeddings with the v2 embeddings being trained inside the triplet loss, so that a triplet’s anchor and positive are both v2 embeddings or one of each version, with semi-hard negatives selected from the whole set of both (Figure 9, whose diagram labels the two versions “v7 template” and “v8 template”). The v2 network was initialized from an independently trained NN2; first only its embedding layer was retrained from random initialization with this loss, then the whole network.

Figure 8 shows ROC curves on a “3G dataset” that the paper does not otherwise describe: NN2 alone is best, NN1 alone worst, and NN2 embeddings compared against NN1 embeddings fall in between, so the mixed mode still beats NN1 by itself. Figure 10 sketches the authors’ interpretation, that most v2 embeddings land near their v1 counterparts while badly placed ones move slightly to better positions. The authors call the result “somewhat surprising” and suggest compatible small mobile models as future work. No numbers are given. Shen et al. (2020) later addressed the same problem as backward-compatible representation learning; they cite FaceNet only among losses on pairs and triplets, not for harmonic embeddings.

Versions

Version	Date	Differences
arXiv v1	12 March 2015	Constraint (Eq. 1) on images; semi-hard condition Eq. 3; VAL and FAR as separate Eqs. 6 and 7; no input sizes for NNS1/NNS2 in Table 3; Figure 4 labels its axis “Accuracy @10-3 Recall” and marks four models (NN1, NN2, NNS1, NNS2); no “initialized from random” statement
arXiv v2	4 June 2015	Adds harmonic embeddings (abstract sentence, Appendix 7, Figures 8–10); constraint on embeddings $f(x)$, numbered as Eqs. 1–2, so the loss is Eq. 3, the semi-hard condition Eq. 4 and VAL and FAR Eq. 7; input sizes in Table 3; “initialized from random”; Figure 4 as in the CVPR text; Figure 6 caption on mislabelled LFW pairs (“the other four”)
arXiv v3	17 June 2015	Figure 6 caption corrected to 13 false rejects, five mislabelled; Table 2 caption explains $\ell_2$ pooling; minor wording
CVPR 2015	June 2015, pp. 815–823	v1’s equations (constraint on images, semi-hard Eq. 3), except that VAL and FAR share one Eq. 6; no harmonic embeddings and no Figure 6 sentence; input sizes in Table 3, “initialized from random”, and Figure 4 relabelled “VAL @10-3 FAR” with six models marked, as in v2–v3

The CVPR text was read in the CVF open-access copy, which carries the proceedings page numbers; the IEEE Xplore copy was not read. The arXiv comments field of v3 says the paper was also published in the CVPR 2015 proceedings. All results tables are the same in every version. In the CVPR text, Figure 4’s caption still says four models are highlighted, the text names five (NN1, NN2, NN3, NNS1, NNS2) and the figure marks six, including NN4; the caption fitted v1’s figure.

Impact

The paper presented its LFW result as a new record and its YouTube Faces result as a 30% error reduction over DeepID2+, and later comparison tables list it with its training-set size: CosFace gives 99.63% on LFW and 95.1% on YouTube Faces with 200 million images, SphereFace 99.65% (not the printed 99.63%) and 95.1%. The training set itself was cited to illustrate the gap between industrial and public data: the VGG face paper (Parkhi, Vedaldi & Zisserman, 2015) contrasts its 2.6 million images with Google’s 200 million images of 8 million identities, and the MegaFace benchmark notes that such data are not available to the public (Kemelmacher-Shlizerman et al., 2016). MegaFace evaluated a newer Google model, “FaceNet v8”, trained on more than 500 million photos of more than 10 million people and run without uploading its features, which licensing conditions prevented; with one million distractors it reached a rank-1 identification rate of 70.49% on the FaceScrub probes, second to NTechLab’s large model at 73.30%, and 74.59% on the age-varied FGNet probes, the highest in the table.

The recipe was taken up quickly. Parkhi et al. (2015) pretrained a network by identity classification and then learned a 1,024-dimensional projection with a triplet loss “similar in spirit” to FaceNet’s, sampling negatives at random among those that violate the margin; on LFW this step raised their score (100% minus the equal error rate) from 97.27% to 99.13%. OpenFace (Amos, Ludwiczuk & Satyanarayanan, 2016), released in October 2015 under the Apache 2.0 licence, reimplemented the approach in Torch for researchers without private data: FaceNet’s triplet loss with $\alpha = 0.2$ and 128 dimensions, a reduced version of the NN4 network (“nn4.small2”) on $96 \times 96$ inputs, faces aligned by a 2D affine transformation from dlib landmarks rather than FaceNet’s tight crop, and about 500,000 training images from CASIA-WebFace and FaceScrub. It reported 0.9292 ± 0.0134 on LFW. Its batches sampled at most 20 images of each of 15 people, used all anchor–positive pairs, and skipped a pair when no negative fell within the margin. (OpenFace’s comparison table lists FaceNet as 0.9964 ± 0.009, not the printed 99.63% ± 0.09.) David Sandberg’s TensorFlow repository, which describes itself as an implementation of FaceNet and as heavily inspired by OpenFace, kept a triplet-loss training script, but its README at the last commit (April 2018) states that the best results came from training with a softmax loss, and its released models were trained that way on CASIA-WebFace and VGGFace2. Within Google, the MobileNets paper (Howard et al., 2017), with Kalenichenko among its authors, distilled FaceNet into small networks by minimizing the squared difference between their outputs; its FaceNet baseline, at 1,600 million multiply-adds and 7.5 million parameters, has NN2’s printed size, and the results are discussed in the MobileNets paper article.

Limitations

• Private data and evaluation. The training set of 100 to 200 million images, the one-million-image hold-out set and the personal-photo collections are Google’s, and the paper releases no data, code or models. Every ablation in Tables 3 to 6 is on private data, and only the LFW and YouTube Faces numbers can be compared with other work.
• Nothing on who is in the data. The paper gives no information on the composition of its training or test sets, by age, sex, skin tone or anything else, and reports no breakdown of errors by group; NIST’s later measurements of demographic differentials are summarized in face recognition.
• Compute. One to two thousand CPU-cluster hours per model, with the loss decrease slowing after 500 hours; the authors list the “extremely long training times” as future work. Wu et al. (2017) cite FaceNet’s slowdown as consistent with their argument that semi-hard mining runs out of examples within its narrow band, and give the final system’s training time as 80 days.
• Unspecified selection details. Eq. 3 and the text disagree about the upper bound of a semi-hard negative, the rule for choosing among qualifying negatives is not given, and the batch size of about 1,800 was set by the mining rather than by optimization.
• Saturated benchmarks. On LFW’s 6,000 test pairs, 99.63% leaves about 22 errors by our arithmetic, of which, by the arXiv v3 caption, five false rejects are labelling errors in LFW. Comparisons at this level are subject to the cautions in benchmark overfitting and statistical significance in evaluation.
• Claims without numbers. Clustering, similarity-transform alignment and harmonic embeddings are supported by an example figure, a sentence and ROC curves on an undescribed dataset respectively.

What Came After

Wu et al. (2017) describe semi-hard mining, which they credit FaceNet with first using, as widely adopted for the triplet loss. They formalized it as taking, for each anchor–positive pair, the closest negative farther away than the positive, and argued that it soon finds no examples left in its band; they proposed distance-weighted sampling instead. Hermans, Beyer and Leibe (2017) defended the triplet loss for person re-identification, observing that FaceNet’s huge batch with moderate mining “can only be done on the CPU”, and proposed hardest-in-batch mining in small batches that fit on a GPU. These strategies are compared in triplet loss and metric learning.

Much of the later face recognition work returned to classification over identities, with a margin. SphereFace (Liu et al., 2017) argued that contrastive and triplet losses need carefully designed pair or triplet mining that is “both time-consuming and performance-sensitive”; in its own reimplementation on CASIA-WebFace with one 64-layer network, a triplet loss reached 98.70% on LFW and 93.4% on YouTube Faces, against 99.42% and 95.0% for SphereFace. ArcFace (Deng et al., 2019) named a combinatorial explosion of triplets on large datasets and the difficulty of semi-hard mining as the triplet loss’s two drawbacks, and found in an ablation that adding a triplet loss to ArcFace brought no improvement. These margin-based softmax losses, which need no mining but keep one weight vector per training identity, are covered in ArcFace. These losses keep FaceNet’s test-time formulation, a compact, normalized embedding compared by distance or cosine on people absent from training, and change how it is trained.