Euclidean Distance for Face Embeddings

easyFREEFace RecognitionEmbeddingsCV: Recognition

You are given two face embeddings (vectors) and need to calculate the Euclidean distance between them.

Face recognition systems convert face images to fixed-length vectors (embeddings). Similar faces produce similar embeddings, so the distance between embeddings indicates how similar two faces are.

The Euclidean distance (L2 distance) is:

$d(a, b) = \sqrt{\sum_{i=1}^{n} (a_i - b_i)^2} = \|a - b\|_2$

Lower distance = more similar faces.

Typical thresholds: distance < 0.6 might indicate same person, distance > 1.0 likely different people.

Example

Input

a = [1, 0, 0]
b = [0, 1, 0]

Output

1.4142

Reasoning

a and b are two face embeddings of the same length (here 3). Each number is one coordinate of a point in embedding space, so the two lists are compared position by position.
Difference per coordinate: $a - b = (1-0,\ 0-1,\ 0-0) = (1, -1, 0)$ .
Square each difference: $1^2 = 1$ , $(-1)^2 = 1$ , $0^2 = 0$ . Squaring removes the sign, so overshooting or undershooting a coordinate counts the same.
Add the squares, $1 + 1 + 0 = 2$ , then take the square root: $\sqrt{2} \approx 1.414213\ldots$ , which rounded to 4 decimal places is 1.4142.
The result is a single non-negative float, not a vector. Notice the inputs are perpendicular unit vectors, so the distance is the diagonal of a unit square; by the description's thresholds (above 1.0) these would be judged different people.
Two identical embeddings would give a distance of exactly $0$ : the same point in space.

Constraints

a and b are lists of floats (embeddings) of the same length
Return distance rounded to 4 decimal places

Learn this in

RecognitionCV Study Plan

More from CV: Recognition

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

Concept primer

Background Knowledge

Face Embeddings and Vector Representation

Face recognition systems use deep learning models to convert face images into fixed-length numerical vectors called embeddings. These embeddings capture the essential facial features in a compressed form, typically ranging from 128 to 512 dimensions depending on the model used. The key insight is that faces of the same person produce embeddings that are close together in this high-dimensional space, while faces of different people produce embeddings that are far apart. This property makes embeddings ideal for face verification and identification tasks.

Distance Metrics in Face Recognition

The Euclidean distance (also called L2 distance) is one of the most common metrics for comparing embeddings. It measures the straight-line distance between two points in n-dimensional space. In practice, face recognition systems establish decision thresholds based on Euclidean distance: embeddings with distance below a threshold (typically 0.6) are considered the same person, while distances above another threshold (typically 1.0) indicate different people. Other distance metrics like Manhattan distance and Cosine similarity also exist, though Cosine similarity has shown superior performance in some applications due to its robustness with fixed thresholds.

Why Euclidean Distance Works

The effectiveness of Euclidean distance for face embeddings stems from how neural networks learn to organize facial features in embedding space during training. The network learns to position similar faces close together and dissimilar faces far apart, making the geometric distance a reliable proxy for facial similarity.

Algorithm/Approach

The solution involves computing the L2 norm of the difference vector between two embeddings. The general approach is:

Calculate the element-wise differences between corresponding dimensions of the two vectors
Square each difference
Sum all squared differences
Take the square root of the sum

This is a straightforward mathematical computation with no complex algorithmic patterns required.

Step-by-Step Strategy

Step 1: Understand the Input

You'll receive two embeddings as arrays/lists of numbers
Both embeddings should have the same length (same number of dimensions)
Verify that both inputs are valid vectors

Step 2: Calculate Differences

For each dimension $i$ , compute $(a_i - b_i)$
Store or accumulate these differences

Step 3: Square the Differences

Square each difference: $(a_i - b_i)^2$
This ensures negative differences contribute positively to the distance

Step 4: Sum the Squared Differences

Add all squared differences together: $\sum_{i=1}^{n} (a_i - b_i)^2$
This gives you the squared Euclidean distance

Step 5: Take the Square Root

Apply the square root to get the final Euclidean distance: $\sqrt{$ \sum_{i=1}^{n} $(a_i - b_i)^2}$
Return this value

Common Pitfalls

Forgetting the square root: Computing only the sum of squared differences gives you the squared distance, not the actual Euclidean distance. Always take the square root at the end.
Dimension mismatch: Ensure both embeddings have the same length. If they don't, the problem setup is invalid.
Numerical precision: When working with floating-point numbers, be aware of potential precision issues. However, for most face embedding problems, standard floating-point arithmetic is sufficient.
Negative values: Don't worry about negative differences—squaring them makes them positive, which is the intended behavior.
Off-by-one errors: When iterating through dimensions, ensure you're covering all indices from 0 to n-1 (or 1 to n, depending on your language).

Time & Space Complexity

Time Complexity: $O(n)$ , where $n$ is the number of dimensions in each embedding. You must iterate through each dimension once to compute differences, square them, and sum them.

Space Complexity: $O(1)$ if you accumulate the sum in a single variable without storing intermediate results. If you store all squared differences in an array before summing, it becomes $O(n)$ , but this is unnecessary and should be avoided for efficiency.

solution.py

Python 3.13

Test results