Similarity Metrics for Vectors

Comparing two vectors is only meaningful once you decide what close means, and the three metrics in common use encode three different answers.

Cosine similarity measures the angle between the vectors and ignores their length:

cosine = a @ b / (np.linalg.norm(a) * np.linalg.norm(b))

Dot product measures the angle scaled by both lengths — it is what you compute when you skip the division:

dot = a @ b

Euclidean distance measures the straight-line gap between the endpoints:

euclid = np.linalg.norm(a - b)

The choice is a statement about which information you keep. Cosine throws magnitude away; dot product keeps it; Euclidean keeps it and penalizes it. The next chapter shows the three disagreeing on one pair of vectors.

Two candidate documents and one query vector. Which document is closer depends entirely on what "closer" means:

import numpy as np

query = np.array([1.0, 0.0])    # unit vector on the x axis
doc_a = np.array([3.0, 0.4])    # long, almost the same direction
doc_b = np.array([0.6, 0.6])    # short, clearly off-axis

def cosine(a, b):
    return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))

def dot(a, b):
    return a @ b

def euclid(a, b):
    return np.linalg.norm(a - b)

for name, v in [('doc_a', doc_a), ('doc_b', doc_b)]:
    print(name, f'cos={cosine(query, v):.3f}',
          f'dot={dot(query, v):.3f}', f'l2={euclid(query, v):.3f}')

Output:

doc_a cos=0.991 dot=3.000 l2=2.040
doc_b cos=0.707 dot=0.600 l2=0.721

Cosine prefers doc_a: it points almost the same way as the query. Euclidean prefers doc_b: it sits physically nearer. Same two vectors, opposite rankings — because doc_a is three units long, and Euclidean distance charges for length while cosine refuses to see it.

The hand check for the first row: the numerator is 1*3 + 0*0.4 = 3.0, the denominator is 1 * 3.027 (the norm of doc_a), and the quotient is 0.991.

Scale every document by 10 and cosine rankings are untouched, dot product rankings slide toward the longest vectors, and Euclidean distances inflate for them. Vectors from a real embedding model come out similar in length but not identical, so a metric picked by habit is a metric picked blind.

Scale each vector to unit length — Euclidean norm of 1 — and the denominator in cosine vanishes: the dot product is the cosine from then on. Indexes that support only inner product can therefore serve cosine-style queries without recomputing anything at query time (ANN Index Types).

def unit(v):
    return v / np.linalg.norm(v)

q, a, b = unit(query), unit(doc_a), unit(doc_b)
print(f'{q @ a:.6f} vs {cosine(query, doc_a):.6f}')
print(f'{q @ b:.6f} vs {cosine(query, doc_b):.6f}')

Output:

0.991228 vs 0.991228
0.707107 vs 0.707107

Three consequences fall out of those two lines:

• Normalize at write time. The division moves to ingestion, paid once per document, instead of on every probe.
• Scaling input before normalization is a no-op for cosine. Unit-normalizing doc_a * 10 gives the same direction as unit-normalizing doc_a, so cosine cannot distinguish a popular document from an obscure one if length was carrying that signal.
• Dot product without normalization keeps the signal. If magnitude encodes something real — term weight, popularity, recency folded into the vector — inner product over raw vectors preserves it and cosine destroys it. The metric is a statement about which information you are willing to discard.

Dimension changes the intuition behind the numbers. In 1,536 dimensions, unrelated text does not land near cosine 0: anisotropy in trained models pushes the whole distribution up, so random document pairs commonly score 0.1 to 0.35, and near-duplicates sit around 0.9 plus. The 2-D picture of angles is a mnemonic, not a calibration — the score band belongs to the model that produced it, which is what the next chapter has to handle.

cosine = 0.92 reads like a probability and is not one. It reports a small angle in one model's space. It says nothing about the chance a document is relevant, and it is not comparable to a 0.92 from another model or from the same collection before a rebuild.

Failure modes worth naming before a cutoff ships:

• Reading 0.9 as '90% likely related'. Similarity is geometry; relevance is a judgment about text.
• Reusing a value across models. A retrieval-tuned model clusters unrelated text higher than a generic one, so 0.85 means different things in each space.
• Tuning on the queries that built the index. Those queries already share vocabulary with the corpus, and the cutoff inherits that optimism.
• Freezing the value forever. New chunking, a new model version, a corpus that grew — all three move the score distribution while the number stays put.
• Charting scores across rebuilds. Two index versions, two scales, one trend line that measures nothing.

The defensible version: derive the cutoff from labeled pairs every time the model, chunking, or corpus changes, and keep the derivation — queries, labels, precision and recall at each candidate value — beside the number. That machinery is Evaluating Embedding Quality, and it is also how you compare two candidate models before moving a single vector. Meanwhile the corpus itself has to get embedded somewhere, which is Batching Embedding Requests.