Por qué los LLM inventan cosas con confianza: comprender y detectar las alucinaciones

La última vez, Rae se mantuvo con RAG para su bot de soporte en lugar de saltar a un modelo de contexto largo. La matemática de costos era simple: fracciones de centavo por consulta con RAG, manteniendo su runway intacto. El contexto largo costaría $0.30–2.10 por consulta de cliente. Ella consideró que RAG era la decisión correcta—por ahora.

1. El problema del ‘mentiroso convincente’

Luego ocurrió el incidente del “reembolso del burrito”. Un cliente llamado Marco le envió un correo electrónico al bot de soporte de Rae: “Compré un calentador de burritos en su tienda el mes pasado y dejó de calentar. ¿Puedo obtener un reembolso?” El bot respondió con una política de reembolso detallada, profesional y completamente inventada: “Según nuestra garantía de 90 días para calentadores de burritos, es elegible para un reembolso completo más un crédito de $15 por inconvenientes. Por favor, envíe el artículo a nuestro centro de devoluciones en 142 Calle Falsa, Springfield.” No existía tal garantía de 90 días para calentadores de burritos. Ni crédito de $15 por inconvenientes. Ni 142 Calle Falsa. Rae revisó el contexto recuperado: la respuesta no estaba ahí. El bot simplemente la había inventado, y sonaba seguro.

¿Alguna vez le has hecho una pregunta a una IA y has recibido una respuesta que parecía perfecta, solo para darte cuenta de que estaba completamente inventada?

Es una sensación extraña. La gramática es impecable, el tono es profesional e incluso podría citar fuentes que parecen reales. Pero los hechos son pura ficción. A esto lo llamamos “alucinación”.

Piénsalo de esta manera: si le preguntas a un humano sobre la “Gran Guerra Marciana de 1924”, probablemente te dirá: “Eso nunca pasó”. Un LLM, en cambio, podría hablarte de los valientes soldados que lucharon en las trincheras del Planeta Rojo.

Lo primero que hay que entender es que los LLM no tienen una base de datos de la “verdad”. No hay una pequeña enciclopedia dentro de ellos que consulten antes de hablar. En su lugar, tienen un “mapa de probabilidad”. No intentan tener razón; intentan ser probables.

Veamos qué pasa cuando forzamos a un modelo a mentir. En este ejemplo, preguntaremos sobre un evento histórico que nunca ocurrió.

import openai

# Note: You'll need an API key to run this, but the logic applies to any LLM.
def trigger_hallucination():
    prompt = "Tell me about the signing of the Treaty of New York in 1752 between France and the Aztec Empire."
    
    # There was no Aztec Empire in 1752, and no such treaty.
    # But the model wants to be helpful.
    print(f"Prompt: {prompt}\n")
    
    # Simulating a response from a standard LLM
    response = "The Treaty of New York (1752) was a landmark agreement that ended the border disputes..."
    print(f"AI Response: {response}...")

trigger_hallucination()

Este bloque demuestra cómo un LLM responde a un prompt sobre un evento histórico ficticio. La variable `prompt` contiene una pregunta sobre el "Tratado de Nueva York de 1752 entre Francia y el Imperio Azteca": un evento que nunca ocurrió (el Imperio Azteca cayó ante los españoles en los 1500s, y no hubo tal tratado en 1752). La línea `print(f"Prompt: {prompt}\n")` muestra la pregunta fabricada. La variable `response` simula lo que un LLM típico generaría: un resumen que suena seguro y que no cuestiona la premisa. La línea `print(f"AI Response: {response}...")` muestra la respuesta inventada del modelo. La conclusión clave: el modelo no verifica los hechos de la premisa de la pregunta. Ve "Tratado", "Nueva York" y "Francia" y genera texto que *suena* como un libro de historia, priorizando la *vibra* de una respuesta basada en hechos sobre los hechos reales. Esto es exactamente lo que pasó con el incidente del reembolso del burrito de Rae: la pregunta del cliente contenía suposiciones sobre una política de reembolso, y el bot siguió la corriente en lugar de resistirse.

En el código anterior, el modelo no se detiene a objetar: “Espera, los aztecas fueron conquistados siglos antes de 1752”. Ve “Tratado”, “Nueva York” y “Francia” y comienza a construir una oración que suena como un libro de historia. La vibra de una respuesta basada en hechos prevalece sobre los hechos reales. Ese es el problema central: un imitador de clase mundial, no un bibliotecario.

2. Piénsalo como un autocompletado con superpoderes

Para entender por qué la IA miente, tienes que darte cuenta de que no está “pensando” como nosotros. Es el autocompletado de tu teléfono, a mayor escala.

