Modelos de lenguaje: cómo «piensa» ChatGPT

Definición

Un modelo de lenguaje grande (LLM, Large Language Model) es una red neuronal entrenada con enormes cantidades de texto para resolver una sola tarea: dado un texto, estimar qué token viene después. ChatGPT, Claude y Gemini son productos construidos sobre modelos de este tipo. No consultan una base de datos de hechos ni «entienden» como una persona: generan la respuesta prediciendo, uno por uno, los fragmentos de texto más probables según lo que aprendieron.

Que una tarea tan simple produzca respuestas útiles se explica por la escala. Para predecir bien la siguiente palabra en millones de documentos, el modelo tiene que capturar gramática, datos frecuentes, estilos, razonamientos que se repiten en los textos e incluso patrones de código. Esa capacidad aparece como efecto de la predicción, no como un módulo aparte.

Este artículo abre la fase de inteligencia artificial generativa de la serie. Los siguientes días se apoyan en él: cómo darle instrucciones (día 10), cómo conectarlo con tus documentos (día 11) y cómo convertirlo en un agente que usa herramientas (día 13).

Cómo funciona por dentro

Casi todos los LLM actuales usan la arquitectura Transformer, publicada por Google en 2017 en el artículo «Attention Is All You Need». El recorrido de un texto por el modelo tiene cuatro etapas:

Los parámetros del modelo (los pesos de esas capas, que van de miles de millones a cientos de miles de millones) son lo único que se aprende en el entrenamiento. El modelo no guarda los textos con los que se entrenó: guarda una compresión estadística de ellos, por eso puede equivocarse con datos concretos.

Tokens: la unidad con la que lee y cobra

Un token es un fragmento de texto: puede ser una palabra completa («casa»), un pedazo de palabra («est», «ás») o un signo («?»). Los modelos usan tokenizadores de subpalabras, como BPE (Byte Pair Encoding), que parten de caracteres y van uniendo los pares más frecuentes del corpus hasta formar un vocabulario de decenas de miles de piezas.

Consecuencias prácticas:

• El costo se mide en tokens. Las APIs cobran por millón de tokens de entrada (lo que envías) y de salida (lo que el modelo genera); la salida suele ser más cara. Los precios cambian con frecuencia y deben consultarse el día que se decide.
• El español gasta más tokens que el inglés. Los vocabularios se construyen con corpus donde domina el inglés, así que una frase en español suele partirse en más piezas. Como referencia, OpenAI estima que en inglés un token equivale a unos 4 caracteres; en otros idiomas la proporción cambia.
• Los límites se cuentan en tokens, no en palabras: el tamaño de la ventana de contexto y el máximo de la respuesta.
• Cada modelo tokeniza distinto. El mismo texto puede costar un número diferente de tokens en ChatGPT, Claude o Gemini. Cada proveedor publica un contador o un método en su API para medirlo.

La predicción del siguiente token

Para responder, el modelo ejecuta un bucle autorregresivo:

1. Recibe todo el texto disponible (instrucciones, conversación y lo que ya generó).
2. Calcula la probabilidad de cada token del vocabulario.
3. Elige uno según una estrategia de decodificación.
4. Lo agrega al texto y vuelve al paso 1, hasta generar un token de fin o llegar al límite.

Por eso las respuestas aparecen «escribiéndose»: el servidor envía cada token en cuanto lo genera (streaming). Y por eso el tiempo de respuesta crece con la longitud de la salida.

La estrategia de decodificación se controla con parámetros de la API:

Con temperatura 0 el modelo tiende a elegir siempre el token más probable (decodificación codiciosa o greedy). Aun así, las APIs no garantizan respuestas idénticas entre llamadas.

Cómo se entrena un LLM

El conocimiento del modelo se congela en la fecha de corte (knowledge cutoff) de sus datos. Lo que pasó después, o lo que nunca fue público (los documentos de tu empresa), no está en sus parámetros. Las dos formas habituales de dárselo son ponerlo en el prompt o recuperarlo en el momento de responder (RAG, día 11).

Ventana de contexto

La ventana de contexto (context window) es el número máximo de tokens que el modelo procesa en una llamada: instrucciones del sistema + historial de la conversación + documentos adjuntos + la respuesta que va a generar. Hoy va de decenas de miles a cientos de miles de tokens, y algunos modelos llegan al millón; el valor exacto se consulta en la documentación de cada modelo.

Puntos que conviene saber:

