Módulo 4: Evaluación y Chunking Strategies

Introducción al Módulo 4: Evaluación y Chunking Strategies

Siguiente →

Bienvenida al módulo

Ya sabes qué son embeddings (M1), cómo funcionan internamente (M2), y cómo elegir el modelo correcto (M3). Ahora llega el paso crítico para implementar RAG: chunking (dividir documentos largos en fragmentos) y evaluación (medir si tu sistema retrieval funciona bien).

En este módulo aprenderás estrategias de chunking (fixed-size, semantic, recursive), cómo evaluar calidad de retrieval (métricas como nDCG, MRR, Recall@K), optimizar tamaño de chunks y overlap, y construir un sistema RAG con chunking inteligente.

Al final, podrás implementar RAG production-ready con chunking óptimo y métricas de evaluación robustas.

Objetivos del módulo

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

  1. ✅ Implementar chunking: Fixed-size, semantic, recursive
  2. ✅ Optimizar chunks: Tamaño óptimo, overlap, boundaries
  3. ✅ Evaluar retrieval: nDCG, MRR, Recall@K, Precision@K
  4. ✅ Construir datasets: Evaluation sets para RAG
  5. ✅ A/B testing: Comparar estrategias de chunking
  6. ✅ Context window: Manejar límites de tokens (8K)
  7. ✅ Metadata enrichment: Agregar contexto a chunks
  8. ✅ Proyecto: Sistema RAG con chunking inteligente y evaluación

Roadmap del módulo

Fase 1: Chunking fundamentals (Cápsulas 01-03)

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

  • Objetivos, roadmap, contexto

Cápsula 02: Fixed-Size Chunking

  • Character-based, token-based
  • Overlap strategies
  • Código implementación

Cápsula 03: Semantic Chunking

  • Sentence boundaries
  • Paragraph-based
  • Topic-based segmentation
  • Trade-offs

Fase 2: Evaluación de retrieval (Cápsulas 04-06)

Cápsula 04: Métricas de Retrieval

  • nDCG (Normalized Discounted Cumulative Gain)
  • MRR (Mean Reciprocal Rank)
  • Recall@K, Precision@K, F1@K

Cápsula 05: Crear Evaluation Datasets

  • Formatos (queries + relevant docs)
  • Synthetic data generation
  • Human annotation
  • Quality assurance

Cápsula 06: A/B Testing Chunking Strategies

  • Comparar fixed vs semantic
  • Statistical significance
  • Optimization loops

Fase 3: Production patterns (Cápsulas 07-08)

Cápsula 07: Advanced Chunking Patterns

  • Recursive chunking (LangChain-style)
  • Metadata enrichment
  • Hierarchical chunks
  • Context preservation

Cápsula 08: Mini-Proyecto - RAG System con Chunking Inteligente

  • Chunking automático
  • Embedding + vector storage (in-memory)
  • Retrieval con evaluación
  • Métricas end-to-end

Conexión con el AI Engineering Path

Pre-requisitos (completados):

✅ Módulo 1: ¿Qué son embeddings? ✅ Módulo 2: Arquitectura de embeddings ✅ Módulo 3: Comparación de modelos

Este módulo en el path:

Embeddings Deep Dive - M3 (Comparación modelos)
          ↓
Embeddings Deep Dive - M4 (Chunking + Evaluación) ← ESTÁS AQUÍ
          ↓
Embeddings Deep Dive - M5 (Distance Metrics)
          ↓
Vector Databases Guide
          ↓
RAG Production Patterns

Por qué chunking es crítico para RAG

El problema:

# Documento largo (10,000 tokens):
document = """
[10,000 palabras de documentación técnica]
"""

# Problema 1: Token limit
# OpenAI embeddings: Max 8,191 tokens
# Este documento NO cabe en 1 embedding

# Problema 2: Granularidad
# Embedding de documento completo = demasiado general
# Usuario pregunta sobre feature específica
# Embedding no captura suficiente detalle

