Módulo 5: Distance Metrics Deep Dive

Introducción al Módulo 5: Distance Metrics Deep Dive

Bienvenida al módulo

Has aprendido embeddings, chunking, y RAG. Ahora profundizamos en las distance metrics: las fórmulas matemáticas que determinan "similaridad" entre vectores. Cosine similarity es estándar, pero ¿por qué? ¿Cuándo usar Euclidean, dot product, o Manhattan?

En este módulo dominarás las métricas de distancia principales, sus trade-offs matemáticos y computacionales, cuándo usar cada una, y cómo optimizar búsqueda vectorial. Al final, podrás elegir la métrica correcta según tu caso de uso.

Objetivos del módulo

✅ Cosine similarity: Por qué es estándar para embeddings
✅ Euclidean distance: Cuándo usar vs cosine
✅ Dot product: Equivalencia con cosine (normalized)
✅ Manhattan distance: Use cases específicos
✅ Performance: Benchmarks de velocidad
✅ Optimizaciones: FAISS, aproximaciones (ANN)
✅ Trade-offs: Accuracy vs speed
✅ Proyecto: Comparador de métricas

Roadmap del módulo

Fase 1: Métricas principales (Cápsulas 01-04)

Cápsula 01: Introducción (esta cápsula) Cápsula 02: Cosine Similarity (estándar) Cápsula 03: Euclidean Distance Cápsula 04: Dot Product & Others

Fase 2: Performance & Optimization (Cápsulas 05-07)

Cápsula 05: Performance Benchmarks Cápsula 06: Approximate Nearest Neighbors (ANN) Cápsula 07: FAISS Introduction

Fase 3: Proyecto (Cápsula 08)

Cápsula 08: Proyecto - Distance Metrics Comparator

Por qué distance metrics importan

# Embeddings (vectores):
emb_a = [0.5, 0.3, 0.8]
emb_b = [0.6, 0.2, 0.9]

# ¿Cuán "similares" son?
# Depende de la métrica:

cosine_sim = 0.98   # Muy similar (direcciones casi iguales)
euclidean_dist = 0.2  # Cercanos en espacio
dot_product = 1.05  # Fuerte alineación

# Diferentes métricas → diferentes resultados!

Métricas principales (overview)

1. Cosine Similarity (estándar):

# Mide ángulo entre vectores (dirección, no magnitud)
cos_sim = dot(a, b) / (||a|| × ||b||)

# Range: [-1, 1]
# 1.0 = Idénticos (mismo ángulo)
# 0.0 = Ortogonales (perpendiculares)
# -1.0 = Opuestos

# Por qué estándar:
# - Normaliza magnitud (solo dirección importa)
# - Robusto a escalas diferentes

2. Euclidean Distance:

# Distancia "directa" en espacio
euclidean = sqrt(Σ(a_i - b_i)²)

# Range: [0, ∞)
# 0 = Idénticos
# Mayor valor = Más lejanos

# Cuándo usar:
# - Magnitud importa (no solo dirección)
# - Embeddings ya normalizados

3. Dot Product:

# Producto escalar
dot_prod = Σ(a_i × b_i)

# Range: [-∞, ∞)
# Mayor valor = Más similares

# Ventaja:
# - MÁS RÁPIDO que cosine (no requiere normalización)
# - Equivalente a cosine SI embeddings normalizados

4. Manhattan Distance:

# Distancia "taxicab" (suma de diferencias absolutas)
manhattan = Σ|a_i - b_i|

# Range: [0, ∞)
# 0 = Idénticos

# Cuándo usar:
# - Alta dimensionalidad (curse of dimensionality)
# - Más rápido que Euclidean

Trade-offs principales

Métrica	Velocidad	Accuracy	Normalized?	Uso típico
Cosine	Media	Alta	Sí	Embeddings (default)
Dot Product	Rápida	Alta*	No**	Embeddings normalizados
Euclidean	Media	Media	No	Embeddings no-normalizados
Manhattan	Rápida	Media	No	Alta dimensionalidad

