LLMs y transformers

📐 Fundamento

Antes de procesar texto, hay que convertirlo en números.

Tokenización

Un LLM no opera sobre letras ni sobre palabras enteras: opera sobre tokens, fragmentos de palabras. La técnica estándar es Byte-Pair Encoding (BPE) o variantes.

"pupusa de queso"  →  ["pup", "usa", " de", " queso"]   →  [12345, 678, 91, 2345]

Por qué tokens y no palabras: el vocabulario sería infinito (palabras nuevas, errores tipográficos, idiomas raros). Con ~50.000 tokens cubrís cualquier texto.

Implicaciones prácticas:

• Cuando una API de LLM te factura "por token", 1 palabra ≈ 1.3 tokens en español.
• "GPT" = 1 token. "antidisestablishmentarianism" = 7 tokens. Lenguajes con menos representación (español, código en lenguajes raros) consumen más tokens por idea.

Embeddings

Cada token se convierte en un vector de alta dimensión (típicamente 1024-12288 dimensiones). El modelo aprende durante el entrenamiento a colocar tokens semánticamente similares cerca en ese espacio.

embedding("rey")    - embedding("hombre") + embedding("mujer")  ≈  embedding("reina")

Esa propiedad emergente es famosa: el modelo descubre la estructura del significado sin que nadie le diga qué es género, plural, sinónimo, etc.

Casos de uso prácticos del embedding (sin LLM completo):

• Búsqueda semántica: convertís textos a vectores y buscás los más cercanos por coseno (no por keyword exacto).
• Detección de duplicados en preguntas/tickets.
• Recomendaciones ("documentos similares a este").

Positional encoding

Los transformers no tienen noción intrínseca de orden (todo se procesa en paralelo). Para que distinga "el perro mordió al hombre" de "el hombre mordió al perro", se suma a cada embedding un vector que codifica la posición. Hay variantes: sinusoidal (paper original), aprendido, RoPE (rotary, usado en Llama).

📐 Fundamento

Para cada token, el modelo calcula 3 vectores: Query (Q), Key (K), Value (V) mediante 3 transformaciones lineales aprendidas.

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

Lectura paso a paso:

1. $Q K^T$: producto escalar entre mi query y todas las keys del resto de tokens. Dice "qué tan relacionado estoy con cada uno".
2. $/ \sqrt{d_k}$: normalización para estabilidad numérica.
3. $\text{softmax}$: convierte los scores en una distribución de probabilidad (los pesos suman 1).
4. $\cdot V$: combinación ponderada de los values según esos pesos.

El resultado para cada token es una mezcla del contenido de los tokens más relevantes en su contexto.

Multi-head attention

En vez de una sola atención, el transformer hace varias en paralelo ($h$ "cabezas") y concatena. Cada cabeza puede aprender a fijarse en cosas distintas (sintaxis, semántica, correferencia, posición). Típicamente $h = 16, 32, 64$.

Bloque transformer completo

Cada capa del transformer apila:

Input → MultiHeadSelfAttention → +Residual → LayerNorm
      → FeedForward (MLP) → +Residual → LayerNorm → Output

Un LLM moderno tiene 40-100 de estos bloques apilados. GPT-4 (estimado): 120 capas. Cada capa refina la representación, con cabezas que descubren patrones de más alto nivel a medida que subís.

📐 Fundamento

Un LLM "moderno" como Claude o GPT-4 pasa por 3-4 etapas antes de estar listo:

1. Pretraining (la fase cara)

Entrená el modelo para predecir el siguiente token sobre trillones de tokens de internet, libros, código. Costo: $10M-$100M, semanas a meses de cómputo en miles de GPU.

Resultado: un modelo que "sabe" mucho del mundo pero no necesariamente sigue instrucciones.

2. Supervised fine-tuning (SFT)

Entrenás sobre conversaciones de alta calidad escritas por humanos: "Usuario pregunta X, asistente responde Y". El modelo aprende el formato de respuesta útil.

3. RLHF (Reinforcement Learning from Human Feedback)