# Problema 3: Retrieval precision
# Si retrieves documento completo, LLM recibe 10K tokens irrelevantes
# Context window desperdiciado

Solución: Chunking (dividir en fragmentos).

Ejemplo chunking:

# Original (10,000 tokens):
document = """
Chapter 1: Introduction to Python
Python is a high-level programming language...
[8,000 palabras más]

Chapter 2: Variables and Data Types
Variables store data values...
[2,000 palabras más]
"""

# Después de chunking (chunks de 500 tokens):
chunks = [
    "Chapter 1: Introduction to Python. Python is a high-level...",
    "...programming language created by Guido van Rossum...",
    "Chapter 2: Variables and Data Types. Variables store...",
    "...data values. Python has several data types..."
]

# Ahora:
# - Cada chunk < 8,191 tokens ✅
# - Granularidad específica ✅
# - Retrieval preciso (solo chunks relevantes) ✅

Estrategias de chunking (overview)

1. Fixed-Size Chunking:

# Dividir cada N caracteres/tokens
chunk_size = 500  # tokens
overlap = 50      # tokens de overlap

# Pros:
# - Simple, determinístico
# - Rápido

# Cons:
# - Puede cortar en medio de frase/párrafo
# - No respeta semántica

2. Semantic Chunking:

# Dividir en boundaries naturales (frases, párrafos, secciones)

# Pros:
# - Respeta estructura del documento
# - Chunks más coherentes

# Cons:
# - Chunks de tamaño variable (algunos muy grandes/pequeños)
# - Más complejo

3. Recursive Chunking:

# Dividir jerárquicamente:
# 1. Intentar dividir por párrafos
# 2. Si párrafo muy grande → dividir por frases
# 3. Si frase muy grande → dividir por caracteres

# Pros:
# - Balance entre fixed y semantic
# - Garantiza tamaño máximo

# Cons:
# - Más complejo de implementar

Trade-offs de chunking

Tamaño de chunk:

# Chunks pequeños (200 tokens):
✅ Retrieval muy preciso (solo info relevante)
✅ Menos ruido para LLM
❌ Puede perder contexto (fragmentos muy pequeños)
❌ Más chunks = más embeddings = más storage

# Chunks grandes (1000 tokens):
✅ Más contexto preservado
✅ Menos chunks = menos storage
❌ Retrieval menos preciso (más ruido)
❌ Desperdicia context window del LLM

Optimal range: 400-800 tokens (depende del caso).

Overlap:

# Sin overlap:
Chunk 1: [tokens 0-500]
Chunk 2: [tokens 500-1000]
# Problema: Si info importante está en boundary (token 499-501),
# se divide entre 2 chunks → pierde coherencia

# Con overlap (50 tokens):
Chunk 1: [tokens 0-500]
Chunk 2: [tokens 450-950]  ← overlap de 50 tokens
# Ventaja: Info en boundary aparece completa en ambos chunks

# Optimal overlap: 10-20% del chunk size

Evaluación de retrieval

Por qué evaluar:

# Sin evaluación:
# "El sistema funciona... creo?"
# No sabes si chunking óptimo, si modelo correcto, etc.

# Con evaluación:
# "Chunking de 500 tokens tiene Recall@5 = 0.85"
# "Cambiar a 800 tokens mejora a 0.90"
# → Decisiones basadas en datos

Métricas principales:

1. Recall@K:

# De los docs relevantes, ¿cuántos están en top-K?
# Ejemplo:
# - Query: "How to install Python?"
# - Docs relevantes: [doc_3, doc_7]
# - Top-5 retrieved: [doc_1, doc_3, doc_5, doc_7, doc_9]
# Recall@5 = 2/2 = 1.0 (ambos docs relevantes en top-5)

2. Precision@K:

