Cosine similarity vs dot product comparison
cosine similarity to measure the angle-based similarity between embeddings, normalizing for vector length. Use dot product when vector magnitude matters, as it combines length and direction in similarity scoring.VERDICT
cosine similarity for most embedding similarity tasks due to its normalization and scale invariance; use dot product when embedding magnitude encodes meaningful information or for efficient approximate nearest neighbor search.| Metric | Definition | Range | Normalization | Best for | Computational cost |
|---|---|---|---|---|---|
| Cosine similarity | Measures cosine of angle between vectors | -1 to 1 | Yes, vectors normalized | Semantic similarity, scale-invariant tasks | Moderate (normalization + dot) |
| Dot product | Sum of element-wise products | Unbounded (depends on vector length) | No | Magnitude-sensitive tasks, fast similarity | Low (simple vector multiplication) |
| Use case example | Text embedding similarity | Image feature matching | Vector length irrelevant | Vector length encodes importance | Depends on vector size |
| Interpretation | Similarity based on direction only | Similarity influenced by length and direction | Ensures fair comparison | Captures strength and presence | Faster but less robust |
Key differences
Cosine similarity measures the cosine of the angle between two vectors, focusing on their direction and normalizing for length. Dot product multiplies vectors element-wise and sums the result, combining both magnitude and direction. This means cosine similarity is scale-invariant, while dot product is sensitive to vector length.
Cosine similarity ranges from -1 to 1, making it interpretable as a normalized similarity score. Dot product values are unbounded and depend on vector magnitudes, which can bias similarity if vector lengths vary.
Side-by-side example
import numpy as np
# Example vectors
vec_a = np.array([1, 2, 3])
vec_b = np.array([4, 5, 6])
# Dot product
dot = np.dot(vec_a, vec_b)
# Cosine similarity
cosine = dot / (np.linalg.norm(vec_a) * np.linalg.norm(vec_b))
print(f"Dot product: {dot}")
print(f"Cosine similarity: {cosine:.4f}")Dot product: 32 Cosine similarity: 0.9746
Dot product equivalent
from openai import OpenAI
import os
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
# Embeddings for two texts
response_a = client.embeddings.create(model="text-embedding-3-small", input="Hello world")
response_b = client.embeddings.create(model="text-embedding-3-small", input="Hi there")
vec_a = response_a.data[0].embedding
vec_b = response_b.data[0].embedding
# Compute dot product similarity
similarity = sum(a * b for a, b in zip(vec_a, vec_b))
print(f"Dot product similarity: {similarity}")Dot product similarity: 12.345678 (example value)
When to use each
Use cosine similarity when you want to compare embeddings regardless of their magnitude, such as semantic similarity in NLP or image features where scale varies. Use dot product when vector length encodes meaningful information, like confidence or frequency, or when you need faster approximate similarity computations.
In practice, cosine similarity is preferred for normalized embedding comparisons, while dot product is common in recommendation systems and some vector databases optimized for speed.
| Use case | Preferred metric | Reason |
|---|---|---|
| Semantic text similarity | Cosine similarity | Normalizes vector length for fair comparison |
| Recommendation ranking | Dot product | Captures magnitude as importance or confidence |
| Approximate nearest neighbor search | Dot product | Faster computation, hardware optimized |
| Image feature matching | Cosine similarity | Focuses on direction, ignoring scale |
Pricing and access
Both cosine similarity and dot product are mathematical operations you implement locally or in your vector database. Embeddings to use with these metrics come from APIs like OpenAI or Anthropic, which have their own pricing.
| Option | Free | Paid | API access |
|---|---|---|---|
| OpenAI embeddings | Yes (limited) | Yes | OpenAI API with text-embedding-3-small model |
| Anthropic embeddings | Check pricing | Yes | Anthropic API with claude-3-5-sonnet embeddings |
| Local embeddings | Yes | No | Use sentence-transformers or similar |
| Vector DB similarity | Depends on DB | Depends on DB | Many support both cosine and dot product |
Key Takeaways
-
Cosine similaritynormalizes vectors, making it ideal for semantic similarity tasks. -
Dot productincludes vector magnitude, useful when length encodes importance. - Use cosine similarity for fair comparison; use dot product for speed or magnitude-sensitive use cases.