Cosine Similarity Face Matching

mediumPROFace RecognitionRecognitionCV: Recognition

Implement face verification using cosine similarity between face embeddings. The goal is to determine if two faces match by comparing their embedding vectors.

Face recognition networks output embedding vectors, which are dense representations of facial features. The similarity between two faces can be measured using the cosine similarity formula, which calculates the dot product of two vectors divided by the product of their magnitudes.

Here are the steps to calculate cosine similarity:

Obtain face embedding vectors from a face recognition network.
Calculate the dot product of the two embedding vectors.
Calculate the magnitudes of the two embedding vectors.
Compute the cosine similarity using the formula.

\text{similarity} = \frac{\mathbf{e}_1 \cdot \mathbf{e}_2}{\|\mathbf{e}_1\| \|\mathbf{e}_2\|} = \cos(\theta)

Output

Return a list of (index, similarity) tuples for every stored embedding whose similarity is greater than or equal to threshold. Round each similarity to 2 decimal places and order the list from highest to lowest similarity.

This technique is widely used in security and surveillance systems.

Example

Input

embeddings = [[1,0,0], [0,1,0], [0.9,0.1,0]]
query = [1, 0, 0]
threshold = 0.8

Output

[(0, 1.0), (2, 0.99)]

Reasoning

embeddings holds $N = 3$ stored face vectors with $D = 3$ features each; query is the face to identify, and threshold $= 0.8$ is the lowest cosine score that still counts as a match.
Magnitudes: the query and rows 0 and 1 all have length $1$ ; row 2 has length $\sqrt{0.9^2 + 0.1^2} = \sqrt{0.82} \approx 0.9055$ .
Row 0 matches the query's direction: dot product $1$ , so $\cos\theta = \frac{1}{1 \cdot 1} = 1.0$ .
Row 1: dot product $0 \cdot 1 + 1 \cdot 0 + 0 \cdot 0 = 0$ , so the vectors are perpendicular and $\cos\theta = 0.0 < 0.8$ , so it is rejected.
Row 2: dot product $0.9$ , so $\cos\theta = \frac{0.9}{0.9055 \cdot 1} \approx 0.9939$ , rounding to $0.99 \ge 0.8$ , a match.
The output [(0, 1.0), (2, 0.99)] pairs each matching index with its rounded score, best first. Notice row 2 scores high: cosine similarity depends only on the angle, so rescaling an embedding never changes its score.

Constraints

embeddings: List of face embedding vectors (N, D)
query: Query face embedding (D,)
threshold: Similarity threshold for matching
Return: List of (index, similarity) for matches above threshold

Learn this in

RecognitionCV Study Plan Visual SLAM & Localization3D Computer Vision

More from CV: Recognition

Face Alignment with Landmarkshard Mean Intersection over Union (mIoU)hard Top-K Accuracy Computationhard Optimal Verification Thresholdmedium Cosine Similarity for Face Verificationeasy

Concept primerPREVIEW

Cosine Similarity Face Matching: Background & Strategy

Background Knowledge

Face Embeddings and Vector Representations

Face recognition networks (typically deep convolutional neural networks) don't output class labels directly. Instead, they produce embedding vectors—high-dimensional numerical representations that encode the facial features of a person. These embeddings are learned such that faces of the same person cluster together in embedding space, while faces of different people are pushed apart. The key insight is that you don't need to compare raw pixel values; instead, you compare these learned feature representations, which are far more robust to variations in lighting, pose, and expression.

Cosine Similarity as a Distance Metric

Cosine similarity measures the angle between two vectors in high-dimensional space, ranging from -1 (opposite directions) to 1 (identical directions). Unlike Euclidean distance, cosine similarity is scale-invariant—it only cares about direction, not magnitude. This makes it ideal for embeddings because it's robust to variations in how the embedding vectors are normalized. The formula $\cos(\theta) = \frac{$ \mathbf{e} $_1 \cdot$ \mathbf{e} $_2}{\|$ \mathbf{e} $_1\| \|$ \mathbf{e} $_2\|}$ computes the dot product of normalized vectors. In practice, if embeddings are already L2-normalized (unit vectors), the cosine similarity simplifies to just the dot product.

Threshold-Based Decision Making

Face verification is a binary classification problem: given two embeddings, decide if they belong to the same person. A similarity threshold (typically 0.5–0.7) acts as the decision boundary. Similarities above the threshold indicate a match; below indicate different people. The choice of threshold involves a trade-off: lower thresholds increase false positives (incorrectly matching different people), while higher thresholds increase false negatives (missing genuine matches).

Algorithm/Approach

The general pattern for cosine similarity face matching follows these stages:

Extract embeddings from a pre-trained face recognition model (e.g., InsightFace, FaceNet)
Compute cosine similarity between pairs of embeddings
Apply threshold to make a binary decision (match or no match)
Evaluate performance using metrics like accuracy, precision, and recall

This is a straightforward similarity-based matching approach, contrasting with more complex methods like knowledge distillation or attention mechanisms that optimize the embeddings themselves.

Step-by-Step Strategy

Step 1: Understand the Input Format

You'll receive two embedding vectors (likely as lists, arrays, or tensors)
Embeddings are typically normalized or should be normalized to unit vectors
Determine the dimensionality (e.g., 512-dimensional embeddings are common)

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results