Módulo 3: Modelos de Embeddings Comparison

MTEB: Massive Text Embedding Benchmark

Descripción de la cápsula

MTEB (Massive Text Embedding Benchmark) es el estándar de facto para evaluar modelos de embeddings. Creado por HuggingFace en 2022, evalúa 58+ datasets a través de 8 tareas diferentes (retrieval, classification, clustering, etc.). Los scores MTEB son la métrica principal que usas para comparar modelos.

En esta cápsula aprenderás qué es MTEB, cómo interpretar scores, las 8 tareas que evalúa, limitaciones de benchmarks, y cómo ejecutar MTEB en tus propios modelos. También verás el leaderboard actual y qué modelos dominan.

Al final, podrás evaluar objetivamente qué modelo elegir según scores MTEB.

¿Qué es MTEB?

Definición:

MTEB (Massive Text Embedding Benchmark): Framework para evaluar embeddings en 58 datasets a través de 8 tareas diferentes. Genera un score promedio (0-100) que resume performance.

Desarrollado por: HuggingFace (2022)

Objetivo: Estandarizar evaluación de embeddings (antes cada paper usaba métricas diferentes).

8 tareas evaluadas:

Tarea	Descripción	Datasets	Métrica
Retrieval	Buscar documentos relevantes para query	15	nDCG@10
Classification	Clasificar texto en categorías	12	Accuracy
Clustering	Agrupar textos similares	11	V-measure
Pair Classification	¿Dos textos son similares?	3	AP
Reranking	Reordenar docs por relevancia	4	MAP
STS (Semantic Similarity)	Predecir score de similaridad	10	Spearman
Summarization	Encontrar mejor resumen	1	Spearman
BitextMining	Alinear traducciones	2	F1

Total: 58 datasets

MTEB Leaderboard (2026)

Top modelos (English):

Ranking | Modelo                    | MTEB Score | Dims | Tipo
--------|---------------------------|------------|------|----------
#1      | gte-Qwen2-7B-instruct     | 72.3       | 3584 | Open-source
#2      | text-embedding-3-large    | 64.6       | 3072 | OpenAI (API)
#3      | bge-large-en-v1.5         | 64.2       | 1024 | Open-source
#4      | instructor-xl             | 63.9       | 768  | Open-source
#5      | e5-mistral-7b-instruct    | 63.7       | 4096 | Open-source
#6      | text-embedding-3-small    | 62.3       | 1536 | OpenAI (API)
#7      | bge-base-en-v1.5          | 62.8       | 768  | Open-source
#8      | e5-large-v2               | 62.0       | 1024 | Open-source
#9      | all-mpnet-base-v2         | 57.8       | 768  | Open-source
#10     | all-MiniLM-L6-v2          | 56.3       | 384  | Open-source

Fuente: MTEB Leaderboard (HuggingFace)

Interpretar scores MTEB

Score range:

Score MTEB | Performance | Uso recomendado
-----------|-------------|------------------
70-100     | Excelente   | Production crítica (RAG, legal)
65-70      | Muy bueno   | Production estándar (RAG)
60-65      | Bueno       | Semantic search, prototipado
55-60      | Aceptable   | MVP, demos
<55        | Básico      | Solo para testing

Desglose por tarea:

Ejemplo: OpenAI text-embedding-3-large

Tarea                 | Score | Interpretación
----------------------|-------|----------------
Retrieval             | 60.0  | Muy bueno (RAG-ready)
Classification        | 70.1  | Excelente (mejor que retrieval)
Clustering            | 51.9  | Aceptable (no especializado)
STS                   | 84.0  | Excelente (semantic similarity)
Reranking             | 64.2  | Muy bueno
Pair Classification   | 88.4  | Excelente
Summarization         | 30.8  | Débil (no es su fuerte)
BitextMining          | 85.7  | Excelente (multiidioma)

MTEB Average: 64.6

Insights:

Excelente para semantic similarity (STS 84.0)
Bueno para retrieval (60.0) → RAG-ready
Débil en summarization (30.8) → No usar para eso

Tareas detalladas

1. Retrieval (más importante para RAG):

Qué evalúa:

# Dado un query, encontrar documentos relevantes
Query: "How to install Python?"
Corpus: 10,000 documentos
Tarea: Rankear documentos por relevancia

Métrica: nDCG@10 (normalized Discounted Cumulative Gain)
- 1.0 = Perfecto (docs relevantes en top 10)
- 0.0 = Terrible

Datasets:

NQ (Natural Questions)
MS MARCO
HotpotQA
FiQA
...15 total

2. Classification:

Qué evalúa:

# Clasificar texto en categorías
Input: "This movie was amazing!"
Output: "Positive"

Métrica: Accuracy
- % de clasificaciones correctas

Datasets:

Amazon Reviews
IMDB
Banking77
...12 total

3. Clustering:

Qué evalúa:

# Agrupar textos similares automáticamente
Input: 1000 textos sin labels
Output: Clusters (ej: [Tech, Sports, Politics])

Métrica: V-measure
- Qué tan bien los clusters coinciden con labels verdaderos

4. STS (Semantic Textual Similarity):

Qué evalúa:

# Predecir similaridad entre 2 textos (score 0-5)
Text A: "The cat sat on the mat"
Text B: "A feline rested on a rug"
Expected: 4.0 (muy similar)

Métrica: Spearman correlation
- Correlación entre scores predichos y verdaderos

Limitaciones de MTEB

❌ 1. Sesgo hacia inglés

# MTEB evalúa principalmente datasets en inglés
# Performance en español, chino, etc. puede ser diferente