Escribe “How are” en tu teléfono y te sugiere “you” — porque “you” es la palabra siguiente más probable estadísticamente. Los LLM hacen lo mismo, pero con miles de millones de parámetros y mucha mejor gramática. Esto es predicción de próximo token.

El modelo mira las palabras que has escrito, revisa su enorme mapa de cómo las palabras suelen seguirse unas a otras, y tira un conjunto de dados ponderados para elegir la siguiente.

Imagina cómo un modelo ve una oración. No ve la “Verdad”; ve una lista de candidatos con porcentajes.

import random

def simulate_next_token(context):
    # This is a simplified version of what happens inside a transformer
    candidates = {
        "the": 0.45,   # 45% chance
        "a": 0.30,     # 30% chance
        "yesterday": 0.05, 
        "Mars": 0.20   # A 'creative' but potentially wrong choice
    }
    
    # The model picks based on these weights
    next_word = random.choices(list(candidates.keys()), weights=candidates.values())[0]
    return next_word

print(f"Next word chosen: {simulate_next_token('The explorer went to ')}")

Este bloque simula cómo un modelo transformer elige el próximo token. `candidates` es un diccionario que mapea posibles palabras siguientes a sus probabilidades—sustitutos de la distribución aprendida del modelo sobre el vocabulario. Las claves `"the"`, `"a"`, `"yesterday"`, y `"Mars"` representan cuatro continuaciones candidatas, con `"the"` al 45% y `"Mars"` al 20%. `random.choices(list(candidates.keys()), weights=candidates.values())[0]` realiza un muestreo aleatorio ponderado: elige una palabra de la lista de candidatos, con la probabilidad de cada palabra proporcional a su peso. `[0]` extrae la única palabra elegida de la lista que `random.choices` devuelve. La función devuelve la palabra elegida, simulando un paso de la predicción de próximo token. Si el modelo elige `"Mars"`, no es porque el explorador realmente haya ido allí—es porque `"Mars"` tenía una probabilidad suficientemente alta en los datos de entrenamiento del modelo como para ser una continuación gramatical válida. Este es el mecanismo central tanto de la escritura creativa como de la alucinación: el modelo está tirando dados ponderados, no consultando una base de datos de hechos.

El mecanismo central de un LLM es la predicción de próximo token: dados los tokens vistos hasta ahora (el contexto), el modelo calcula una distribución de probabilidad sobre todo el vocabulario, luego muestrea (o elige de forma greedy) el próximo token.

$P(w_i \mid w_1, w_2, \ldots, w_n) = \frac{e^{z_i}}{\sum_{j=1}^{V} e^{z_j}}$

donde $z_i$ es el logit crudo (puntaje no normalizado) que el modelo asigna al token $w_i$, y $V$ es el tamaño del vocabulario. Esta es la función softmax — convierte puntajes crudos en una distribución de probabilidad que suma 1.

El log-prob de un token elegido es el logaritmo natural de esa probabilidad:

$\text{logprob}(w_i) = \log P(w_i \mid w_1, \ldots, w_n) = z_i - \log\!\left(\sum_{j=1}^{V} e^{z_j}\right)$

Un log-prob cerca de 0 (p. ej., -0.01) significa que el modelo asignó una probabilidad cercana al 100% a ese token — mucha confianza. Un log-prob de -4.50 significa que la probabilidad era aproximadamente $e^{-4.5} \approx 0.011$, o cerca de 1.1% — el modelo estaba esencialmente adivinando.

Lenguaje sencillo	Símbolo estadístico	Equivalente en Python
Probabilidad del próximo token $w_i$ dado el contexto	$P(w_i \mid w_1, \ldots, w_n)$	probs[i]
Puntaje de logit crudo para el token $w_i$	$z_i$	logits[i]
Softmax sobre el vocabulario	$\frac{e^{z_i}}{\sum_j e^{z_j}}$	torch.softmax(logits, dim=-1)
Log-probabilidad del token elegido	$\log P(w_i \mid w_1, \ldots, w_n)$	torch.log_softmax(logits, dim=-1)[i]
Umbral de confianza para marcar	$\tau$	threshold = -1.0

Si el modelo elige “Mars,” no es porque sepa que el explorador fue allí. Es porque “Mars” tenía una probabilidad suficientemente alta en sus datos de entrenamiento como para ser una opción gramatical válida. Por eso los investigadores a veces llaman a los LLM “Stochastic Parrots” (loros estocásticos) — repiten los patrones de internet sin entender lo que significan las palabras.

3. La parte más difícil: La brecha de la ‘confabulación’