Humanos comparan dos respuestas del modelo y eligen la mejor. Un modelo de recompensa aprende esa preferencia, y luego se usa RL (PPO típicamente) para empujar al LLM hacia respuestas que maximicen recompensa.

Esa fase es lo que hace que un LLM se sienta "alineado": evita toxicidad, sigue instrucciones, admite cuando no sabe. Es lo más distintivo de la generación post-ChatGPT.

Variantes modernas: DPO (Direct Preference Optimization) — más simple que PPO, mismo resultado.

4. Prompting (la única fase a tu alcance)

Como usuario de la API, no entrenás nada. Vos sólo armás un prompt (entrada de texto) que extrae el comportamiento que querés. Es ingeniería del input.

Patrones de prompt

• Zero-shot: "Resumí este texto en 3 viñetas." — el modelo lo hace sin ejemplos.
• Few-shot: das 2-3 ejemplos de input → output, después tu input real. Más confiable para tareas estructuradas.
• Chain-of-thought: "Pensá paso a paso antes de responder." — desbloquea razonamiento, especialmente en matemáticas/lógica.
• System prompt: instrucción persistente que define rol/restricciones del asistente. Distinto del mensaje de usuario.

📐 Fundamento

Pipeline RAG mínimo:

1. INDEXACIÓN (offline, una vez)
   docs → chunks (~500 tokens) → embeddings → almacén vectorial

2. CONSULTA (cada pregunta)
   pregunta → embedding → top-k chunks similares → prompt = pregunta + chunks → LLM → respuesta

# Pseudocódigo Python
from openai import OpenAI
import chromadb

client = OpenAI()
db = chromadb.Client().create_collection("kb")

# 1. Indexar
def indexar(docs):
    for i, doc in enumerate(docs):
        for j, chunk in enumerate(chunkear(doc, size=500)):
            emb = client.embeddings.create(model="text-embedding-3-small", input=chunk)
            db.add(ids=[f"{i}-{j}"], documents=[chunk], embeddings=[emb.data[0].embedding])

# 2. Responder
def responder(pregunta):
    q_emb = client.embeddings.create(model="text-embedding-3-small", input=pregunta)
    resultados = db.query(query_embeddings=[q_emb.data[0].embedding], n_results=5)
    contexto = "\n\n".join(resultados["documents"][0])
    prompt = f"Contesta usando SOLO el contexto.\n\nContexto:\n{contexto}\n\nPregunta: {pregunta}"
    r = client.chat.completions.create(model="gpt-4o-mini", messages=[{"role": "user", "content": prompt}])
    return r.choices[0].message.content

Componentes que vas a tomar decisiones reales sobre:

• Chunking: tamaño y solape. Chunks chicos = más relevantes pero pierden contexto. 300-800 tokens, solape 50-100, es el sweet spot.
• Modelo de embedding: OpenAI text-embedding-3-small, Cohere, Voyage, o modelos abiertos como BGE.
• Almacén vectorial: Chroma (local), Qdrant, Weaviate, pgvector (Postgres + extensión), Pinecone (managed).
• Re-ranking: después del top-k, un modelo cross-encoder reordena para mejor precisión.
• Eval: mediar precision@k y recall@k con un set de preguntas con respuestas conocidas.

Agentes (RAG con tools)

Un agente es un LLM al que le permitís llamar funciones (search, calculator, API, código). El loop básico:

LLM → genera "quiero llamar tool X con args Y" → app ejecuta tool → 
le devuelve el resultado al LLM → LLM produce respuesta final (o pide otra tool)

Frameworks: LangChain, LlamaIndex (más opinionados), o directamente la tool-use API de OpenAI/Anthropic. Empezá sin framework — el código directo es más fácil de debuggear.

📐 Fundamento

Foto del ecosistema al cierre de este capítulo (cambia rápido):

Reglas prácticas:

• Empezá con el más pequeño y barato que cumpla la tarea. Subí solo si falla.
• Mediá costos por request real, no por benchmarks. Tu prompt + tu output es lo que pagás.
• Para producción de alto volumen: cache de embeddings, cache de respuestas frecuentes, batching, modelos abiertos on-prem si el costo justifica la operación.