Solución: MTEB Multilingual (evalúa 100+ idiomas).

❌ 2. No evalúa latencia/costo

# MTEB solo evalúa performance (accuracy, nDCG)
# No considera:
# - Latencia (API 100ms vs local 5ms)
# - Costo ($0.13/1M tokens vs $0)
# - Tamaño de modelo (80MB vs 1.2GB)

Solución: Complementar con benchmarks de latencia/costo (Cápsulas 05-06).

❌ 3. Datasets pueden no representar tu dominio

# MTEB usa datasets públicos (Wikipedia, Reddit, etc.)
# Tu dominio puede ser diferente (legal, medical)

Solución: Evaluar en tus propios datasets (domain-specific).

❌ 4. Overfitting al benchmark

# Modelos pueden ser "tuneados" específicamente para MTEB
# Performance en producción puede diferir

Solución: A/B testing en producción (validar con usuarios reales).

Ejecutar MTEB en tus modelos

Instalación:

pip install mteb

Código básico:

from mteb import MTEB
from sentence_transformers import SentenceTransformer

# Cargar modelo
model = SentenceTransformer('all-MiniLM-L6-v2')

# Definir evaluación (solo 1 tarea para demo)
evaluation = MTEB(tasks=["Banking77Classification"])

# Ejecutar
results = evaluation.run(model, output_folder="results/")

print(results)

Output (ejemplo):

{
  "Banking77Classification": {
    "test": {
      "accuracy": 0.7234,
      "f1": 0.7123
    }
  }
}

Evaluación completa (58 datasets):

# ADVERTENCIA: Toma ~8 horas en GPU
evaluation = MTEB(tasks=MTEB(task_langs=['en']).tasks)
results = evaluation.run(model, output_folder="results/")

Evaluación selectiva (solo retrieval):

# Solo tareas de retrieval (más relevante para RAG)
retrieval_tasks = [
    "NFCorpus",
    "SciFact",
    "FiQA2018",
    "ArguAna",
    "TRECCOVID"
]

evaluation = MTEB(tasks=retrieval_tasks)
results = evaluation.run(model)

Comparación práctica: MTEB vs Real-World

Experimento:

# Modelo A: MTEB 64 (OpenAI 3-large)
# Modelo B: MTEB 58 (all-mpnet-base-v2)

# Pregunta: ¿Modelo A es 10% mejor en producción?

# Respuesta: NO necesariamente.
# Razones:
# 1. Dominio puede ser diferente (MTEB es general)
# 2. Latencia importa (modelo B es 10x más rápido)
# 3. Costo importa (modelo B es $0/query)

Conclusión: MTEB es guía, no verdad absoluta. Valida en tu dominio.

Ejercicios

Ejercicio 1: Interpretar MTEB

Modelo X tiene estos scores:

Retrieval: 58
Classification: 72
Clustering: 45
STS: 80
MTEB Average: 62

¿Para qué tarea es mejor este modelo?

Ver solución

Respuesta: Semantic Similarity (STS: 80)

Interpretación:

Excelente para comparar similaridad entre textos
Muy bueno para classification (72)
Aceptable para retrieval (58) → OK para RAG básico
Débil en clustering (45) → No usar para agrupar documentos

Caso de uso recomendado: Semantic search, duplicate detection, paraphrase detection.

Ejercicio 2: Elegir modelo según MTEB

Tienes 2 opciones:

Modelo A: MTEB 64, Costo $0.13/1M tokens, Latencia 100ms
Modelo B: MTEB 58, Costo $0 (self-hosted), Latencia 10ms

Tu caso: RAG system con 100K queries/mes, presupuesto $50/mes.

¿Cuál eliges?

Ver solución

Análisis:

Modelo A (OpenAI 3-large):

Performance: Excelente (MTEB 64)
Costo: (100K × 50 tokens) / 1M × $0.13 = $0.65/mes ✅
Latencia: 100ms (aceptable)

Modelo B (all-mpnet-base-v2):

Performance: Bueno (MTEB 58, suficiente para RAG básico)
Costo: $0/query (+ GPU $200/mes) ❌ (excede presupuesto)
Latencia: 10ms (excelente)

Recomendación: Modelo A (OpenAI 3-large)

Razones:

Costo total <$1/mes (muy por debajo de presupuesto)
Performance superior (MTEB 64 vs 58)
Zero maintenance
Self-hosting no justifica para 100K queries/mes

Resumen

Qué aprendiste:

✅ MTEB: Benchmark estándar (58 datasets, 8 tareas)
✅ Score range: 70+ excelente, 60-70 bueno, <60 aceptable
✅ Tareas: Retrieval (RAG), Classification, STS (similarity)
✅ Limitaciones: Sesgo inglés, no evalúa latencia/costo, dominio general
✅ Ejecución: Código con biblioteca mteb

Conceptos clave:

MTEB es guía, no verdad absoluta
Retrieval score más importante para RAG
Complementar con latencia, costo, y dominio específico

Recursos adicionales

MTEB Leaderboard - Rankings actualizados
MTEB Paper - Paper original
MTEB GitHub - Código
MTEB Tasks - Datasets

En la siguiente cápsula

Cápsula 05: Latencia y Throughput

Aprenderás:

Medir latencia (API vs local)
Throughput (docs/segundo)
Batch processing impact
Código de benchmarking

De performance a velocidad.

Módulo 3 - Embeddings Deep Dive Guide MTEB: el estándar para evaluar embeddings

← AnteriorOpen-Source Embeddings: Self-Hosted Alternatives Siguiente →Latencia y Throughput: Performance Real