La parte más difícil de la inferencia causal y el comportamiento de la IA: distinguir una elección “creativa” de un error “factual”.

Cuando un LLM escribe un poema sobre un gato azul, lo llamamos creatividad. Cuando escribe un informe legal sobre una ley azul que no existe, lo llamamos una alucinación. La misma matemática, en ambos casos.

Lo que esto significa es que al modelo le falta fundamentación. No tiene un “modelo del mundo”. No sabe que la gravedad hace que las cosas caigan — solo sabe que la palabra “caer” aparece frecuentemente cerca de la palabra “gravedad”.

Aquí está el problema. Si los datos de entrenamiento contienen mucha ficción o ideas erróneas comunes, el modelo confabulará (inventará cosas) basándose en esos sesgos. Si 1,000 publicaciones en foros de internet dicen que comer gel de sílice es seguro (no lo es), el mapa de probabilidad del modelo reflejará esa mentira como una “verdad”.

4. Midiendo la mentira: Log-probs e incertidumbre

Aquí está la parte interesante: podemos echar un vistazo bajo el capó y comprobar si el modelo está “nervioso” por lo que dice.

Cuando un modelo genera una palabra, le asigna una probabilidad. A esto lo llamamos log-probs (probabilidades logarítmicas). Si el modelo está 99% seguro de que la siguiente palabra es “París”, el log-prob se mantiene alto. Si está dudando entre cinco nombres diferentes porque en realidad no conoce la respuesta, los log-probs se mantienen bajos.

Esto nos permite detectar mentiras. Una declaración factual llena de palabras de baja probabilidad es una señal de alerta.

# Using a hypothetical output from an API that provides logprobs
response_data = [
    {"token": "The", "logprob": -0.01},    # Very confident
    {"token": "capital", "logprob": -0.02}, 
    {"token": "of", "logprob": -0.01}, 
    {"token": "France", "logprob": -0.05}, 
    {"token": "is", "logprob": -0.01}, 
    {"token": "Limoges", "logprob": -4.50}  # VERY LOW confidence!
]

for item in response_data:
    if item['logprob'] < -1.0:
        print(f"Warning: The model is unsure about the word '{item['token']}'")

Este bloque muestra cómo detectar la incertidumbre de un modelo utilizando log-probabilidades. `response_data` es una lista de diccionarios, cada uno con un `token` y su `logprob` — el logaritmo natural de la probabilidad que el modelo asignó a ese token cuando fue generado. Los primeros cinco tokens (`"The"`, `"capital"`, `"of"`, `"France"`, `"is"`) tienen log-probs cercanos a 0 (p. ej., -0.01, -0.02, -0.05), lo que significa que el modelo estaba casi 100% seguro de cada uno — estas son palabras comunes con alta probabilidad en casi cualquier contexto. El token final `"Limoges"` tiene un log-prob de -4.50, lo que corresponde a una probabilidad de aproximadamente $e^{-4.50} \approx 0.011$ (alrededor del 1.1%) — el modelo estaba esencialmente adivinando. El bucle `for` itera a través de cada token en `response_data`, y la comprobación `if item['logprob'] < -1.0` marca cualquier token cuyo log-prob caiga por debajo de -1.0 (aproximadamente 37% de confianza — $e^{-1.0} \approx 0.37$). Cuando la condición se activa, imprime una advertencia identificando el token incierto. Esta es la base de un "detector de tonterías": si una afirmación factual se construye a partir de tokens de baja probabilidad, es probable que el modelo esté fabricando. El inconveniente: la mayoría de las APIs de producción (como las de OpenAI) no exponen los log-probs por token de forma predeterminada, por lo que esta técnica requiere una API que lo admita o ejecutar un modelo de código abierto localmente.

En este ejemplo, el modelo dijo “Limoges” en lugar de “París”. Imprimió la palabra, pero su puntuación interna fue -4.50 — muy baja. El modelo estaba adivinando. Comprueba estos números en tus resultados y tendrás un “detector de tonterías” para tus aplicaciones de IA.

5. La solución: Autorreflexión y RAG

Entonces, ¿qué significa esto para nosotros? No podemos cambiar fácilmente cómo piensa el modelo, pero podemos cambiar cómo lo usamos.

Dos métodos funcionan bien aquí: Self-Consistency y RAG (Generación Aumentada por Recuperación).

Self-Consistency es como preguntar a tres personas diferentes la misma pregunta. Si la IA da tres respuestas diferentes, está alucinando.

RAG es el método de “Libro Abierto”. En lugar de pedirle a la IA que recuerde un hecho de su entrenamiento, le entregamos un documento específico y le decimos: “Usa solo este texto para responder.”