• El modelo no tiene memoria entre llamadas. Las apps de chat reenvían el historial en cada mensaje. Cuando no cabe, la aplicación recorta o resume lo más antiguo: por eso, en conversaciones muy largas, «se olvida» de lo que dijiste al principio.
• Más contexto cuesta más. Cada llamada cobra todos los tokens de entrada, incluido el historial reenviado. Algunos proveedores ofrecen caché de prompts para abaratar el contenido que se repite.
• Más contexto no siempre es mejor. Con textos muy largos, la información en medio puede pasarse por alto; está documentado como el efecto lost in the middle. Dar solo lo relevante suele mejorar la respuesta.

Limitaciones que hay que conocer

Cómo elegir un modelo

No hay un «mejor modelo» en general: se elige para una tarea. Los criterios habituales:

Un patrón común en producción es combinar: un modelo grande para tareas difíciles y uno pequeño, más rápido y barato, para clasificar o resumir en volumen.

Usar un LLM desde código

Las apps hablan con un LLM a través de una API (día 1): una petición HTTP POST con el modelo, los mensajes y los parámetros, y una respuesta en JSON con el texto generado y el conteo de tokens usados. Los campos que comparten los principales proveedores:

La llave de la API se guarda en una variable de entorno o en un gestor de secretos, nunca en el código ni en el repositorio. Los SDK oficiales de cada proveedor y sus guías de inicio rápido están en las referencias.

Práctica: un modelo de lenguaje de juguete

Para ver el mecanismo sin depender de ninguna API, este script de Python (solo biblioteca estándar) construye un modelo de bigramas: «entrena» contando qué palabra sigue a cada palabra, convierte los conteos en probabilidades con temperatura y genera texto con el mismo bucle autorregresivo que un LLM. No es una red neuronal; es la misma tarea en miniatura.

1. Guarda el script como mini_llm.py:

"""Un modelo de lenguaje de juguete: predice la siguiente palabra contando pares (bigramas).

No es un LLM real (no tiene red neuronal ni miles de millones de parámetros), pero hace
exactamente la misma tarea: dado un contexto, asigna una probabilidad a cada token posible
y elige el siguiente. Solo usa la biblioteca estándar de Python.
"""
import math
import random
from collections import Counter, defaultdict

CORPUS = """
el cielo es azul . el mar es azul . el cielo es grande .
el cielo está nublado . el mar es profundo . el perro es grande .
buenos días . buenos días a todos . buenas noches .
el modelo predice la siguiente palabra . el modelo aprende de muchos textos .
"""


def tokenizar(texto: str) -> list[str]:
    # Tokenizador mínimo: separa por espacios. Los LLM reales usan subpalabras (BPE).
    return texto.split()


def entrenar(tokens: list[str]) -> dict[str, Counter]:
    # «Entrenar» aquí = contar qué token aparece después de cada token.
    pares: dict[str, Counter] = defaultdict(Counter)
    for actual, siguiente in zip(tokens, tokens[1:]):
        pares[actual][siguiente] += 1
    return pares


def probabilidades(modelo: dict[str, Counter], contexto: str, temperatura: float = 1.0) -> list[tuple[str, float]]:
    # Convierte los conteos en probabilidades. La temperatura las aplana (>1) o las afila (<1).
    conteos = modelo[contexto]
    logits = {tok: math.log(n) / temperatura for tok, n in conteos.items()}
    m = max(logits.values())
    exp = {tok: math.exp(v - m) for tok, v in logits.items()}
    total = sum(exp.values())
    return sorted(((tok, v / total) for tok, v in exp.items()), key=lambda x: -x[1])


def generar(modelo, inicio: str, n: int, temperatura: float, semilla: int) -> str:
    # Bucle autorregresivo: predice un token, lo agrega y vuelve a predecir con el nuevo contexto.
    rng = random.Random(semilla)
    salida = [inicio]
    for _ in range(n):
        opciones = probabilidades(modelo, salida[-1], temperatura)
        if not opciones:
            break
        tokens, pesos = zip(*opciones)
        salida.append(rng.choices(tokens, weights=pesos)[0])
    return " ".join(salida)


if __name__ == "__main__":
    tokens = tokenizar(CORPUS)
    modelo = entrenar(tokens)
    print(f"Tokens de entrenamiento: {len(tokens)} · vocabulario: {len(set(tokens))}")

    print("\nDespués de «es», ¿qué sigue?")
    for tok, p in probabilidades(modelo, "es"):
        print(f"  {tok:10s} {p:6.1%}")

    print("\nCon temperatura 0.3 (más predecible):")
    for tok, p in probabilidades(modelo, "es", 0.3)[:3]:
        print(f"  {tok:10s} {p:6.1%}")

    print("\nGeneración (semilla fija para que el resultado se repita):")
    print("  T=0.3:", generar(modelo, "el", 6, 0.3, semilla=7))
    print("  T=1.5:", generar(modelo, "el", 6, 1.5, semilla=7))

    # Ventana de contexto: un modelo solo «ve» los últimos N tokens.
    conversacion = tokenizar("me llamo Ana . quiero un correo . para mi jefe . hazlo más corto . ¿cómo me llamo ?")
    ventana = 8
    print(f"\nVentana de {ventana} tokens:", " ".join(conversacion[-ventana:]))
    print("¿«Ana» sigue dentro de la ventana?", "Ana" in conversacion[-ventana:])

