Módulo 3: Modelos de Embeddings Comparison

Introducción al Módulo 3: Modelos de Embeddings Comparison

Siguiente →

Bienvenida al módulo

Ya sabes qué son embeddings (Módulo 1) y cómo funcionan internamente (Módulo 2: Transformers, tokenización, pooling). Ahora llega el momento crítico para AI Engineers: elegir el modelo correcto.

En este módulo aprenderás a comparar modelos de embeddings (OpenAI, Sentence-BERT, BGE, Instructor, Cohere), ejecutar benchmarks con MTEB, usar modelos open-source localmente, optimizar para tu dominio específico, y manejar multiidioma. Al final, podrás tomar decisiones informadas sobre qué modelo usar según tu caso de uso, presupuesto, y requerimientos de performance.

Objetivos del módulo

Al finalizar este módulo, serás capaz de:

  1. ✅ Comparar modelos: OpenAI vs open-source (SBERT, BGE, Instructor)
  2. ✅ Ejecutar benchmarks: MTEB scores, latencia, costos
  3. ✅ Usar open-source: Sentence-Transformers (HuggingFace)
  4. ✅ Optimizar para dominio: Fine-tuning (conceptual) vs zero-shot
  5. ✅ Manejar multiidioma: Multilingual embeddings (mBERT, XLM-R)
  6. ✅ Decidir trade-offs: Precisión vs costo vs latencia
  7. ✅ Implementar fallback: Multi-provider strategy
  8. ✅ Proyecto: Benchmark framework para comparar modelos

Roadmap del módulo

Fase 1: Landscape de modelos (Cápsulas 01-03)

Cápsula 01: Introducción (esta cápsula)

  • Objetivos, roadmap, contexto

Cápsula 02: OpenAI Embeddings Models

  • text-embedding-3-small vs 3-large
  • Performance, costos, dimensiones
  • Cuándo usar cada uno

Cápsula 03: Open-Source Embeddings Overview

  • Sentence-BERT (SBERT)
  • BGE Models
  • Instructor Embeddings
  • Cohere (API)
  • E5 Models

Fase 2: Evaluación y benchmarking (Cápsulas 04-06)

Cápsula 04: MTEB Benchmark

  • Qué es MTEB (Massive Text Embedding Benchmark)
  • Interpretar scores
  • Limitaciones de benchmarks

Cápsula 05: Latencia y Throughput

  • Medir latencia (API vs local)
  • Throughput (documentos/segundo)
  • Batch processing performance

Cápsula 06: Cost Analysis

  • Comparar costos (OpenAI vs self-hosted)
  • TCO (Total Cost of Ownership)
  • Cuándo self-hosted hace sentido

Fase 3: Specialization y proyecto (Cápsulas 07-08)

Cápsula 07: Domain-Specific y Multilingual

  • Domain-specific embeddings (legal, medical)
  • Multilingual embeddings (100+ idiomas)
  • Cuándo fine-tune vs zero-shot

Cápsula 08: Mini-Proyecto - Benchmark Framework

  • Comparar 3+ modelos
  • Métricas: MTEB, latencia, costo
  • Reportes automáticos
  • Recomendación de modelo

Conexión con el AI Engineering Path

Pre-requisitos (completados):

✅ Módulo 1 (Embeddings Deep Dive): Fundamentos de embeddings ✅ Módulo 2 (Embeddings Deep Dive): Arquitectura interna

Este módulo en el path:

AI Semantics Guide (conceptos vectoriales)
          ↓
Embeddings Deep Dive - M1 (¿Qué son?)
          ↓
Embeddings Deep Dive - M2 (¿Cómo funcionan?)
          ↓
Embeddings Deep Dive - M3 (Comparación de modelos) ← ESTÁS AQUÍ
          ↓
Embeddings Deep Dive - M4 (Evaluación y chunking)
          ↓
Vector Databases Comparison Guide

Por qué comparar modelos es crítico

Escenario real:

Tarea: Implementar semantic search para 1M documentos

Opciones:
1. OpenAI text-embedding-3-large:
   - Performance: Excelente (MTEB ~64)
   - Costo: $130/1M tokens
   - Latencia: ~100ms (API)
   
2. Sentence-BERT (all-MiniLM-L6-v2):
   - Performance: Bueno (MTEB ~58)
   - Costo: $0 (self-hosted)
   - Latencia: ~5ms (local GPU)