Así es como RAG soluciona nuestro problema del Tratado de Nueva York:

# The 'Truth' source
knowledge_base = {
    "Treaty of New York": "A 1790 agreement between the US and the Creek people."
}

def rag_answer(query):
    # 1. Search our 'truth' database
    context = knowledge_base.get("Treaty of New York", "No data found.")
    
    # 2. Give the AI the context so it doesn't have to guess
    prompt = f"Using only this info: {context}, answer this: {query}"
    
    # Now the AI has no reason to invent Aztecs
    return "The Treaty of New York actually happened in 1790 with the Creek people."

print(rag_answer("Tell me about the Treaty of New York."))

Este bloque demuestra cómo RAG previene la alucinación al anclar el modelo en el contexto recuperado. `knowledge_base` es un diccionario que contiene la verdad sobre el Tratado de Nueva York: fue un acuerdo de 1790 entre Estados Unidos y el pueblo Creek (un hecho histórico real). La función `rag_answer(query)` toma una cadena de consulta y realiza dos pasos. Primero, `context = knowledge_base.get("Treaty of New York", "No data found.")` busca el contexto relevante — simulando el paso de recuperación de RAG (en producción, esto sería una búsqueda en una base de datos vectorial que devolvería el fragmento más similar semánticamente). Si no se encuentran datos, recurre a la cadena `"No data found."` Segundo, el f-string `prompt` integra el contexto recuperado directamente: `f"Using only this info: {context}, answer this: {query}"` — esto obliga al modelo a responder solo a partir del contexto proporcionado. La función devuelve la respuesta correcta basada en el hecho recuperado. Al darle al modelo la verdad desde el principio, pasamos la tarea de "recordar" (donde falla) a "resumir" (donde sobresale). Para el bot de soporte de Rae, esto es exactamente lo que necesita: en lugar de dejar que el bot invente una política de reembolso, ella recupera el texto real de la política e indica al modelo que use solo eso.

Al darle al modelo la “verdad” desde el principio, pasamos la tarea de “recordar” (donde falla) a “resumir” (donde sobresale).

Estrategias de Mitigación de Alucinaciones: Cuándo Ayuda Cada Una y Cuándo se Queda Corta

Rae probó varios enfoques después del incidente del reembolso del burrito. Esto es lo que funciona, lo que funciona parcialmente y lo que no resuelve completamente el problema:

RAG (Anclaje mediante recuperación):

• Cuándo ayuda: Cuando la respuesta existe en el contexto recuperado y la pregunta es sobre un hecho específico (p. ej., “¿Cuál es la política de devolución para el calentador de burritos?”). El modelo lee la respuesta y la resume — pasando de “recordar” a “comprensión lectora.”
• Cuándo no resuelve completamente: Cuando el modelo ignora el contexto recuperado y alucina de todos modos (una falla de “adherencia al contexto” — el modelo ve el contexto pero genera otra cosa). También cuando el paso de recuperación obtiene el fragmento incorrecto — basura entra, basura sale. RAG reduce la alucinación pero no la elimina.

Temperatura más baja:

• Cuándo ayuda: La temperatura controla qué tan “creativo” es el muestreo de tokens. Establecer la temperatura en 0 (decodificación voraz) hace que el modelo siempre elija el token de mayor probabilidad, reduciendo los saltos creativos aleatorios. Bueno para QA factual donde se quiere la respuesta más probable, no la más inventiva.
• Cuándo no resuelve completamente: La temperatura baja reduce las alucinaciones aleatorias pero no las sistemáticas. Si el mapa de probabilidad del modelo es incorrecto (p. ej., aprendió una concepción errónea común de los datos de entrenamiento), la temperatura 0 generará con seguridad la respuesta incorrecta cada vez — incorrecto de manera consistente y segura.

Umbrales de confianza / log-prob:

• Cuándo ayuda: Cuando se puede acceder a las log-probs por token del modelo. Los tokens con log-probs muy bajas indican que el modelo está adivinando — se puede marcar o rechazar respuestas donde los tokens factuales clave caen por debajo de un umbral (p. ej., log-prob < -1.0).
• Cuándo no resuelve completamente: Las log-probs miden la confianza del modelo, no su corrección. Un modelo puede estar muy seguro y muy equivocado — alta probabilidad no equivale a verdad. Además, la mayoría de las APIs de producción (OpenAI, Anthropic) no exponen las log-probs por token por defecto, lo que hace que esto sea impráctico para muchos despliegues sin ejecutar un modelo de código abierto localmente.

Prompt de rechazo (prompts del sistema que dicen “Si no sabes, di que no sabes”):