2. Ejecútalo con Python 3.10 o superior: python mini_llm.py. Salida real (Python 3.12, Windows):

Tokens de entrenamiento: 55 · vocabulario: 26

Después de «es», ¿qué sigue?
  azul        40.0%
  grande      40.0%
  profundo    20.0%

Con temperatura 0.3 (más predecible):
  azul        47.6%
  grande      47.6%
  profundo     4.7%

Generación (semilla fija para que el resultado se repita):
  T=0.3: el cielo es grande . el cielo
  T=1.5: el cielo es grande . el mar

Ventana de 8 tokens: hazlo más corto . ¿cómo me llamo ?
¿«Ana» sigue dentro de la ventana? False

3. Interpreta el resultado.

• Después de «es», el corpus tiene «azul» dos veces, «grande» dos veces y «profundo» una: de ahí el 40/40/20 %. Un LLM hace lo mismo, pero con un vocabulario de decenas de miles de tokens y considerando todo el contexto, no solo la palabra anterior.
• Con temperatura 0.3, «profundo» baja de 20 % a 4.7 %: la temperatura baja concentra la probabilidad en lo más frecuente.
• La generación muestra el bucle predecir → agregar → repetir.
• La última línea reproduce el «olvido» de la ventana de contexto: si solo caben 8 tokens, el nombre «Ana» quedó fuera y el modelo ya no puede saberlo.

4. Experimenta. Agrega frases al CORPUS y observa cómo cambian las probabilidades; prueba generar(modelo, "buenos", 3, 1.0, semilla=1); reduce ventana a 4. Para pasar a un modelo neuronal real, el curso de Andrej Karpathy de las referencias construye un modelo tipo GPT desde cero con este mismo punto de partida.

Preguntas frecuentes

¿Qué es un LLM en palabras simples?

Es un programa entrenado con muchísimo texto para predecir qué palabra sigue. Repitiendo esa predicción, token por token, redacta respuestas completas. ChatGPT, Claude y Gemini funcionan así.

¿ChatGPT entiende lo que dice?

No como una persona. Genera el texto más probable según los patrones que aprendió. Por eso puede sonar seguro y aun así equivocarse; las respuestas importantes se verifican.

¿Qué es un token y por qué se cobra por token?

Es un fragmento de texto: una palabra, parte de una palabra o un signo. Es la unidad que el modelo procesa, así que el trabajo de cómputo y el precio se miden en tokens de entrada y de salida.

¿Por qué la IA olvida lo que dije al principio de una conversación larga?

Porque solo procesa lo que cabe en su ventana de contexto. Cuando la conversación la rebasa, la aplicación recorta o resume lo más antiguo.

En el reel lo explicamos así

Piensa en el autocompletado de tu teléfono: escribes «buenos» y te sugiere «días». Un LLM es ese autocompletado, pero entrenado con una biblioteca entera. No lee palabras completas, sino pedacitos llamados tokens (por eso se cobra por token). Para responderte predice un token, lo agrega y vuelve a predecir, pedacito por pedacito. Y solo recuerda lo que cabe en su ventana de contexto: si la plática es muy larga, lo primero se le olvida.

Referencias

• Vaswani et al., «Attention Is All You Need» (2017): el artículo que presentó la arquitectura Transformer.
• OpenAI, ¿Qué son los tokens y cómo contarlos?: tokens, proporción de caracteres por token y tokenizador.
• Anthropic, Ventanas de contexto: cómo se llena la ventana en una conversación.
• Google, Introducción a los modelos de lenguaje grandes: curso breve de Google for Developers.
• Liu et al., «Lost in the Middle: How Language Models Use Long Contexts» (2023).
• Ouyang et al., «Training language models to follow instructions with human feedback» (2022): el ajuste con preferencias humanas (RLHF).
• Jurafsky y Martin, Speech and Language Processing, capítulo de modelos de n-gramas: la base estadística del ejemplo de la práctica.
• Andrej Karpathy, «Let's build GPT: from scratch, in code, spelled out»: construir un modelo tipo GPT paso a paso.