# De los top-K retrieved, ¿cuántos son relevantes?
# Precision@5 = 2/5 = 0.4 (2 relevantes de 5 retrieved)

3. nDCG@K:

# Como Recall pero considera ranking (mejor score a docs más arriba)
# nDCG@5 = 0.85 (doc_3 en posición 2, doc_7 en posición 4)

4. MRR (Mean Reciprocal Rank):

# Posición del PRIMER doc relevante
# doc_3 está en posición 2 → RR = 1/2 = 0.5

Qué aprenderás (detallado)

1. Chunking strategies:

# Fixed-size (implementación):
def fixed_size_chunking(text, chunk_size=500, overlap=50):
    """Dividir texto en chunks de tamaño fijo"""
    # Implementarás esta función con tiktoken
    pass

# Semantic (implementación):
def semantic_chunking(text, model="sentence-transformers"):
    """Dividir por boundaries semánticas"""
    # Implementarás con spaCy o LangChain
    pass

# Recursive (implementación):
def recursive_chunking(text, max_chunk_size=800):
    """Dividir jerárquicamente"""
    # Implementarás versión simplificada de LangChain
    pass

2. Evaluación sistemática:

# Crear evaluation dataset:
eval_dataset = [
    {
        "query": "How to install Python?",
        "relevant_doc_ids": [3, 7, 12],
        "corpus": [...1000 documentos...]
    },
    # ... más queries
]

# Evaluar retrieval:
metrics = evaluate_retrieval(
    queries=eval_dataset,
    retrieval_function=my_rag_system,
    k=5
)

print(f"Recall@5: {metrics['recall@5']:.2f}")
print(f"nDCG@5: {metrics['ndcg@5']:.2f}")

3. Optimization:

# A/B test diferentes chunk sizes:
chunk_sizes = [200, 400, 600, 800, 1000]

for size in chunk_sizes:
    chunks = fixed_size_chunking(docs, chunk_size=size)
    metrics = evaluate_retrieval(chunks)
    print(f"Size {size}: Recall@5 = {metrics['recall@5']:.2f}")

# Output:
# Size 200: Recall@5 = 0.75
# Size 400: Recall@5 = 0.85
# Size 600: Recall@5 = 0.90  ← Optimal
# Size 800: Recall@5 = 0.88
# Size 1000: Recall@5 = 0.82

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

Teoría (40%):

  • Estrategias de chunking (conceptos)
  • Métricas de evaluación (fórmulas)
  • Trade-offs (tamaño, overlap)

Práctica (60%):

  • Implementar chunking (código)
  • Calcular métricas (código)
  • A/B testing (código)
  • Proyecto RAG completo

Qué NO aprenderás (fuera de scope)

❌ Vector databases (Pinecone, Weaviate):

Razón: Módulo dedicado siguiente (Vector Databases Guide).
Cobertura: In-memory storage (numpy) suficiente para aprender.

❌ LLM generation (GPT-4 responses):

Razón: Enfoque en retrieval (R de RAG), no generation (G).
Cobertura: Solo hasta retrieval de chunks relevantes.

❌ Advanced NLP (NER, POS tagging):

Razón: No es crítico para chunking básico.
Cobertura: Solo sentence/paragraph boundaries.

Herramientas del módulo

Bibliotecas Python:

# Chunking
import tiktoken  # Token counting (OpenAI)
from langchain.text_splitter import RecursiveCharacterTextSplitter

# NLP (sentence boundaries)
import spacy  # Optional para semantic chunking

# Evaluación
import numpy as np  # Métricas custom

# Embeddings (ya visto)
from openai import OpenAI
from sentence_transformers import SentenceTransformer

Setup requerido:

# Instalar LangChain (chunking utilities)
pip install langchain

# Instalar spaCy (optional - sentence boundaries)
pip install spacy
python -m spacy download en_core_web_sm

Estructura del módulo

