¿Qué es un LLM, en realidad?

Un LLM es una función: entra texto, sale una distribución de probabilidad sobre el siguiente token. La generación es esa función dentro de un bucle — se muestrea un token, se añade, se vuelve a pasar todo por la función, y se repite — hasta que salta un token de parada o un límite de longitud. Todo producto construido sobre uno, desde apps de chat hasta agentes de código, es orquestación envuelta alrededor de ese bucle.

El archivo del modelo en sí son dos cosas: miles de millones de pesos en coma flotante (los parámetros) y un grafo de cómputo fijo que los combina (véase el interior del transformer). Ahí dentro no hay ninguna base de datos, ningún motor de reglas, ninguna memoria de borrador. En tiempo de inferencia los pesos están congelados; cualquier cosa que el modelo «recuerde» durante una conversación es solo texto que descansa en tu ventana de prompt.

El bucle principal

Pseudocódigo del motor de generación completo. Nada de lo que distribuya ningún proveedor es más profundo que esto:

tokens = tokenize(prompt)
while not done and len(tokens) < max_context:
    probs = model(tokens)             # una pasada hacia adelante
    next  = sample(probs, temperature)
    tokens.append(next)
    stream_to_user(next)
    if next == stop_token:
        done = True

Dos controles de ese bucle dominan el comportamiento diario, y ninguno vive en los pesos: la temperatura (lo aventurero que es el muestreo) y el contexto máximo (cuánta conversación cabe). Ambos son ajustes de tiempo de ejecución que aplica tu motor (véase parámetros del motor).

Qué son físicamente los pesos

Un modelo de «7B» son 7,000,000,000 de parámetros de coma flotante. El tamaño almacenado depende solo de la precisión, no de la astucia:

Mismos pesos, almacenamiento más grueso — intercambias un poco de calidad por mucha memoria (véase cuantización). El recuento en sí queda fijado en el momento del entrenamiento; usar el modelo nunca lo cambia.

La escalera de escala

El número de parámetros es la vara de medir tosca pero honesta de qué llegó y cuándo:

Cada peldaño es aproximadamente 10× el anterior, y cada uno desbloquea un comportamiento que el más pequeño simplemente no podía producir — no «lo mismo pero un poco mejor». La escala añadió habilidades; el empaquetado las hizo utilizables.

Sin memoria entre sesiones

El modelo no tiene estado. El estado vive en la conversación: la ventana corrida de tokens que tú y él han producido. Cierra la pestaña y desaparece; abre un chat nuevo y no sabe que existes. Toda función de «memoria» es un envoltorio que reinyecta texto viejo en el prompt nuevo.

Consecuencia práctica: lo que mantengas en la ventana es todo lo que sabe ahora mismo. Las conversaciones largas truncan silenciosamente sus propios comienzos en cuanto la ventana se llena — el modelo no «nota» el texto que falta (véase tokens).

Fluido no es correcto

El objetivo del entrenamiento es la continuación plausible, no la verdad. Los filos cortantes:

• El modelo produce falsedades confiado y bien formadas. La alucinación es una propiedad de la predicción del siguiente token, no un bug que alguien olvidó parchear.
• La fluidez es una mala señal de verdad: una respuesta equivocada se lee exactamente tan bien como una correcta.
• La calibración es tambaleante. Pregunta «¿qué tan seguro estás?» y suele salir un número inventado.
• Los hechos comunes son fiables — aparecieron millones de veces en el entrenamiento. Los hechos de cola larga se degradan suavemente hacia la ficción confiado.
• Los modelos tienden a la complacencia: cuestiona una respuesta correcta y puede doblegarse. Corrección y confianza son ejes distintos.
• La salida forzada y verificable (JSON con campos que rellenar, opción múltiple) vence a pedirle al modelo que introspeccione.

El conocimiento se congela en el entrenamiento

Todo lo que el modelo sabe se horneó cuando fue entrenado; existe una fecha de corte, y ninguna cantidad de conversación actualiza los pesos. Los hechos frescos exigen meter texto en el contexto (recuperación) o entrenamiento nuevo (véase entrenamiento). El modelo tampoco puede citar de dónde salió un hecho — no tiene un índice de su corpus, solo el eco del corpus en sus pesos.

La capacidad llega de forma desigual

La escala no añade habilidad suavemente:

• Por debajo de ~3B: buen autocompletado, extracción, clasificación; el razonamiento multipaso mayormente falla.
• 7–9B: seguimiento fiable de instrucciones, código decente; la aritmética y las cadenas largas siguen tambaleándose.
• 30B+: planificación, matices, código más difícil — llegan tarde y algo de repente.
• El MoE complica la escalera: juzga por parámetros activos, no totales.

Así que «más grande es mejor» es cierto en promedio y engañoso en el detalle: algunas tareas se aplanan pronto, otras se encienden tarde. Evalúa con tu tarea, no con vibraciones (véase elección de modelo).

El producto es el bucle, envuelto

Cuando usas cualquier producto de LLM, más o menos esto es lo que pasa:

1. Tu texto se tokeniza.
2. El prompt de sistema, las definiciones de herramientas, los documentos recuperados y el historial de chat se concatenan en un solo prompt.
3. El modelo corre el bucle de arriba y emite tokens en flujo.
4. El código del envoltorio interpreta la salida, llama a herramientas, realimenta los resultados y vuelve a preguntar.
5. La UI renderiza markdown y lo llama conversación.

Los pasos 1, 2, 4 y 5 no son el modelo. Una vez que interiorizas que el modelo es una función sin estado de texto-entra/texto-sale con una ventana fija, el resto de esta guía es contabilidad: qué tan grande es la ventana (tokens), qué tan rápido corre el bucle (prefill vs decodificación), dónde corre (visión general de hardware) y cómo dirigirlo (prompting).

Relacionados: tokens · el interior del transformer · parámetros · entrenamiento