Face Verification Matches One Pair at a Time

Face verification answers one narrow question about a pair of photos, same person or not, by checking whether their embeddings land close enough together to clear a threshold.

Verification thresholds one number: a dot product of 0.909 over norms of 0.9115 gives cosine 0.997, which clears the 0.60 operating point as confidently the same person

Why Does This Exist?

Unlocking a phone and searching a crowd look similar but are different tasks. Search is one-to-many: find this face among millions. Unlocking is one-to-one: is this the owner, yes or no. Confusing the two produces bad systems, because a threshold tuned for search lets strangers into phones. Face verification exists as the narrow one-to-one decision with its own metrics and trade-offs. Embeddings come from networks trained with losses such as triplet loss or ArcFace, and the surrounding pipeline is in face detection and recognition.

Think of It Like This

A key and a lock

A lock never asks which key you are among all keys ever made. It asks one question: does this key shape match mine within tolerance. Too loose and any key turns (a false accept); too tight and your own key sticks on cold mornings (a false reject). Face verification is a lock. The embedding is the key shape, the threshold is the tolerance, and tuning it picks your position between break-ins and lockouts. Where it stops: a lock tolerance is fixed metal, while a threshold is a number you set from validation data and must reset when cameras or lighting change.

How It Actually Works

Both photos are detected, aligned, embedded and L2-normalized. The system computes cosine similarity (equivalently, squared Euclidean distance on unit vectors) and accepts the pair as same-person when the score passes a threshold chosen on held-out pairs. Moving the threshold traces the ROC curve: raising it cuts false accepts but grows false rejects, and the operating point near 0.60 used below is typical for normalized face embeddings, not universal.

A worked decision

Take toy 4D embeddings $a = (0.8, 0.1, 0.5, -0.2)$ and $b = (0.78, 0.15, 0.48, -0.15)$ . The dot product is $0.8 \times 0.78 + 0.1 \times 0.15 + 0.5 \times 0.48 + (-0.2) \times (-0.15) = 0.624 + 0.015 + 0.24 + 0.03 = 0.909$ . The norms are $\sqrt{0.64 + 0.01 + 0.25 + 0.04} = \sqrt{0.94} \approx 0.9695$ and $\sqrt{0.6084 + 0.0225 + 0.2304 + 0.0225} = \sqrt{0.8838} \approx 0.9401$ , whose product is $0.9695 \times 0.9401 \approx 0.9115$ . Cosine similarity is $0.909 / 0.9115 \approx 0.997$ . Against an operating threshold of 0.60 this pair is confidently accepted as the same person, with a margin of about 0.40.

Code

The snippet below recomputes the worked decision with only the standard library: dot product, both norms, and the cosine score against the 0.60 threshold.

1import math2
3a = (0.8, 0.1, 0.5, -0.2)4b = (0.78, 0.15, 0.48, -0.15)5
6dot = sum(x * y for x, y in zip(a, b))7na = math.sqrt(sum(x * x for x in a))8nb = math.sqrt(sum(y * y for y in b))9cos = dot / (na * nb)10
11print(round(dot, 3))              # -> 0.90912print(round(na * nb, 4))          # -> 0.911513print(round(cos, 3))              # -> 0.99714print(cos > 0.60)                 # -> True

The pair scores 0.997, well above 0.60, so the system accepts. The same three lines settle any pair: change the vectors and the verdict follows without touching the logic.

Watch Out For

Tuning the threshold on the wrong population

A threshold picked on clean studio portraits fails on nightclub selfies because the score distributions shift. The symptom is a sudden spike in false rejects after deployment, with genuine users locked out daily. Fix it by calibrating the threshold on pairs sampled from your actual cameras, lighting and demographics, and re-calibrating whenever any of those change.

Skipping liveness next to the matcher

A threshold only compares pixels, so a printed photo or a screen replay of the owner scores 0.997 just like the live face. The symptom is a verification log full of confident accepts during a presentation attack. Fix it by pairing verification with a liveness check such as blink, depth or texture analysis, because similarity alone cannot tell a face from a picture of one.

The Quick Version

Verification is one-to-one matching with a threshold; identification is one-to-many search.
Both faces are embedded and compared with cosine similarity or Euclidean distance.
The worked pair scores 0.909 over 0.9115, giving cosine 0.997 against a 0.60 threshold.
The threshold trades false accepts against false rejects along a ROC curve.
Thresholds must be calibrated on deployment-like pairs, and liveness checks block photo spoofs.