El módulo 8 fabricó datasets etiquetados; este módulo atiende al consumidor más glotón del stack: los corpus de texto para LLM — el material del fine-tuning, del pre-entrenamiento continuo, y (con matices propios) del RAG del módulo 10. Su rasgo distintivo es la escala con textura: millones de documentos donde nadie leerá ninguno — así que toda la calidad debe ser programática. Las cuatro operaciones de este módulo son el estándar que la industria destiló de entrenar los modelos que usas a diario.

La tesis del módulo

Un corpus de LLM se fabrica con cuatro operaciones en orden: deduplicar (la palanca de calidad número uno — los duplicados sobre-representan, memorizan y fugan), filtrar (calidad e idioma con clasificadores baratos, con el sesgo del filtro como precio vigilado), limpiar PII (obligación de pipeline con detección + enmascaramiento, no promesa de buena conducta), y — si se genera sintético — mezclar y verificar, porque la escala infinita cobra en diversidad. El corpus resultante es un mart versionado, como todo lo que este curso produce.

   EL CORPUS DE LLM — CUATRO OPERACIONES EN ORDEN

  crudo (millones de documentos que nadie lee)
     │
     ▼
  1. DEDUPLICAR   exacta (hash) + difusa (MinHash+LSH)
     │            lo casi-igual sobre-representa y fuga
     ▼
  2. FILTRAR      heurísticas → idioma → calidad
     │            auditar siempre lo que se bota
     ▼
  3. PII          detectar + enmascarar [NOMBRE_1]
     │            antes de tocar entrenamiento
     ▼
  4. SINTÉTICOS   (si hay) mezclar con real, variar,
     │            deduplicar de nuevo, test 100% real
     ▼
  corpus = mart versionado con aduana (módulo 7)

Operación 1: deduplicar — la palanca número uno

Los corpus reales están llenos de repetición: la misma plantilla de correo mil veces, el mismo párrafo legal en cada contrato, el boilerplate del CRM. Entrenar con duplicados tiene tres costos — sobre-representación (el modelo aprende que la plantilla es el idioma), memorización (el texto repetido se recita literal, con sus datos adentro — un riesgo de privacidad directo), y la fuga train/test del módulo 8 a escala industrial. La deduplicación tiene dos niveles:

Exacta: hash del texto normalizado (minúsculas, espacios colapsados) — barata, primera pasada, elimina lo idéntico.
Difusa (fuzzy): el trabajo real, porque los duplicados peligrosos son casi iguales (mismo correo con otro saludo). El estándar es MinHash + LSH: cada documento se reduce a una firma compacta a partir de sus fragmentos (shingles), diseñada para que documentos parecidos tengan firmas parecidas, y el LSH (locality-sensitive hashing) agrupa firmas candidatas sin comparar todos contra todos — lo que vuelve tratable deduplicar millones (la comparación ingenua de N² murió en el primer millón).

# Dedup difusa — el patrón con datasketch (MinHash + LSH)
from datasketch import MinHash, MinHashLSH

def firma(texto: str, num_perm=128) -> MinHash:
    m = MinHash(num_perm=num_perm)
    tokens = texto.lower().split()
    for i in range(len(tokens) - 2):          # shingles de 3 palabras
        m.update(" ".join(tokens[i:i+3]).encode("utf8"))
    return m

lsh = MinHashLSH(threshold=0.8, num_perm=128) # 0.8 = "casi duplicado"
unicos = []
for doc_id, texto in corpus:
    m = firma(texto)
    if not lsh.query(m):                      # ¿se parece a algo ya visto?
        lsh.insert(doc_id, m)
        unicos.append(doc_id)

El umbral (0.8 arriba) es una decisión con trade-off: alto deja pasar parientes cercanos; bajo mata variaciones legítimas (los diez reclamos distintos que comparten estructura). Se calibra mirando muestras de lo que agrupa — no se copia de un blog.

Operación 2: filtrar — calidad e idioma a escala

Nadie lee el corpus; los filtros sí. La batería estándar, en orden de costo: heurísticas (largo mínimo/máximo, proporción de símbolos y mayúsculas, líneas repetidas — el boilerplate y el ruido caen aquí, gratis), identificación de idioma (un clasificador rápido tipo fastText: si el corpus es para español, el inglés colado distorsiona), y clasificadores de calidad (modelos chicos entrenados para puntuar “texto útil” vs. ruido — o, la versión moderna, un LLM barato puntuando muestras con tu rúbrica, el juez de Evals en rol de aduanero).