*Si embeddings normalizados
**Requiere normalización para equivalencia

Ejemplo comparativo

import numpy as np

# Vectores
a = np.array([3, 4, 0])
b = np.array([4, 3, 0])

# Cosine
cos = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
print(f"Cosine: {cos:.4f}")  # 0.96

# Euclidean
euc = np.linalg.norm(a - b)
print(f"Euclidean: {euc:.4f}")  # 1.41

# Dot product
dot = np.dot(a, b)
print(f"Dot: {dot:.4f}")  # 24.0

# Manhattan
man = np.sum(np.abs(a - b))
print(f"Manhattan: {man:.4f}")  # 2.0

Diferentes métricas → diferentes valores!

Cuándo usar cada métrica

Cosine Similarity:

✅ Embeddings de texto (OpenAI, SBERT)
✅ Cuando magnitud no importa (solo semántica)
✅ Default para RAG systems
✅ Embeddings de diferentes modelos (escalas diferentes)

Ejemplo: Semantic search

Dot Product:

✅ Embeddings YA normalizados (magnitud = 1.0)
✅ Performance crítico (3x más rápido que cosine)
✅ Large-scale search (millones de vectores)

Ejemplo: Production RAG (con normalización previa)

Euclidean Distance:

✅ Magnitud importa (no solo dirección)
✅ Embeddings específicos (imágenes, audio)
✅ Clustering (K-means usa Euclidean)

Ejemplo: Image similarity

Manhattan Distance:

✅ Alta dimensionalidad (curse of dimensionality)
✅ Performance crítico
✅ Outliers (más robusto que Euclidean)

Ejemplo: High-dim feature vectors

Balance teoría/práctica (40/60)

Teoría (40%):

Fórmulas matemáticas
Propiedades geométricas
Trade-offs conceptuales

Práctica (60%):

Implementación en numpy
Benchmarks de velocidad
Comparación empírica
Proyecto comparador

Qué NO aprenderás (fuera de scope)

❌ Advanced metrics (Mahalanobis, Minkowski):

Razón: Rara vez usadas para embeddings.
Cobertura: Solo las 4 principales.

❌ Vector databases internals:

Razón: Módulo dedicado siguiente.
Cobertura: Solo numpy in-memory.

❌ Deep math (proofs, derivations):

Razón: Enfoque práctico (AI Engineering).
Cobertura: Intuición + implementación.

Herramientas del módulo

# NumPy (vectores)
import numpy as np

# SciPy (distance functions)
from scipy.spatial.distance import cosine, euclidean

# Scikit-learn (métricas)
from sklearn.metrics.pairwise import cosine_similarity

# FAISS (optimización - opcional)
import faiss

Estructura del módulo

module-05-distance-metrics/
└── es/
    ├── 01-introduccion-modulo.md        ← Estás aquí
    ├── 02-cosine-similarity.md
    ├── 03-euclidean-distance.md
    ├── 04-dot-product-others.md
    ├── 05-performance-benchmarks.md
    ├── 06-approximate-nn.md
    ├── 07-faiss-intro.md
    └── 08-proyecto-metrics-comparator.md

Conexión con AI Engineering Path

M4 (Chunking + Evaluación)
          ↓
M5 (Distance Metrics) ← ESTÁS AQUÍ
          ↓
M6 (Embedding Operations)
          ↓
Vector Databases Guide

En la siguiente cápsula

Cápsula 02: Cosine Similarity

Aprenderás:

Fórmula matemática
Por qué es estándar para embeddings
Implementación numpy
Propiedades (normalización)
Código production-ready

De introducción a deep dive en cosine.

Módulo 5 - Embeddings Deep Dive Guide Distance Metrics: el corazón de la búsqueda vectorial

← AnteriorMini-Proyecto: Sistema RAG con Chunking Inteligente Siguiente →Cosine Similarity: La Métrica Estándar