3. BGE-large-en:
   - Performance: Excelente (MTEB ~63)
   - Costo: $0 (self-hosted)
   - Latencia: ~20ms (local GPU)

Pregunta: ¿Cuál eliges?

Respuesta: Depende de:

  • Presupuesto (API vs self-hosted)
  • Performance requerido (RAG vs semantic search básico)
  • Latencia tolerable (100ms vs 5ms)
  • Volumen (1K docs vs 1M docs)
  • Idioma (inglés vs multiidioma)

Este módulo te da herramientas para decidir.

Qué aprenderás (detallado)

1. Landscape de modelos:

# OpenAI (API):
- text-embedding-3-small (1536 dims, $0.02/1M tokens)
- text-embedding-3-large (3072 dims, $0.13/1M tokens)

# Open-source (HuggingFace):
- Sentence-BERT (all-MiniLM-L6-v2, all-mpnet-base-v2)
- BGE (BAAI/bge-large-en, bge-base-en)
- Instructor (hkunlp/instructor-large)
- E5 (intfloat/e5-large-v2)

# Commercial API:
- Cohere (embed-english-v3.0)
- Voyage AI (voyage-large-2)

2. Evaluación sistemática:

MTEB scores (performance):

Modelo               | MTEB Score | Uso típico
---------------------|------------|------------------
text-embedding-3-large | ~64      | RAG production
BGE-large-en          | ~63      | Self-hosted RAG
text-embedding-3-small | ~62      | Prototipado
all-mpnet-base-v2     | ~58      | Semantic search básico
all-MiniLM-L6-v2      | ~56      | Demos, MVP

Latencia (speed):

Modelo               | Latencia | Dónde
---------------------|----------|------------
all-MiniLM-L6-v2     | ~5ms    | Local CPU
BGE-large-en (GPU)   | ~20ms   | Local GPU
OpenAI API           | ~100ms  | Cloud

Costo (economics):

Modelo               | Costo/1M tokens | Break-even
---------------------|-----------------|-------------
OpenAI 3-large       | $130           | -
BGE (self-hosted)    | $0 + GPU ($2/h)| ~65 horas uso

3. Trade-offs reales:

Caso 1: Startup con presupuesto limitado

Recomendación: Sentence-BERT (all-MiniLM-L6-v2)
- Costo: $0 (self-hosted)
- Performance: Suficiente para MVP
- Latencia: Excelente (5ms local)

Caso 2: Empresa con RAG production-ready

Recomendación: OpenAI text-embedding-3-large
- Costo: $130/1M tokens (presupuesto OK)
- Performance: Top-tier (MTEB 64)
- Latencia: Aceptable (100ms)
- Zero maintenance

Caso 3: E-commerce con 10M productos

Recomendación: BGE-large-en (self-hosted GPU)
- Costo: $0/token + GPU ($500/mes)
- Performance: Excelente (MTEB 63)
- Latencia: 20ms (local)
- Break-even después de 1 mes vs OpenAI

Balance teoría/práctica (50/50)

Teoría (50%):

  • Comparación de modelos (arquitecturas, performance)
  • MTEB benchmark (cómo interpretar scores)
  • Cost analysis (TCO, break-even)
  • Domain-specific y multilingual (cuándo usar)

Práctica (50%):

  • Ejecutar benchmarks con MTEB
  • Medir latencia (código)
  • Calcular costos (spreadsheet)
  • Comparar modelos (proyecto final)

Este módulo es menos "hands-on code" que M1/M2 (más evaluación y decisiones estratégicas).

Qué NO aprenderás (fuera de scope)

❌ Fine-tuning de embeddings:

Razón: Fine-tuning es avanzado (requiere ML Engineering).
Cobertura: Solo conceptual (cuándo considerar fine-tuning).

❌ Entrenar embeddings desde cero:

Razón: Requiere corpus masivo + semanas de GPU + ML expertise.
Cobertura: No aplica para AI Engineers (usa modelos pre-entrenados).

❌ Arquitecturas custom (modificar Transformers):

Razón: Fuera de scope de AI Engineering (es Research/ML Engineering).
Cobertura: Solo usar modelos existentes.

❌ Visualización avanzada (UMAP, t-SNE):

Razón: No es crítico para producción (más Data Science).
Cobertura: Solo conceptual (no código matplotlib).

Herramientas del módulo

Bibliotecas Python:

# Sentence-Transformers (HuggingFace)
from sentence_transformers import SentenceTransformer

# MTEB (benchmarking)
from mteb import MTEB

# OpenAI (ya visto)
from openai import OpenAI

# Cost tracking
import time

Setup requerido:

# Instalar Sentence-Transformers
pip install sentence-transformers

# Instalar MTEB
pip install mteb

# OpenAI (ya instalado)
pip install openai

Estructura del módulo

module-03-modelos-embeddings-comparison/
└── es/
    ├── 01-introduccion-modulo.md        ← Estás aquí
    ├── 02-openai-models.md
    ├── 03-open-source-overview.md
    ├── 04-mteb-benchmark.md
    ├── 05-latencia-throughput.md
    ├── 06-cost-analysis.md
    ├── 07-domain-multilingual.md
    └── 08-proyecto-benchmark-framework.md

Habilidades profesionales

Al completar este módulo, demostrarás:

1. Strategic thinking:

  • Evaluar trade-offs (costo vs performance)
  • TCO analysis (no solo precio de API)
  • Break-even calculations

2. Technical evaluation:

  • Interpretar benchmarks (MTEB)
  • Medir latencia (código)
  • Comparar modelos objetivamente

3. Decision-making:

  • Elegir modelo según caso de uso
  • Justificar decisiones con datos
  • Fallback strategies (multi-provider)

Casos de uso reales

1. RAG system (production):

Requerimientos:

  • Alta precisión (contexto correcto)
  • Latencia <200ms
  • Presupuesto: $500/mes
  • Volumen: 100K queries/mes

Decisión:

Modelo: OpenAI text-embedding-3-large
Razón:
- Performance top-tier (RAG crítico)
- Latencia OK (100ms)
- Costo OK ($130/1M tokens = $13/100K queries)

2. E-commerce search (10M productos):

Requerimientos:

  • Performance bueno (no crítico)
  • Latencia <50ms
  • Presupuesto: $200/mes
  • Volumen: 1M queries/mes

Decisión:

Modelo: BGE-large-en (self-hosted GPU)
Razón:
- Performance excelente (MTEB 63)
- Latencia excelente (20ms)
- Costo OK (GPU $200/mes, no por query)

3. Startup MVP (proof-of-concept):

Requerimientos:

  • Performance suficiente
  • Latencia cualquiera
  • Presupuesto: $0
  • Volumen: 1K queries/mes

Decisión:

Modelo: Sentence-BERT (all-MiniLM-L6-v2)
Razón:
- Performance OK para MVP (MTEB 56)
- Latencia excelente (5ms local CPU)
- Costo: $0 (self-hosted)

Metodología del módulo

Aprendizaje comparativo:

Paso 1: Conocer modelos (landscape)
         ↓
Paso 2: Evaluar (MTEB, latencia, costo)
         ↓
Paso 3: Decidir (trade-offs, caso de uso)
         ↓
Paso 4: Implementar (proyecto benchmark)

Ejercicio inicial (reflexión)

Escenario:

Estás construyendo un sistema de búsqueda semántica para una base de conocimientos interna de tu empresa (10,000 documentos técnicos en español).

Preguntas:

  1. ¿Qué modelo elegirías? ¿Por qué?
  2. ¿Qué métricas usarías para evaluar?
  3. ¿Cuál es tu presupuesto máximo mensual?
  4. ¿Qué latencia es aceptable?

No hay respuesta correcta única (depende de restricciones).

Al final del módulo, podrás responder con datos concretos.

Recursos del módulo

Benchmarks:

  1. MTEB Leaderboard - Rankings oficiales
  2. Sentence-Transformers - Open-source embeddings
  3. OpenAI Embeddings Guide - Oficial

Herramientas:

  1. HuggingFace Model Hub - Modelos pre-entrenados
  2. MTEB GitHub - Código de benchmarking

En la siguiente cápsula

Cápsula 02: OpenAI Embeddings Models

Aprenderás:

  • Diferencias entre 3-small y 3-large
  • Performance comparado (MTEB scores)
  • Costos detallados
  • Dimensiones configurables
  • Cuándo usar cada modelo

De introducción a deep dive en OpenAI.

Módulo 3 - Embeddings Deep Dive Guide Eligiendo el modelo correcto: performance, costo, y trade-offs

← AnteriorMini-Proyecto: API Client Robusto para ProducciónSiguiente →OpenAI Embeddings Models: Deep Dive Comparison