Ojo — el filtro tiene sesgo, y es tuyo: todo filtro de “calidad” codifica una definición de calidad — el clasificador que puntúa bajo el texto coloquial deja tu corpus formal, y tu modelo fine-tuneado tratará mal los correos coloquiales de tus clientes reales. La auditoría obligatoria: mirar muestras de lo eliminado en cada filtro. Si lo descartado incluye textos que tus usuarios escriben, el filtro está podando tu distribución real — el eco data-céntrico del módulo 1: el sesgo del dataset es el sesgo del modelo.

Operación 3: PII — obligación de pipeline

El corpus del caso del curso son correos de clientes: nombres, RUT, teléfonos, tarjetas. Entrenar con eso es fabricar un modelo que puede recitar datos personales (la memorización de la operación 1, ahora como incidente de privacidad con ley aplicable — la Ley 21.719 y el GDPR del curso de Producto). El tratamiento es una etapa del pipeline, no una promesa:

Detección: librerías dedicadas (Presidio es el estándar open source) que combinan patrones (RUT, tarjetas, correos, teléfonos — los formatos regulares caen con regex bien hechas) y NER (reconocimiento de entidades: nombres y direcciones, que no tienen formato).
Acción: enmascarar con placeholders consistentes ([NOMBRE_1], [RUT]) — no borrar, porque la estructura del texto entrena (“estimado [NOMBRE_1], su boleta…”) y el dato no.
Posición: antes de que el corpus toque la capa de entrenamiento — y recordando la excepción del módulo 2: el bronce con PII tiene retención de política, no de conveniencia. Es el componente 5 de la landing zone aplicado al pipeline de datos: mismo principio, otra tubería.
Verificación: la aduana del módulo 7 incluye un chequeo de PII residual sobre muestra — la detección nunca es perfecta; la medición de cuánto se escapa, obligatoria.

Operación 4: sintéticos — escala que cobra en diversidad

Los datos sintéticos — un LLM generando ejemplos de entrenamiento — resuelven problemas reales: clases raras sin ejemplos (los correos de fraude que casi no existen), privacidad (entrenar con parafraseos sintéticos en vez del texto real), y volumen para arrancar. Y cobran un precio documentado: la diversidad. El generador produce variaciones de su distribución — más pulida, más repetitiva en estructura, más “voz de LLM” que la realidad — y el modelo entrenado en exceso de sintético aprende esa voz y degrada en la calle (el fenómeno estudiado como colapso por auto-consumo). Las reglas de uso adulto:

Regla	Por qué
Sintético mezclado con real, nunca solo	El real ancla la distribución; el sintético rellena huecos
Generar con variedad forzada (personas, tonos, errores de tipeo)	Combatir la voz única del generador
Deduplicar el sintético (operación 1 aplica doble)	Los generadores se repiten más de lo que parece
Evaluar contra un test 100% real	La métrica sobre test sintético mide al generador, no al mundo

Errores comunes

Saltarse la dedup difusa. La exacta atrapa lo idéntico; el daño vive en lo casi-idéntico. MinHash+LSH no es opcional a escala — es la palanca número uno por algo.
Umbral de dedup copiado. El 0.8 de un paper con otro corpus mata o perdona distinto en el tuyo. Se calibra mirando qué agrupa.
Filtrar sin auditar lo eliminado. El filtro que poda tu distribución real fabrica el modelo que no entiende a tus usuarios. Muestras de lo descartado, en cada filtro, siempre.
PII como promesa. “Tendremos cuidado” no es una etapa de pipeline. Detección + enmascaramiento + verificación de residuo, antes de entrenar — con la retención del bronce decidida por política.
Test contaminado de sintético. Evaluar el modelo con datos del mismo generador que lo entrenó es el examen con las respuestas. El test es real o no es test.
El corpus fuera de la disciplina. Como el dataset del módulo 8: mart versionado, con linaje (¿qué filtros, qué umbrales, qué fecha de corte produjeron el v3?), tests y aduana. El “corpus_final_v2_AHORA_SI.jsonl” es el síntoma de que este curso faltaba.

La frase para llevarse

“Cuatro operaciones en orden: dedupe difuso porque lo casi-igual es lo que daña, filtra auditando lo que botas, enmascara PII como etapa y no como promesa, y si generas sintético — mézclalo, fuérzale variedad y examínalo contra realidad pura. El corpus es un mart más; el modelo que salga de él no perdonará que no lo fuera.”

Qué viene

Módulo 10: el pipeline de un RAG a escala. El curso de RAG enseñó la calidad del retrieval; este módulo construye lo que aquel asume: la infraestructura de ingesta que mantiene el índice completo, fresco y barato cuando los documentos son cientos de miles y cambian a diario — detección de cambios, re-indexación incremental (y por qué re-embeber todo cada noche quiebra a alguien), sincronización de permisos, y el índice como asset del módulo 6 con su SLA de frescura.

Data Engineering — Módulo 9: datos para LLM