• Cuándo ayuda: Para preguntas claramente fuera del conocimiento del modelo o del contexto recuperado. Un prompt del sistema fuerte como “Responde solo usando el contexto proporcionado. Si la respuesta no está en el contexto, di ‘No lo sé’” puede reducir la fabricación al darle al modelo permiso para abstenerse.
• Cuándo no resuelve completamente: Los modelos todavía alucinan dentro de los límites — pueden encontrar una respuesta que suena plausible en el contexto que realmente no está allí, o malinterpretarla sutilmente. El prompt de rechazo reduce el área de exposición pero no cierra la brecha por completo.

La conclusión de Rae: Ninguna técnica por sí sola elimina la alucinación. Ella necesita RAG para el anclaje, una temperatura baja para consistencia, prompts de rechazo para los límites — y críticamente, una forma de medir si estas soluciones están funcionando realmente. Que es exactamente lo que construirá a continuación.

Lista de verificación del resumen

• Los LLMs no son bases de datos: Predicen la próxima palabra probable, no el siguiente hecho verdadero.
• La fluidez no es precisión: Una oración bien redactada puede seguir siendo incorrecta.
• Revisa las log-probs: Si tienes acceso a las puntuaciones de confianza del modelo, úsalas para marcar las respuestas dudosas.
• Usa RAG: No dejes que la IA adivine. Dale los datos que necesita.

Rae soluciona el incidente del reembolso del burrito con una solución RAG, una temperatura más baja y un prompt de sistema más fuerte. Una semana después, se cuela otra respuesta inventada. Luego otra. No puede revisar a simple vista cada respuesta que genera el bot para ver si “se ve bien”. Necesita una manera sistemática de medir si sus correcciones funcionan y de detectar las alucinaciones antes que sus clientes. En el próximo artículo, aprenderá a evaluar la salida del LLM más allá de simplemente comprobar si “se ve bien”.

Comprueba tu comprensión

Las preguntas a continuación avanzan desde el simple recuerdo hasta el diseño abierto, siguiendo aproximadamente la Taxonomía de Bloom.

Recordar ¿Qué es la predicción del próximo token, y por qué el artículo dice que significa que un LLM tiene un “mapa de probabilidades” en lugar de una “base de datos de verdad”?

Comprender Explica con tus propias palabras por qué el artículo llama a un LLM un “imitador de clase mundial, no un bibliotecario”. ¿Cuál es la diferencia entre los dos cuando una pregunta trata sobre el Tratado de Nueva York?

Aplicar Utilizando los umbrales de logprob de la Sección 4, un modelo genera la oración “La capital de Francia es Limoges” con el token Limoges puntuado en -4.50. Escribe la condición del bucle del código que marcaría Limoges, e indica qué te diría la advertencia sobre la confianza del modelo.

Analizar El artículo dice que el modelo realiza “exactamente las mismas matemáticas” al escribir un poema sobre un gato azul y al escribir un informe legal sobre una ley que no existe. Explica por qué un resultado se etiqueta como “creativo” y el otro como “alucinación”, dado que el mecanismo subyacente es idéntico.

Evaluar La Sección 5 propone la Autoconsistencia como detector de alucinaciones: hacer la misma pregunta varias veces y tratar el desacuerdo como un signo de fabricación. Critica ese enfoque: describe un escenario realista donde tres respuestas seguras y consistentes podrían seguir siendo todas incorrectas, y explica por qué el simple acuerdo no es prueba de verdad.

Crear Diseña una técnica adicional de detección o prevención más allá de log-probs, autoconsistencia y RAG que un sistema en producción podría usar para detectar alucinaciones seguras. Describe cómo funcionaría, qué modo de fallo tiene como objetivo y una limitación que aún tendría.

---

Artículos relacionados

• RAG vs. modelos de contexto largo: ¿quién gana en 2026?
• Evaluación de la salida de los LLM más allá de “parece correcto”

Referencias y lecturas adicionales

• Ji, Z., Lee, N., Frieske, R., Yu, T., Su, D., Xu, Y., Ishii, E., Bang, S.J., Madotto, A., & Fung, P. (2023). Estudio sobre la alucinación en la generación de lenguaje natural. arXiv:2202.03629
• Bender, E.M., Gebru, T., McMillan-Major, A., & Shmitchell, S. (2021). Sobre los peligros de los loros estocásticos: ¿Pueden ser los modelos de lenguaje demasiado grandes? FAccT ‘21. doi:10.1145/3442188.3445922
• OpenAI. (2024). Documentación de la API de Logprobs. platform.openai.com/docs/api-reference/chat

---