module-04-evaluacion-chunking/
└── es/
    ├── 01-introduccion-modulo.md        ← Estás aquí
    ├── 02-fixed-size-chunking.md
    ├── 03-semantic-chunking.md
    ├── 04-metricas-retrieval.md
    ├── 05-evaluation-datasets.md
    ├── 06-ab-testing-chunking.md
    ├── 07-advanced-chunking.md
    └── 08-proyecto-rag-chunking-inteligente.md

Habilidades profesionales

Al completar este módulo, demostrarás:

1. RAG Implementation:

  • Implementar chunking production-ready
  • Optimizar chunk size (data-driven)
  • Preservar contexto

2. Evaluation mindset:

  • Crear evaluation datasets
  • Calcular métricas (nDCG, MRR)
  • A/B testing sistemático

3. Trade-off analysis:

  • Balance tamaño vs contexto
  • Overlap optimal
  • Fixed vs semantic chunking

Casos de uso reales

1. Documentation search (1000 docs técnicos):

Requerimientos:

  • Chunks deben respetar secciones (semantic)
  • Recall@5 > 0.85
  • Chunk size: 400-600 tokens

Decisión:

Estrategia: Semantic chunking (por secciones)
Tamaño promedio: 500 tokens
Overlap: 50 tokens
Resultado: Recall@5 = 0.88 ✅

2. Legal document Q&A (contratos):

Requerimientos:

  • Chunks deben preservar cláusulas completas
  • Contexto crítico (no cortar mid-clause)
  • Recall@10 > 0.90

Decisión:

Estrategia: Semantic chunking (por cláusula)
Tamaño variable: 300-1200 tokens
Overlap: 0 (cláusulas no se solapan)
Resultado: Recall@10 = 0.92 ✅

3. Customer support chatbot (FAQs):

Requerimientos:

  • Chunks pequeños (respuestas concisas)
  • Latencia <100ms
  • Precision@3 > 0.80

Decisión:

Estrategia: Fixed-size chunking (simple, rápido)
Tamaño: 200 tokens
Overlap: 20 tokens
Resultado: Precision@3 = 0.83 ✅

Metodología del módulo

Aprendizaje iterativo:

Paso 1: Implementar chunking básico
         ↓
Paso 2: Evaluar con métricas
         ↓
Paso 3: Optimizar (tamaño, overlap, estrategia)
         ↓
Paso 4: Re-evaluar (loop)
         ↓
Paso 5: Proyecto RAG completo

Ejercicio inicial (reflexión)

Escenario:

Tienes 500 documentos técnicos (Python tutorials), cada uno de 2,000 tokens promedio. Usuario pregunta: "How to use list comprehensions?"

Preguntas:

  1. ¿Qué estrategia de chunking usarías? ¿Por qué?
  2. ¿Qué tamaño de chunk sería óptimo?
  3. ¿Necesitas overlap? ¿Cuánto?
  4. ¿Cómo evaluarías si tu chunking funciona bien?

No hay respuesta única (depende de trade-offs).

Al final del módulo, podrás responder con implementación y datos.

Recursos del módulo

Papers y referencias:

  1. LangChain Text Splitters - Chunking strategies
  2. Retrieval Metrics - nDCG, MRR, etc.
  3. RAG Best Practices - Pinecone guide

Herramientas:

  1. LangChain - Chunking utilities
  2. tiktoken - Token counting

En la siguiente cápsula

Cápsula 02: Fixed-Size Chunking

Aprenderás:

  • Character-based vs token-based chunking
  • Implementar chunking con tiktoken
  • Overlap strategies (sliding window)
  • Trade-offs de fixed-size
  • Código production-ready

De introducción a implementación práctica.

Módulo 4 - Embeddings Deep Dive Guide Chunking y evaluación: de documentos largos a RAG production-ready

← AnteriorMini-Proyecto: Benchmark Framework para Modelos de EmbeddingsSiguiente →Fixed-Size Chunking: Implementación Práctica