Fundamentos de LLMs
¿Qué es un Large Language Model?
Un LLM es un modelo de deep learning basado en la arquitectura Transformer que ha sido entrenado con cantidades masivas de texto para predecir el siguiente token en una secuencia. Esta capacidad simple da origen a habilidades emergentes como razonamiento, traducción, código y conversación.
Arquitectura Transformer
┌─────────────────────────────────────────────┐
│ TRANSFORMER │
│ │
│ Input: "El gato se sentó en el ___" │
│ │
│ 1. Tokenización → [El, gato, se, sentó...] │
│ 2. Embeddings → vectores de dimensión d │
│ 3. Self-Attention (multi-head) │
│ - Query, Key, Value matrices │
│ - Attention(Q,K,V) = softmax(QK^T/√d)V │
│ 4. Feed-Forward Networks │
│ 5. Layer Normalization │
│ 6. Repetir N layers (GPT-4: ~120 layers) │
│ 7. Output layer → probabilidad por token │
│ │
│ Output: "sofá" (p=0.35), "mat" (p=0.28) │
└─────────────────────────────────────────────┘
Self-Attention: La Clave
El mecanismo de self-attention permite que cada token "atienda" a todos los demás tokens de la secuencia, capturando relaciones contextuales sin importar la distancia.
Attention(Q, K, V) = softmax(Q · K^T / √d_k) · V
- Q (Query): ¿Qué busco?
- K (Key): ¿Qué tengo para ofrecer?
- V (Value): ¿Qué información doy?
- √d_k: Factor de normalización
Tokenización
Los LLMs no procesan texto directamente — lo convierten en tokens (subpalabras).
Texto: "Programación en Python"
Tokens: ["Program", "ación", " en", " Python"]
Token IDs: [38294, 2621, 551, 13585]
# Diferentes tokenizadores:
# - BPE (Byte-Pair Encoding): GPT, Llama
# - SentencePiece: T5, Gemini
# - WordPiece: BERT
¿Por qué importa la tokenización en LLMOps?
- Costos: Se cobra por token, no por palabra
- Context window: Límite en tokens (no caracteres)
- Idiomas: Español usa ~1.5x más tokens que inglés
- Código: Puede tokenizar ineficientemente
import tiktoken
encoder = tiktoken.encoding_for_model("gpt-4")
tokens = encoder.encode("Hola mundo desde Python")
print(f"Tokens: {len(tokens)}") # 5 tokens
print(f"Costo estimado: ${len(tokens) * 0.00003:.6f}")
Parámetros de Generación
Temperature
Controla la aleatoriedad de la salida:
temperature = 0.0 → Determinista, siempre elige el token más probable
temperature = 0.7 → Balance creatividad/coherencia (recomendado general)
temperature = 1.0 → Más creativo, menos predecible
temperature = 2.0 → Muy aleatorio, puede ser incoherente
Top-p (Nucleus Sampling)
Selecciona tokens cuya probabilidad acumulada no supere p:
top_p = 0.1 → Solo considera el top 10% de probabilidad (más enfocado)
top_p = 0.9 → Considera el top 90% (más diverso)
top_p = 1.0 → Considera todos los tokens
Max Tokens
Límite de tokens en la respuesta generada.
Stop Sequences
Tokens que detienen la generación.
Frequency/Presence Penalty
Penalizan repetición de tokens ya usados.
Context Window
El context window es la cantidad máxima de tokens que un modelo puede procesar (input + output).
| Modelo | Context Window | ~Palabras |
|---|---|---|
| GPT-3.5 | 16K tokens | ~12,000 |
| GPT-4o | 128K tokens | ~96,000 |
| Claude 3.5 | 200K tokens | ~150,000 |
| Gemini 1.5 Pro | 2M tokens | ~1,500,000 |
| Llama 3 (8B) | 8K tokens | ~6,000 |
Implicaciones para LLMOps:
- RAG: Necesario cuando los datos exceden el context window
- Chunking: Dividir documentos para que quepan
- Caching: Reutilizar contexto entre requests
- Costos: Más contexto = más tokens = más costo
Embeddings
Los embeddings son representaciones vectoriales de texto que capturan significado semántico.
from openai import OpenAI
client = OpenAI()
response = client.embeddings.create(
model="text-embedding-3-small",
input="LLMOps es fundamental para producción"
)
vector = response.data[0].embedding # [0.023, -0.041, 0.019, ...]
print(f"Dimensiones: {len(vector)}") # 1536
Similitud Coseno
sim(A, B) = (A · B) / (||A|| × ||B||)
sim = 1.0 → Idénticos en significado
sim = 0.0 → Sin relación
sim = -1.0 → Opuestos
Los embeddings son la base de:
- RAG: Buscar documentos relevantes
- Clasificación: Agrupar textos similares
- Búsqueda semántica: Encontrar por significado, no palabras clave
Modelos Populares para Producción
Frontier Models (API)
| Modelo | Fortalezas | Costos (input/output por 1M tokens) |
|---|---|---|
| GPT-4o | Multimodal, rápido, versátil | $2.50 / $10.00 |
| Claude 3.5 Sonnet | Código, razonamiento, largo contexto | $3.00 / $15.00 |
| Gemini 1.5 Pro | Context window enorme, multimodal | $1.25 / $5.00 |
Open-Source (Self-hosted)
| Modelo | Parámetros | Uso ideal |
|---|---|---|
| Llama 3.1 70B | 70B | General-purpose, alta calidad |
| Mistral Large | 123B | Multilingüe, razonamiento |
| Phi-3 Mini | 3.8B | Edge/mobile, baja latencia |
| CodeLlama | 34B | Generación de código |
Resumen
Entender los fundamentos — tokenización, attention, parámetros de generación, embeddings y context windows — es esencial para tomar decisiones informadas en LLMOps: elegir el modelo correcto, optimizar costos, diseñar pipelines de RAG y configurar inference para producción.