Problemas de atención de LLM en contexto largo

Por qué los LLMs olvidan hechos en contextos largos: Explicación de la atención y las alucinaciones

Los LLMs basados en transformers sufren degradación de atención en contextos largos: los sesgos de primacía y recencia debilitan el procesamiento de la parte media del texto. Esto conduce al efecto Perdido-en-el-Medio, aumento de alucinaciones y pérdida de precisión incluso con ventanas de millones de tokens. Este artículo cubre las causas del problema y técnicas para sistemas RAG en producción.

Problemas con la auto-atención en secuencias largas

La auto-atención en transformers tiene complejidad cuadrática O(n²), lo que limita la longitud del contexto. Optimizaciones como FlashAttention, RoPE y ALiBi reducen costos pero introducen sesgos posicionales:

• Sesgo de primacía: El inicio del contexto se recuerda mejor.
• Sesgo de recencia: El final del contexto también es accesible.
• La parte media se pierde: Los tokens en el centro reciben atención debilitada debido al enmascaramiento causal y la decaída en los embeddings posicionales.

Aumentar la ventana de contexto no elimina el sesgo; expande la 'zona muerta' en el medio. El modelo no reconoce vacíos sino que genera hechos plausibles pero falsos.

El efecto Perdido-en-el-Medio en números

Investigación de Nelson Liu (Stanford, 2023) mostró una curva de precisión en forma de U: caída del 30–50% para información en el medio de 20–30 documentos. En 2025–2026, MIT y otros laboratorios confirmaron la persistencia del efecto en modelos con 1M+ tokens.

Los benchmarks han evolucionado:

• Needle-in-a-Haystack: Prueba para encontrar un hecho en un texto largo.
• U-NIAH (2026): Compara LLMs de contexto largo y RAG.
• NeedleBench, BABILong, LooGLE: Pruebas de síntesis de partes dispersas.

El Vectara Hallucination Leaderboard (HHEM-2.3, 2026) registra aumento de alucinaciones en 32K+ tokens: el modelo enlaza fragmentos A y C, ignorando B, e inventa lo que falta.

El mecanismo de alucinaciones en contextos largos

OpenAI (2025, 'Cuando más se convierte en menos') señaló: contexto más grande aumenta inferencia pero reduce calidad. El modelo llena vacíos con conexiones 'plausibles'. MIT (2025) añadió: la confianza lingüística crece proporcionalmente a las alucinaciones—cuantos menos hechos, más convincente la ficción.

La cadena: contexto largo → ruido → atención difusa → hecho faltante → entrenamiento RLHF para 'responder siempre' → alucinación creativa.

Estrategias de chunking para RAG

RAG efectivo comienza con división adecuada de documentos. Evita divisores por defecto—usa enfoques dirigidos:

• RecursiveCharacterTextSplitter (LangChain): Chunks de 400–512 tokens, superposición 10–20%. Confiable para textos estructurados.
• SemanticChunker: División por embeddings, +15–20% precisión en datos complejos.
• HierarchicalNodeParser (LlamaIndex): Jerarquía de 2048 → 512 → 128 tokens para recuperación escalonada.

Pasa al modelo 3–5 chunks relevantes en lugar de 100K tokens de basura.

Ejemplo de implementación de chunking con reranking:

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.retrievers import ContextualCompressionRetriever
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import FAISS

# Recursivo + superposición
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=100,
    separators=["\n\n", "\n", ". ", " ", ""]
)

# Divisor semántico
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
semantic_splitter = SemanticChunker(embeddings)

# Reranking
compressor = CrossEncoderReranker(model_name="BAAI/bge-reranker-large")
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=vectorstore.as_retriever(search_kwargs={"k": 20})
)

Recupera 20 chunks, el reranker mantiene top-5—reduce ruido.

Verificación y flujos de trabajo agenticos

Después de la recuperación, añade capas de verificación:

• Auto-consistencia / CoVe: Genera una respuesta, luego preguntas para auto-comprobación.
• Agente Crítico: Un LLM separado valida la respuesta contra el contexto.
• Verificación simbólica: Grafo de Conocimiento o Pydantic para fechas, números, nombres.

Flujo de trabajo agentico (estándar 2026):

• Planificador: Descompone la tarea.
• Agente Recuperador: Busca subtareas.
• Ejecutor: Genera.
• Verificador: Comprobación iterativa.

Bucle de verificación mínimo:

from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool

def verify_answer(answer: str, context: str) -> str:
    prompt = (
        "Verifica si la respuesta coincide con el contexto. "
        "Responde SÍ/NO + explicación.\n"
        f"Contexto: {context}\n"
        f"Respuesta: {answer}"
    )
    return llm.invoke(prompt)

tools = [Tool(name="Verificador", func=verify_answer, description="Verifica si la respuesta coincide con el contexto")]
agent = create_react_agent(llm, tools, prompt=react_prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=5)

Híbrido Neuro-Simbólico para dominios de alto riesgo

En derecho, medicina, finanzas, combina LLM + Grafo de Conocimiento + verificador simbólico. Reduce alucinaciones 60–80% (estudios 2025), pero requiere infraestructura.

Conclusiones clave:

• Contexto largo amplifica Perdido-en-el-Medio y alucinaciones debido a sesgo de atención.
• Chunking (recursivo/semántico) + reranking—70% del éxito de RAG.
• Capas de verificación (CoVe, agentes críticos) son esenciales en producción.
• Flujos de trabajo agenticos valen la pena con riesgos reputacionales.
• Enfoque híbrido para dominios regulados.

— Editorial Team