Facsímil 01 · Completo

Los cimientos

El punto de partida: qué es la IA, cómo aprenden las redes, qué son los tokens y cómo leer los modelos clásicos sin perderse.

Empezar lectura Ver índice

Contenido disponible: 12 de 12 capítulos listos
Estado editorial: Completo

Sobre esta edición

Esta página se genera desde capítulos Markdown propios del facsímil. Las fórmulas se renderizan con KaTeX, los mapas con Mermaid y las notas al pie se mantienen junto al texto para leer el facsímil como una pieza autónoma, no como una exportación del taller.

Capítulo 01

Facsímil 1 · Los cimientos

Capítulo 01: Qué es y qué no es la inteligencia artificial

Entrando en el tema

Abres el navegador, escribes «explícame cómo funciona un motor de combustión» y pulsas Intro. En menos de tres segundos tienes delante un texto articulado, con ejemplos, párrafos bien estructurados y un tono didáctico impecable. Tu cerebro, entrenado durante décadas para asociar lenguaje coherente con inteligencia, llega a una conclusión instantánea: aquí dentro hay alguien que sabe de motores.

Es una reacción comprensible, humana y equivocada.

Este capítulo nace exactamente de esa reacción. Vamos a desmontarla pieza a pieza. Porque entender qué es —y sobre todo qué no es— la inteligencia artificial es la primera decisión de ingeniería que tomarás al trabajar con ella. Y posiblemente la más importante.

Qué no es la inteligencia artificial

Empecemos por lo que no es. La lista de malentendidos es larga, pero cinco negaciones bastan para despejar el terreno.

No es magia ni ciencia ficción. No hay una entidad misteriosa dentro de la máquina. Es software, ejecutándose en servidores, con electricidad y silicio.¹ Impresionante, sí. Pero explicable, medible y auditable.

No es una mente consciente. No tiene deseos, emociones ni intenciones. No «quiere» nada. Procesa tokens y calcula probabilidades. Punto. Si alguna vez has sentido que el modelo «te entiende», has experimentado el efecto Eliza: nuestro cerebro antropomorfiza cualquier cosa que produzca lenguaje coherente.²

No es un buscador glorificado. Un buscador recupera páginas o documentos que ya existen. Un LLM (Large Language Model, modelo grande de lenguaje) genera texto a partir de patrones aprendidos durante el entrenamiento y no consulta fuentes por defecto. Son mecanismos radicalmente distintos.

No «piensa» como un humano. Puede producir pasos que parecen razonamiento, pero su mecanismo base es predecir el siguiente token a partir de patrones estadísticos. No hay deliberación, no hay duda, no hay «déjame pensarlo». Hay una multiplicación de matrices a escala industrial.

No es infalible ni objetiva. Puede alucinar —generar información falsa con total confianza—, heredar sesgos de los datos de entrenamiento y carecer de introspección fiable sobre sus propios errores. No te dirá «no sé» a menos que se lo hayas enseñado explícitamente.

Qué sí es la inteligencia artificial

Ahora la definición positiva. Si la IA no es conciencia ni un oráculo, ¿qué es?

Modelos matemáticos masivos. Redes neuronales con miles de millones o billones de parámetros —números— ajustados para reconocer patrones en texto, imágenes, código y audio.

Reconocimiento de patrones a escala. Lo que una persona tarda horas en analizar, el modelo lo procesa en segundos. No «entiende» en el sentido humano de saber qué está diciendo, contrastarlo con el mundo y hacerse responsable de ello: aprende regularidades estadísticas y las usa para producir una salida plausible. Esa diferencia parece filosófica, pero en ingeniería es muy concreta: una salida plausible necesita verificación.

Predicción estadística del siguiente token. Dada una secuencia de tokens, ¿cuál es el más probable a continuación? Esta operación, repetida miles de veces, produce párrafos coherentes, código funcional y respuestas que parecen razonadas. Es el mecanismo central de todo LLM moderno.

Un amplificador de capacidades. Si sabes programar, te hace más rápido. Si no sabes, te da una falsa sensación de que funciona... hasta que deja de hacerlo. La IA no sustituye el criterio humano: lo amplifica. Si le das contexto claro y restricciones precisas, el resultado es impresionante. Si le das ambigüedad, el resultado es impredecible.

Para situarnos en el mapa, estos son los hitos que nos han traído hasta aquí. La parte histórica es estable; la parte de herramientas actuales no lo es. Fecha de corte: 10 de junio de 2026. Ese día, las fuentes consultadas para la fila de sistemas con herramientas y agentes fueron la documentación pública de OpenAI Agents SDK, Claude Agent SDK, Google ADK y Model Context Protocol.³

Fecha	Hito	Por qué importa
1950	Test de Turing	Turing propone un criterio para evaluar si una máquina exhibe comportamiento inteligente. No es un test técnico, pero inaugura la pregunta filosófica que aún nos hacemos.⁴
1956	Conferencia de Dartmouth	McCarthy, Minsky, Shannon y Rochester organizan un taller de verano en Dartmouth College. Acuñan el término «inteligencia artificial».⁵ Es el nacimiento del campo como disciplina.
1986	Retropropagación	Rumelhart, Hinton y Williams publican el algoritmo que permite entrenar redes de más de dos capas. Sin esto no existiría el deep learning.⁶ Lo veremos en detalle en el capítulo 6.
2012	AlexNet gana ImageNet	Una red neuronal convolucional arrasa en el concurso de reconocimiento de imágenes. Comienza la era del deep learning moderno.⁷
2017	Transformer	El artículo «Attention Is All You Need» presenta una arquitectura que procesa todas las palabras simultáneamente en vez de secuencialmente. Es la base de todo lo que vino después.⁸ Lo desarrollaremos con todo detalle en el facsímil 3.
2020	GPT-3	175 000 millones de parámetros. Demostró que escalar funciona: más datos y más parámetros producen más capacidad.⁹
2022	ChatGPT	RLHF —aprendizaje por refuerzo con feedback humano— más una interfaz de chat. La IA se hace accesible al público general.
2023	GPT-4	Multimodal y con razonamiento avanzado. Salto cualitativo en capacidades.¹⁰
2024	Claude 3 / Gemini	Competencia real. Contextos de 200 000 o más tokens. La IA se convierte en herramienta de trabajo diaria.
2025-2026	Sistemas con herramientas y agentes de software	El chat deja de ser la única interfaz. Aparecen SDKs y protocolos que combinan modelo, herramientas, estado, trazas, aprobaciones y ejecución sobre entornos reales. Lo exploraremos a fondo en el facsímil 5.

Cómo funciona por dentro

Este capítulo es conceptual: no vamos a derivar nada ni a multiplicar matrices. Pero antes de cerrarlo necesitas entender el mecanismo que está debajo de todo lo demás. Porque cada capítulo futuro —la neurona artificial, la retropropagación, el Transformer, los agentes— se construye sobre esta pieza.

Se llama predicción del siguiente token y funciona así.

Imagina que escribes:

El cielo es de color

El modelo recibe esta secuencia y ejecuta tres pasos:

Paso 1: tokenización. Convierte cada palabra —o fragmento de palabra— en un número que la identifica. «El» podría ser el token 145, «cielo» el 2897, «es» el 56, «de» el 1024 y «color» el 3810. El modelo no ve palabras: ve secuencias de números.

El modelo no ve palabras: ve secuencias de números. En el capítulo 9 exploraremos la tokenización en profundidad y entenderemos por qué «cielo» puede ser un token y «extraordinariamente» pueden ser tres.

Paso 2: transformación por pesos aprendidos. Esos números atraviesan las capas de la red neuronal. En cada capa, los miles de millones de parámetros —los pesos aprendidos durante el entrenamiento— transforman la representación. Conviene no llamarlo «memoria» sin matiz: el modelo no abre una ficha interna sobre el cielo ni recupera una frase guardada. Aplica pesos que codifican regularidades observadas durante el entrenamiento y produce una representación nueva de la secuencia.

Paso 3: muestreo. El modelo produce una distribución de probabilidad sobre todas las palabras posibles que podrían seguir. No elige «la correcta». Asigna probabilidades:

azul: 97 %
gris: 2 %
rojo: 0,5 %
verde: 0,3 %
naranja: 0,1 %
...y una probabilidad minúscula para cada una de las decenas de miles de palabras de su vocabulario.

Luego muestrea de esa distribución. Normalmente elegirá azul, pero no siempre. Esa pequeña probabilidad de elegir gris o rojo es lo que hace que el texto generado no sea idéntico en cada ejecución. Es lo que le da variabilidad, creatividad... y también impredecibilidad.

El proceso se repite. El token elegido —digamos azul— se añade a la secuencia de entrada:

El cielo es de color azul

Y el modelo predice el siguiente:

El cielo es de color azul ,

Y el siguiente:

El cielo es de color azul, aunque

Y así, token a token, durante cientos o miles de iteraciones, hasta que el modelo genera un token especial que significa «terminé». Lo que empezó como una pregunta de cinco palabras se convierte en una respuesta de tres párrafos.

No hay comprensión humana, intención ni conciencia. Hay una operación estadística —predecir el siguiente elemento probable de una secuencia— ejecutada a una escala que produce resultados que parecen inteligentes. La precisión importa: no estamos diciendo que el sistema sea inútil; estamos diciendo que su utilidad no lo convierte en sujeto, oráculo ni fuente fiable por sí misma.

flowchart LR
    A["«El cielo es de color»"] --> B["Tokenización"]
    B --> C["[145, 2897, 56, 1024, 3810]"]
    C --> D["Modelo\nmiles de millones\nde parámetros"]
    D --> E["Distribución de\nprobabilidad"]
    E --> F["Muestreo"]
    F --> G["«azul» (97 %)"]
    G -.->|"se añade a la entrada"| A

En el día a día

Entender qué es y qué no es la IA no es un ejercicio filosófico. Determina decisiones de ingeniería concretas. Veamos tres situaciones reales.

Situación 1: ¿LLM o SQL? Tienes una base de datos con millones de registros de ventas y necesitas saber el importe total del último trimestre. Si crees que el LLM «sabe cosas», le pasarás el prompt «¿cuánto vendimos el último trimestre?» y obtendrás un número. El problema es que ese número puede ser correcto, aproximado o completamente inventado, y no tendrás forma de saberlo sin verificarlo manualmente. Si entiendes que el LLM predice tokens, usarás SQL para la consulta exacta y el LLM para resumir el resultado o redactar el informe. Cada herramienta para lo que sirve.

Situación 2: integrar IA generativa en un producto. Tu equipo quiere añadir un asistente que responda preguntas de los usuarios sobre la documentación. Si crees que el modelo es infalible, desplegarás sin guardrails ni evaluaciones y el primer usuario que reciba una respuesta incorrecta —con la confianza y elocuencia características de un LLM— actuará sobre información falsa. Si entiendes que el modelo alucina, diseñarás el sistema con verificación humana para decisiones de impacto, recuperación de documentos fuente para respuestas auditables y evaluaciones automáticas que midan la tasa de alucinación antes de cada despliegue.

Situación 3: depurar código generado. Le pides al modelo que escriba una función de autenticación y te devuelve treinta líneas impecables. Si crees que «piensa», confiarás y desplegarás. Si entiendes el mecanismo, revisarás cada línea como harías con el código de un compañero junior muy rápido pero sin criterio: ¿valida todos los casos límite?, ¿usa una biblioteca actualizada?, ¿hay algún error sutil de lógica que solo se manifiesta con ciertos valores de entrada? La elocuencia del código no garantiza su corrección.

Por qué debería importarte

La decisión técnica más importante al trabajar con IA no es qué modelo usar ni qué proveedor elegir. Es entender qué estás usando realmente.

De esa comprensión —o de su ausencia— se derivan todas las decisiones posteriores: cuándo desplegar un agente autónomo y cuándo un simple prompt, cómo diseñar las evaluaciones, qué nivel de supervisión humana exigir, cuánto presupuesto asignar a la revisión de salidas, qué arquitectura de software elegir para integrar el modelo.

Si entiendes que la IA no piensa, no entiende y no razona como un humano, puedes usarla mejor: le darás instrucciones más precisas, diseñarás sistemas que no dependan de su infalibilidad y confiarás menos ciegamente en sus respuestas.

El resto de este libro asume que has interiorizado esta idea. Cada capítulo vuelve a ella desde un ángulo distinto.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Antropomorfizar («la IA cree que...», «el modelo piensa que...»)	Atribuir estados mentales a un sistema estadístico lleva a confusiones graves sobre sus capacidades y limitaciones. El modelo no cree nada: asigna probabilidades.	Sustituir mentalmente «la IA cree» por «el modelo asigna alta probabilidad a». Obligarse a usar el vocabulario técnico hasta que se convierta en hábito.
Tratarla como un oráculo infalible	Desplegar sin verificación humana en contextos donde el error tiene consecuencias económicas, legales o de seguridad. El modelo siempre responde con confianza, incluso cuando la respuesta es falsa.	Diseñar siempre con supervisión humana para decisiones de impacto. Si la decisión mueve dinero, afecta a personas o tiene consecuencias legales, un humano debe revisarla.
Confundir elocuencia con corrección	Un modelo puede generar texto perfectamente articulado, con estructura impecable y tono profesional, y ser completamente falso. La fluidez no es garantía de veracidad.	Verificar hechos contra fuentes externas. Las evaluaciones miden corrección, no estilo. Un texto bien escrito y equivocado es más peligroso que uno mal escrito y correcto.
Subestimar el no determinismo	Esperar la misma salida para el mismo prompt. El modelo muestrea de una distribución de probabilidad; dos ejecuciones pueden producir respuestas distintas. Esto rompe los tests unitarios tradicionales.	Diseñar tests que validen estructura y propiedades —¿la respuesta contiene un número?, ¿menciona los tres conceptos clave?—, no texto exacto.

Manos a la obra

La práctica de este capítulo no consiste en llamar a una API. Consiste en algo más básico y más profesional: decidir si un caso necesita IA generativa o no. Muchas integraciones fallan antes de escribir la primera línea de código porque alguien confunde un LLM con una base de datos, un buscador, una calculadora, una política de permisos o una persona responsable.

He dejado un kit ejecutable en kit descargable. El ejercicio toma cinco casos realistas —ventas trimestrales, dudas sobre una política de becas, redacción de un correo, reembolso de cliente e incidencia de producción— y aplica una política sencilla para recomendar una arquitectura mínima: SQL o código determinista, buscador/RAG, LLM, herramienta/API, revisión humana o sistema híbrido.

Importante: esa política no es un algoritmo universal ni una verdad del sector. Es una heurística de auditoría para aprender a formular la primera pregunta profesional: «¿qué pieza mínima resuelve este caso con menos riesgo?». En un proyecto real la ajustarías con normativa, coste, privacidad, madurez del equipo, requisitos de latencia y consecuencias del error.

Qué creas.

output/ai_fit_report.json: informe estructurado con recomendación, componentes y controles por caso.
output/ai_fit_decision.md: decisión legible que podrías revisar con un equipo antes de construir nada.
Makefile: atajos para ejecutar, probar y limpiar el kit sin memorizar comandos.
tests/test_triage_ai_fit.py: pruebas que verifican que la política no recomienda un LLM puro cuando hace falta cálculo exacto o revisión humana.
requirements.txt: recordatorio explícito de que esta práctica no necesita dependencias externas.

Cómo lo ejecutas.

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/triage_ai_fit.py --write
cat output/ai_fit_decision.md

Si prefieres ejecutarlo como mini proyecto reproducible:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

Qué deberías ver. El caso de ventas no se resuelve con un LLM puro: necesita consulta exacta y linaje. El caso de becas pide recuperación de documentos y citas. El correo sí puede apoyarse en generación. El reembolso combina base de datos, herramienta/API y revisión humana porque actúa sobre dinero. La incidencia de producción necesita leer estado real antes de redactar. Los tests deben pasar y proteger tres ideas del capítulo: las recomendaciones pertenecen al vocabulario permitido, los casos de alto impacto no pasan sin revisión y los cálculos exactos no se delegan a generación de texto.

Cómo lo adaptas a tu caso. Cambia data/use_cases.json por tres decisiones reales de tu equipo o de una práctica universitaria. Después ajusta contracts/decision_policy.json: por ejemplo, sube o baja el umbral de revisión humana, añade controles obligatorios o separa casos regulados de casos internos.

Qué entregaría un alumno. Un buen entregable incluye el Markdown generado, dos casos propios añadidos, una justificación de por qué al menos un caso no debe resolverse con un LLM puro y una propuesta de controles mínimos para el caso de mayor impacto.

Cómo encaja todo

Este mapa se lee de izquierda a derecha. Primero aparece el suelo que hereda el capítulo: la pregunta histórica por la inteligencia y la realidad material de que hablamos de software estadístico. En el centro está la idea que debes llevarte: un modelo de lenguaje predice tokens, no consulta la verdad. A la derecha aparece la decisión de ingeniería que nace de esa idea: elegir entre consulta exacta, recuperación documental, generación, herramientas y supervisión.

Si el mapa solo dijera «IA conecta con Transformer», sería demasiado pobre. Lo importante es ver que este capítulo te prepara para distinguir mecanismos. Esa distinción reaparece en sistemas deterministas, neuronas, entrenamiento, RAG, agentes, evaluación y operación.

graph LR
    subgraph "Suelo del capítulo"
        HIST["Pregunta por la inteligencia\n(Turing y Dartmouth)"]
        SW["Software estadístico\nno conciencia"]
    end

    subgraph "Capítulo 1: qué aprendes aquí"
        IA["Inteligencia artificial"]
        NO["Qué no es:\noráculo, mente, buscador"]
        TOKEN["Predicción del\nsiguiente token"]
        DIST["Distribución de\nprobabilidad"]
        ERROR["Alucinación,\nsesgo y variabilidad"]
    end

    subgraph "Decisión de ingeniería"
        SQL["SQL o código exacto"]
        RAG["Buscador/RAG con fuentes"]
        TOOL["Herramienta/API con permisos"]
        REVIEW["Revisión humana trazable"]
    end

    subgraph "Dónde reaparece después"
        DET["Determinista vs probabilístico\n(cap. 2)"]
        NEURONA["Neurona y pesos\n(cap. 4)"]
        TRANS["Transformer\n(fasc. 3)"]
        EVAL["Evaluación y calibración\n(fasc. 7)"]
        AGENTES["Agentes y herramientas\n(fasc. 5)"]
    end

    HIST -->|"abre la pregunta de"| IA
    SW -->|"evita atribuir conciencia a"| IA
    IA -->|"se entiende mejor al negar"| NO
    IA -->|"genera mediante"| TOKEN
    TOKEN -->|"calcula"| DIST
    DIST -->|"introduce"| ERROR

    ERROR -->|"obliga a elegir"| SQL
    ERROR -->|"obliga a citar"| RAG
    ERROR -->|"obliga a separar accion de texto"| TOOL
    ERROR -->|"obliga a reservar decisiones"| REVIEW

    TOKEN -->|"se formaliza con"| DET
    TOKEN -->|"se implementa con"| NEURONA
    TOKEN -->|"se escala en"| TRANS
    ERROR -->|"se mide con"| EVAL
    TOOL -->|"se orquesta en"| AGENTES

    style HIST stroke-dasharray: 5 5
    style SW stroke-dasharray: 5 5
    style DET stroke-dasharray: 5 5
    style NEURONA stroke-dasharray: 5 5
    style TRANS stroke-dasharray: 5 5
    style EVAL stroke-dasharray: 5 5
    style AGENTES stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Inteligencia artificial	Rama de la informática que construye sistemas capaces de realizar tareas que normalmente requieren inteligencia humana, mediante modelos matemáticos que aprenden patrones a partir de datos.
LLM (Large Language Model)	Modelo de lenguaje de gran escala. Red neuronal con miles de millones de parámetros entrenada sobre cantidades masivas de texto para predecir y generar lenguaje.
Token	Unidad mínima de texto que el modelo procesa. Puede ser una palabra, parte de una palabra o un carácter. El modelo opera con tokens, no con palabras completas como las entendemos las personas.
Parámetro	Cada uno de los números que el modelo ajusta durante el entrenamiento. Un modelo de 175 000 millones de parámetros tiene 175 000 millones de números. Codifican patrones aprendidos, pero no son una base de datos consultable ni una memoria de hechos.
Alucinación	Fenómeno por el cual un LLM genera información sintácticamente correcta pero factualmente falsa, expresada con total seguridad. No es un bug: es una propiedad emergente de la predicción estadística.
RLHF (Reinforcement Learning from Human Feedback)	Técnica de post-entrenamiento donde personas evalúan respuestas del modelo y esa señal se usa para alinear su comportamiento con preferencias humanas.
Transformer	Arquitectura de red neuronal presentada en 2017 que sustituye el procesamiento secuencial por un mecanismo de atención paralela. Es la base de todos los LLMs modernos.
RAG (Retrieval-Augmented Generation)	Arquitectura que recupera documentos o datos externos antes de generar una respuesta, para que el modelo no dependa solo de sus patrones internos.
Sistema híbrido	Solución que combina varias piezas: consulta exacta, recuperación documental, generación, herramientas, permisos y revisión humana según el caso.

Antes de pasar página

¿Puedo explicar con mis propias palabras por qué un LLM no «piensa» ni «sabe» cosas como una persona? (Si no, vuelve a «Qué no es la inteligencia artificial».)
¿Entiendo el mecanismo de predicción del siguiente token? ¿Podría explicárselo a alguien sin conocimientos técnicos? (Si no, vuelve a «Cómo funciona por dentro».)
¿Puedo enumerar al menos tres cosas que la IA no es? (Si no, vuelve a «Qué no es la inteligencia artificial».)
¿Puedo enumerar al menos tres cosas que la IA sí es? (Si no, vuelve a «Qué sí es la inteligencia artificial».)
¿Conozco los hitos clave de la IA desde 1950 hasta hoy? (Si no, vuelve a la tabla en «Qué sí es la inteligencia artificial».)
¿Sé diferenciar entre elocuencia y corrección en una respuesta generada por IA? (Si no, vuelve a «Dónde solía tropezar yo», error «Confundir elocuencia con corrección».)
¿Podría decidir si un caso necesita SQL, RAG, LLM, herramienta/API, revisión humana o un sistema híbrido? (Si no, ejecuta el kit de «Manos a la obra».)

En resumen

Idea fuerza	Detalle
La IA no piensa, no entiende y no es consciente.	Es un sistema de predicción estadística de tokens entrenado sobre cantidades masivas de datos. Tratarla como un oráculo es el error más caro que puedes cometer al diseñar sistemas con IA.
El mecanismo fundamental es la predicción del siguiente token.	Dada una secuencia, el modelo calcula qué palabra es más probable a continuación. Repetido miles de veces, produce texto coherente. Es álgebra lineal, probabilidad y muestreo.
La IA es un amplificador, no un sustituto del criterio humano.	Multiplica la velocidad de quien ya sabe. A quien no sabe, le da una falsa sensación de competencia. Diseña siempre con verificación humana para decisiones de impacto.
La elocuencia no es corrección.	Un texto bien escrito y completamente falso es la alucinación por excelencia. Verifica siempre contra fuentes. La confianza con la que el modelo afirma algo no guarda relación con la veracidad de lo que afirma.

Para saber más

Anthropic. (2026). Agent SDK overview. https://code.claude.com/docs/en/agent-sdk/overview

Bender, E. M., Gebru, T., McMillan-Major, A. y Shmitchell, S. (2021). On the dangers of stochastic parrots: can language models be too big? En Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency (pp. 610-623). https://doi.org/10.1145/3442188.3445922

Brown, T. B. et al. (2020). Language models are few-shot learners. En Advances in Neural Information Processing Systems 33 (pp. 1877-1901). https://papers.nips.cc/paper/2020/hash/1457c0d6bfcb4967418bfb8ac142f64a-Abstract.html

Google. (2026). Agent Development Kit. https://adk.dev/

Krizhevsky, A., Sutskever, I. y Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. En Advances in Neural Information Processing Systems 25 (pp. 1097-1105). https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks

McCarthy, J., Minsky, M. L., Rochester, N. y Shannon, C. E. (1956). A proposal for the Dartmouth summer research project on artificial intelligence. http://jmc.stanford.edu/articles/dartmouth.html

Model Context Protocol. (2026). Specification. https://modelcontextprotocol.io/specification

OpenAI. (2026). Agents SDK. https://developers.openai.com/api/docs/guides/agents

OpenAI. (2023). GPT-4 technical report. https://arxiv.org/abs/2303.08774

Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Turing, A. M. (1950). Computing machinery and intelligence. Mind, 59(236), 433-460. https://doi.org/10.1093/mind/LIX.236.433

Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł. y Polosukhin, I. (2017). Attention is all you need. En Advances in Neural Information Processing Systems 30 (pp. 5998-6008). https://papers.nips.cc/paper/7181-attention-is-all-you-need

Wolfram, S. (2023). What Is ChatGPT doing... and why does it work? Stephen Wolfram Writings. https://writings.stephenwolfram.com/2023/02/what-is-chatgpt-doing-and-why-does-it-work/

Notas

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson. Los autores definen la IA como el estudio de agentes que reciben percepciones del entorno y ejecutan acciones, sin atribuir conciencia o intencionalidad al sistema. ↩
Bender, E. M., Gebru, T., McMillan-Major, A. y Shmitchell, S. (2021). On the dangers of stochastic parrots: can language models be too big? En Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency (pp. 610-623). https://doi.org/10.1145/3442188.3445922. Las autoras acuñaron el término «stochastic parrots» para describir el riesgo de atribuir comprensión a modelos que solo reproducen patrones estadísticos. ↩
OpenAI. (2026). Agents SDK. https://developers.openai.com/api/docs/guides/agents; Anthropic. (2026). Agent SDK overview. https://code.claude.com/docs/en/agent-sdk/overview; Google. (2026). Agent Development Kit. https://adk.dev/; Model Context Protocol. (2026). Specification. https://modelcontextprotocol.io/specification. Fuentes consultadas el 10 de junio de 2026. No se citan como verdad permanente del mercado, sino como fotografía técnica del momento. ↩
Turing, A. M. (1950). Computing machinery and intelligence. Mind, 59(236), 433-460. https://doi.org/10.1093/mind/LIX.236.433 ↩
McCarthy, J., Minsky, M. L., Rochester, N. y Shannon, C. E. (1956). A proposal for the Dartmouth summer research project on artificial intelligence. http://jmc.stanford.edu/articles/dartmouth.html ↩
Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0 ↩
Krizhevsky, A., Sutskever, I. y Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. En Advances in Neural Information Processing Systems 25 (pp. 1097-1105). https://papers.nips.cc/paper/4824 ↩
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł. y Polosukhin, I. (2017). Attention is all you need. En Advances in Neural Information Processing Systems 30 (pp. 5998-6008). https://papers.nips.cc/paper/7181-attention-is-all-you-need ↩
Brown, T. B. et al. (2020). Language models are few-shot learners. En Advances in Neural Information Processing Systems 33 (pp. 1877-1901). https://papers.nips.cc/paper/2020/hash/1457c0d6bfcb4967418bfb8ac142f64a-Abstract.html ↩
OpenAI. (2023). GPT-4 technical report. https://arxiv.org/abs/2303.08774 ↩

Capítulo 02

Facsímil 1 · Los cimientos

Capítulo 02: Sistemas deterministas frente a sistemas probabilísticos

Entrando en el tema

Acabas de integrar un LLM en tu aplicación. Has escrito un prompt cuidadoso, has probado varias veces y la respuesta es buena. Como buena ingeniera, escribes un test:

assert respuesta == "Rust es un lenguaje de programación de sistemas..."

El test pasa en tu máquina. Haces push. El CI lo ejecuta. Falla. Lo vuelves a ejecutar en local. Pasa. Lo ejecutas otra vez. Falla.

No es un bug. Es una colisión entre dos formas de pensar el software. Y este capítulo existe para que esa colisión no te pille por sorpresa.

Qué es un sistema determinista

Un sistema determinista cumple una propiedad sencilla: misma entrada, misma salida. Siempre.

Llevas décadas programando en este mundo sin saber que tenía nombre. Cada vez que escribes sumar(2, 3) y esperas 5, estás confiando en el determinismo. Cada compilador que traduce tu código a binario, cada consulta SQL que devuelve las mismas filas para la misma cláusula WHERE, cada función pura que no depende de nada externo.

El determinismo es el contrato silencioso de la ingeniería de software clásica: f(x) = y, y punto.¹ Si alguna vez rompe este contrato, lo llamamos bug y lo arreglamos.

function sumar(a, b) {
  return a + b;
}
// sumar(2, 3) = 5, siempre.
// sumar(2, 3) = 5, también mañana.
// sumar(2, 3) = 5, en cualquier servidor del mundo.

Este contrato es tan fundamental que nuestras herramientas —tests unitarios, debuggers, integración continua— están construidas sobre él. Un test que pasa y luego falla sin cambiar el código es, en el mundo determinista, una señal de alarma. Algo está roto.

Dónde aparece el no determinismo en IA

Aquí conviene ser muy precisos. No toda IA es no determinista. Un árbol de decisión entrenado, una regresión logística con pesos fijos o una red neuronal en modo inferencia pueden comportarse como funciones deterministas: misma entrada, mismos pesos, misma configuración, misma salida. Incluso dentro de un LLM, el forward pass que calcula los logits es una transformación matemática sobre números.

El no determinismo suele entrar después o alrededor del modelo: en el muestreo de tokens, en semillas aleatorias, en diferencias de precisión numérica, en batching, en kernels de GPU, en documentos recuperados que cambian o en herramientas externas que devuelven estados distintos. Por eso una integración real con IA no se prueba solo como una función pura. Se prueba como un sistema con capas.

En generación de texto, un LLM no devuelve «la respuesta correcta». Calcula una distribución de probabilidad sobre todos los tokens posibles y luego, según la configuración, puede muestrear de ella.

Esa palabra —muestrear— es la clave. No elige el token con mayor probabilidad (aunque puede configurarse para que lo haga). Elige un token al azar, pero con más probabilidad de elegir los que tienen puntuación alta. Es como lanzar un dado cargado: el 6 sale más a menudo, pero de vez en cuando sale un 3.

Por eso el mismo prompt puede producir respuestas distintas:

prompt: "Explica qué es Rust"

Ejecución 1: "Rust es un lenguaje de programación de sistemas..."
Ejecución 2: "Se trata de un lenguaje de programación enfocado en..."
Ejecución 3: "Rust, creado por Mozilla Research, es un lenguaje..."

Las tres son correctas. Las tres son razonables. Pero no son idénticas. Y si tu test espera una frase exacta, dos de cada tres ejecuciones fallarán sin que nada esté roto.

Cómo funciona por dentro

El viaje desde el prompt hasta el token generado tiene cinco estaciones:

Texto de entrada → Tokenización → Distribución de probabilidades → Muestreo → Token elegido

Estación 1: texto de entrada. Escribes tu prompt. Digamos: «Explica qué es Rust».

Estación 2: tokenización. El prompt se convierte en una secuencia de números. Este paso es determinista: el mismo texto siempre produce los mismos tokens. Lo vimos en el capítulo anterior y lo exploraremos en profundidad en el capítulo 9.

Estación 3: distribución de probabilidades. Los tokens atraviesan las capas del modelo. Al final, el modelo produce una lista de puntuaciones —llamadas logits— para cada token de su vocabulario. Esas puntuaciones se convierten en probabilidades mediante la función softmax.² El token con mayor probabilidad es el que el modelo asigna como continuación más probable, pero no es el único posible.

La idea se puede escribir así:

P(t_i \mid c) = \frac{e^{z_i / T}}{\sum_j e^{z_j / T}}

Símbolo	Significado	Ejemplo
$t_i$	Token candidato que podría venir después	`azul`
$c$	Contexto ya visto por el modelo	`El cielo es de color`
$z_i$	Logit: puntuación cruda asignada al token $t_i$	4,0 para `azul`
$T$	Temperatura usada antes de convertir logits en probabilidades	1,0
$\sum_j$	Suma sobre todos los tokens candidatos del vocabulario	`azul`, `gris`, `rojo`, ...
$P(t_i \mid c)$	Probabilidad de elegir $t_i$ dado el contexto	0,84 para `azul`

Con tres tokens candidatos y logits sencillos, la temperatura cambia la forma de la distribución:

Token	Logit	Probabilidad con $T=0{,}5$	Probabilidad con $T=1$	Probabilidad con $T=2$
`azul`	4,0	0,98	0,84	0,63
`gris`	2,0	0,018	0,11	0,23
`rojo`	1,0	0,002	0,04	0,14

No memorices los números. Quédate con el mecanismo: al bajar la temperatura, la distribución se concentra en el candidato más probable; al subirla, se reparte más probabilidad entre alternativas. Esto no convierte al modelo en «más inteligente» o «menos inteligente». Cambia la política de muestreo.

Estación 4: muestreo. Aquí puede entrar el no determinismo. Tres parámetros controlan cuánta aleatoriedad se introduce:

temperature: controla lo plano o picuda que es la distribución. Con temperatura baja (cercana a 0), el modelo casi siempre elige el token más probable. Con temperatura alta (cercana a 2), incluso tokens con probabilidad baja tienen opciones.³ Lo veremos en detalle en el capítulo sobre parámetros de configuración.
top-p: en lugar de considerar todos los tokens, el modelo solo considera los más probables hasta que sus probabilidades suman p. Si top-p = 0.9, el modelo elige entre el conjunto mínimo de tokens que suman el 90 % de la probabilidad total.
top-k: el modelo solo considera los k tokens más probables y descarta el resto.

Con temperature = 0, el modelo se acerca al determinismo: casi siempre elige el token más probable. Pero no lo garantiza del todo: pequeñas diferencias en precisión numérica, batching o hardware pueden producir variaciones.

Estación 5: token elegido. El modelo devuelve un token. Ese token se añade a la secuencia de entrada y el ciclo se repite hasta generar un token de fin.

flowchart LR
    A["Texto de entrada"] --> B["Tokenización"]
    B --> C["Distribución de\nprobabilidades"]
    C --> D["Muestreo\n(temp, top-p, top-k)"]
    D --> E["Token elegido"]
    E -.->|"se añade a la entrada"| A

En el día a día

La variabilidad de los LLM en productos reales tiene consecuencias prácticas inmediatas. Veamos tres.

Escribir tests para código que usa LLMs. No puedes hacer assert respuesta == "texto exacto". En su lugar, validas propiedades: ¿la respuesta contiene los tres puntos clave que pediste?, ¿tiene la estructura esperada (JSON, Markdown, lista)?, ¿menciona los conceptos correctos?, ¿está en el idioma solicitado?⁴ Es un cambio de mentalidad: de validar igualdad exacta a validar propiedades semánticas.

Depurar comportamientos inconsistentes. Un usuario reporta que el asistente «a veces responde mal». En un sistema determinista, reproducirías la entrada y obtendrías el mismo error. Con un LLM, necesitas ejecutar varias veces, observar patrones y usar evaluaciones automáticas que midan la tasa de error en lugar de comprobar ejecuciones individuales.

Diseñar experiencias de usuario. Si tu producto muestra respuestas generadas por IA, el usuario esperará que la misma pregunta reciba una respuesta consistente. Si cada vez que pregunta «¿cuál es mi saldo?» obtiene una redacción distinta, puede percibirlo como un error. La solución no es forzar el determinismo: es diseñar la experiencia para que la variabilidad sea una ventaja (creatividad, adaptación al contexto) y no una fuente de confusión.

Por qué debería importarte

El paso más importante que darás al trabajar con IA no es técnico: es mental.

Llevas años —décadas, probablemente— entrenando tu cerebro para pensar en sistemas deterministas. Un bug es una desviación del comportamiento esperado. Un test que falla es una alarma. La reproducibilidad es sagrada.

Trabajar con IA exige un modelo mental distinto. No preguntas «¿esto devuelve X?», sino «¿esto devuelve algo razonable dentro de un rango?». No validas igualdad, validas propiedades. No depuras ejecuciones individuales, observas distribuciones de resultados.

Este cambio de mentalidad no es opcional. Si diseñas sistemas con IA generativa como si siempre fueran funciones puras de texto a texto, construirás sistemas frágiles que fallarán en producción por razones que tus tests no pueden detectar.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Testear texto exacto	Escribir `assert respuesta == "Rust es un lenguaje..."` condena tu test a fallar aleatoriamente. La misma pregunta puede recibir respuestas correctas pero textualmente distintas.	Valida propiedades: ¿contiene las palabras clave?, ¿respeta el formato pedido?, ¿tiene una longitud razonable?
Decir “la IA no es determinista” sin matices	Mezcla cosas distintas: modelo, muestreo, runtime, proveedor, RAG y herramientas. Una parte del sistema puede ser determinista y otra no.	Dibuja la frontera: qué pieza es función pura, qué pieza muestrea, qué pieza consulta estado externo y qué pieza depende de infraestructura.
Confiar en que `temperature=0` es totalmente determinista	Incluso con temperatura cero, pequeñas diferencias en precisión numérica, batching o hardware pueden producir variaciones. No es un interruptor de determinismo: es un atenuador de variabilidad.	Si necesitas determinismo absoluto, usa modelos clásicos. Si usas un LLM, diseña para tolerar variabilidad.
*Depurar como si fuera un bug* determinista**	Ante una respuesta incorrecta de un LLM, repetir el mismo prompt para «reproducir el error» puede no funcionar. El error puede ser estadístico, no sistemático.	Ejecuta múltiples veces, mide la tasa de error y busca patrones. Usa evaluaciones automáticas.
Ignorar los parámetros de muestreo	Usar los valores por defecto sin entender qué hace cada uno. Una temperatura alta en un contexto donde necesitas respuestas consistentes genera frustración en el usuario.	Ajusta `temperature`, `top-p` y `top-k` según el caso de uso. Creatividad alta para brainstorming, baja para respuestas factuales.

Manos a la obra

Este capítulo sí puede practicarse sin llamar a ningún modelo real. He dejado un kit en kit descargable que simula un modelo pequeño: varias respuestas candidatas, un logit por respuesta, distintas temperaturas y una evaluación que compara dos estrategias de testing.

La primera estrategia es la que traemos del mundo determinista: assert salida == texto_esperado. La segunda es la que necesitamos para sistemas probabilísticos: comprobar propiedades, medir tasas de paso y decidir si el comportamiento queda dentro de un contrato aceptable.

Qué creas.

output/stochastic_eval_report.json: resultados por caso y temperatura.
output/stochastic_eval_decision.md: lectura técnica de cuándo falla el assert exacto y cuándo pasa la evaluación por propiedades.
Makefile: atajos para ejecutar, probar y limpiar la práctica.
tests/test_stochastic_eval.py: pruebas que fijan el comportamiento esperado de softmax, temperatura cero, evaluación por propiedades y gate.
requirements.txt: declaración explícita de que el kit no necesita dependencias externas.

Cómo lo ejecutas.

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/run_stochastic_eval.py --write
cat output/stochastic_eval_decision.md

Para tratarlo como práctica reproducible:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

Qué deberías ver. En una tarea factual como explicar Rust, la tasa de coincidencia exacta baja cuando hay varias respuestas válidas, aunque muchas cumplan las propiedades importantes. En una salida estructurada tipo JSON, verás otro problema: dos respuestas pueden tener la misma información en distinto orden. Si tu test exige texto idéntico, falla; si valida campos obligatorios, pasa. Los tests comprueban además que la temperatura cero se comporta como argmax en este simulador, que las probabilidades suman 1 y que una temperatura alta puede bloquear una salida estructurada cuando rompe el contrato.

Cómo lo adaptas a tu caso. Cambia data/sampling_cases.json por una tarea propia: una respuesta de soporte, un resumen técnico o una salida JSON. Ajusta contracts/eval_policy.json para modificar número de ejecuciones, temperaturas, tasa mínima de paso o número máximo de salidas distintas.

Qué entregaría un alumno. Un buen entregable incluye el Markdown generado, un caso nuevo, una política modificada, el resultado de make test y una explicación breve de por qué la igualdad exacta no representa bien la calidad del sistema.

Cómo encaja todo

Este mapa se lee de arriba abajo. El capítulo hereda del capítulo 1 la idea de predicción del siguiente token. Aquí la vuelve operativa: si hay distribución y muestreo, ya no puedes probar, depurar ni diseñar experiencia de usuario como si todo fuera una función pura.

La decisión central del capítulo es cambiar de mentalidad: de salida única a contrato probabilístico. Esa decisión reaparece después en parámetros de inferencia, evaluación, operación, RAG y agentes, porque todos esos sistemas necesitan medir comportamiento en muchas ejecuciones, no en una sola respuesta bonita.

graph TD
    subgraph "Viene del capítulo anterior"
        IA["IA como sistema estadístico\n(cap. 1)"]
        TOKEN["Predicción del siguiente token\n(cap. 1)"]
    end

    subgraph "Capítulo 2: decisión que aprendes"
        DET["Sistema determinista"]
        PROB["Sistema probabilístico"]
        LOGITS["Logits"]
        SOFTMAX["Softmax + temperatura"]
        SAMPLE["Muestreo"]
        TESTS["Evaluación por propiedades"]
    end

    subgraph "Se reutiliza después"
        NEURONA["Pesos y activaciones\n(cap. 4)"]
        TRAIN["Entrenamiento e inferencia\n(cap. 10)"]
        EVALS["Evals y calibración\n(fasc. 7)"]
        OPS["Operación, gates y drift\n(fasc. 6)"]
        AGENTS["Agentes con tools\n(fasc. 5)"]
    end

    IA -->|"se diferencia de"| DET
    IA -->|"se comporta a menudo como"| PROB
    TOKEN -->|"produce"| LOGITS
    LOGITS -->|"se convierten mediante"| SOFTMAX
    SOFTMAX -->|"define una distribución para"| SAMPLE
    SAMPLE -->|"impide depender de"| DET
    PROB -->|"exige"| TESTS

    LOGITS -->|"nacen de"| NEURONA
    SOFTMAX -->|"se configura durante"| TRAIN
    TESTS -->|"se formaliza en"| EVALS
    TESTS -->|"bloquea o permite"| OPS
    SAMPLE -->|"afecta a trayectorias de"| AGENTS

    style IA stroke-dasharray: 5 5
    style TOKEN stroke-dasharray: 5 5
    style NEURONA stroke-dasharray: 5 5
    style TRAIN stroke-dasharray: 5 5
    style EVALS stroke-dasharray: 5 5
    style OPS stroke-dasharray: 5 5
    style AGENTS stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Sistema determinista	Sistema donde la misma entrada produce siempre la misma salida. Un compilador, una consulta SQL o una función pura son ejemplos.
Sistema estocástico	Sistema donde la misma entrada puede producir salidas diferentes porque incorpora elementos de probabilidad o muestreo.
Muestreo	Proceso de elegir un valor concreto a partir de una distribución de probabilidad. En un LLM, se muestrea cuál será el siguiente token.
Temperatura	Parámetro que controla cuánta aleatoriedad se introduce al muestrear. Valores bajos producen respuestas más predecibles; valores altos, más creativas.
*Logit*	Puntuación cruda que asigna el modelo a cada token antes de convertirse en probabilidad.
Softmax	Función que convierte puntuaciones crudas en probabilidades que suman 1.
Distribución de probabilidad	Asignación de una probabilidad a cada resultado posible. En un LLM, a cada token del vocabulario.
Evaluación probabilística	Forma de probar sistemas variables midiendo propiedades, tasas de paso y distribuciones, no igualdad exacta de texto.

Antes de pasar página

¿Puedo explicar con mis propias palabras la diferencia entre un sistema determinista y uno estocástico? (Si no, vuelve a «Qué es un sistema determinista» y «Dónde aparece el no determinismo en IA».)
¿Entiendo por qué un LLM puede dar respuestas distintas al mismo prompt? (Si no, vuelve a «Cómo funciona por dentro».)
¿Sé qué hace el parámetro temperature? (Si no, vuelve a la estación 4 en «Cómo funciona por dentro».)
¿Puedo nombrar al menos dos estrategias para testear sistemas que usan LLMs? (Si no, vuelve a «En el día a día».)
¿Entiendo por qué temperature = 0 no garantiza determinismo absoluto? (Si no, vuelve a «Dónde solía tropezar yo», error «Confiar en que temperature = 0 es totalmente determinista».)
¿He ejecutado el kit de kit descargable y puedo explicar la diferencia entre exact_pass_rate y property_pass_rate? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
En IA generativa, la variabilidad suele aparecer en el muestreo y en el sistema que rodea al modelo.	El mismo prompt puede producir respuestas distintas porque el modelo puede muestrear de una distribución de probabilidad, porque el runtime no siempre es idéntico o porque el contexto externo cambia.
Programar con IA exige un cambio de mentalidad.	Pasas de validar igualdad exacta a validar propiedades. De preguntar «¿esto devuelve X?» a preguntar «¿esto devuelve algo razonable?».
Los parámetros de muestreo controlan la aleatoriedad, no la eliminan.	`temperature`, `top-p` y `top-k` ajustan cuánta variabilidad hay, pero ni siquiera `temperature = 0` garantiza determinismo absoluto.
Testear sistemas con IA requiere herramientas distintas.	No tests de igualdad textual. Sí evaluaciones automáticas, validación de estructura, asserts sobre propiedades semánticas.

Para saber más

Anthropic. (2025). Develop tests for LLM applications. https://platform.claude.com/docs/en/build-with-claude/develop-tests

Bishop, C. M. (2006). Pattern recognition and machine learning. Springer.

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

Holtzman, A., Buys, J., Du, L., Forbes, M. y Choi, Y. (2020). The curious case of neural text degeneration. En International Conference on Learning Representations. https://openreview.net/forum?id=rygGQyrFvH

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Shannon, C. E. (1948). A mathematical theory of communication. The Bell System Technical Journal, 27(3), 379-423. https://doi.org/10.1002/j.1538-7305.1948.tb01338.x

Notas

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson. Los autores dedican el capítulo 2 al concepto de agente racional, estableciendo la diferencia entre entornos deterministas (el siguiente estado está completamente determinado por el estado actual y la acción) y entornos estocásticos. ↩
Bishop, C. M. (2006). Pattern recognition and machine learning. Springer. El capítulo 4 aborda los modelos lineales para clasificación y la transformación de puntuaciones en probabilidades mediante la función softmax. ↩
Holtzman, A., Buys, J., Du, L., Forbes, M. y Choi, Y. (2020). The curious case of neural text degeneration. En International Conference on Learning Representations. https://openreview.net/forum?id=rygGQyrFvH. Este artículo introdujo el muestreo top-p (nucleus sampling) y analiza en profundidad por qué los métodos de muestreo ingenuos producen texto degenerado. ↩
Anthropic. (2025). Develop tests for LLM applications. https://platform.claude.com/docs/en/build-with-claude/develop-tests ↩

Capítulo 03

Facsímil 1 · Los cimientos

Capítulo 03: Principios fundamentales de la inteligencia artificial

Entrando en el tema

Has oído las palabras. Aprendizaje supervisado. Transformers. RLHF. Scaling laws. Suenan a conceptos avanzados que solo entiende quien tiene un doctorado. Pero no lo son. Son cinco ideas, sorprendentemente accesibles, que explican por qué la IA moderna funciona como funciona.

Este capítulo no te va a convertir en experto en ninguna de ellas. Para eso están el resto de capítulos del libro. Pero sí te va a dar el mapa. Cuando termines, sabrás nombrar las cinco patas de la mesa y, sobre todo, sabrás qué pata buscar cuando algo falle.

Aprendizaje supervisado: aprender con ejemplos

Imagina que quieres enseñarle a alguien a distinguir facturas falsas de facturas verdaderas. Le enseñas cien facturas. Cada una lleva una etiqueta: «verdadera» o «falsa». La persona observa, compara, detecta patrones —el logotipo borroso, el NIF que no cuadra, el formato de fecha extraño— y, tras revisar suficientes ejemplos, es capaz de clasificar facturas nuevas que no había visto antes.

Eso es el aprendizaje supervisado.

En términos técnicos: le das al modelo un conjunto de ejemplos etiquetados —cada entrada con su salida esperada— y el modelo ajusta sus parámetros para minimizar el error entre lo que predice y la etiqueta real.¹ Es la base del fine-tuning: coges un modelo pre-entrenado y lo ajustas con ejemplos específicos de tu dominio. El modelo ya sabe lenguaje; tú le enseñas tu jerga.

El aprendizaje supervisado es el paradigma más intuitivo porque se parece a como aprendemos muchas cosas: practicando con ejemplos cuya respuesta correcta conocemos.

Aprendizaje no supervisado: encontrar patrones sin pistas

Ahora imagina que tienes un montón de facturas sin etiquetar. No sabes cuáles son verdaderas ni falsas. Pero aun así, al observarlas, detectas que algunas se parecen mucho entre sí —mismo formato, mismos proveedores, mismos importes redondos— y otras son completamente distintas. Sin que nadie te haya dicho qué es cada cosa, has encontrado estructura.

Eso es el aprendizaje no supervisado.

El modelo recibe datos sin etiquetar y busca patrones, agrupaciones o representaciones. No hay una «respuesta correcta» contra la que comparar. El modelo descubre la estructura por sí mismo.

Este paradigma es el responsable silencioso del éxito de los LLMs. Cuando un modelo como GPT se pre-entrena sobre miles de millones de documentos de internet, no hay un humano etiquetando cada frase. El modelo se entrena con una tarea auto-supervisada: predecir la siguiente palabra.² Es una forma de aprendizaje no supervisado: los propios datos proporcionan la señal de aprendizaje.

Post-training: enseñar preferencias, no solo hechos

Un modelo pre-entrenado sabe completar frases. Pero no sabe que es mejor decir «no tengo esa información» que inventársela. No sabe que ciertos temas requieren un tono más cuidadoso. No sabe cuándo callar.

El post-training resuelve esto. Tras el pre-entrenamiento masivo (aprendizaje no supervisado), se aplican técnicas que enseñan al modelo preferencias:

SFT (Supervised Fine-Tuning): se entrena al modelo con ejemplos de conversaciones de alta calidad escritas por personas. El modelo aprende el formato y el tono deseados.
RLHF (Reinforcement Learning from Human Feedback): personas comparan pares de respuestas del modelo y eligen cuál es mejor. Esa señal de preferencia entrena un modelo de recompensa que guía al modelo principal. Es aprendizaje por refuerzo, pero la recompensa la define un humano, no el entorno.³
DPO (Direct Preference Optimization): una alternativa a RLHF que aprende directamente de las preferencias humanas sin necesidad de entrenar un modelo de recompensa separado.⁴

El post-training es la capa que convierte un modelo que «sabe cosas» en un modelo con el que puedes hablar. Lo exploraremos en detalle en el facsímil 4.

Atención: mirar todo a la vez

Piensa en cómo lees esta frase: «El gato que perseguía al ratón que robó el queso que estaba en la cocina es negro». Para saber que «negro» se refiere a «gato», tu cerebro ha tenido que conectar dos palabras separadas por una larga cláusula subordinada. Ha tenido que prestar atención a la relación entre «gato» y «negro» ignorando temporalmente el ratón, el queso y la cocina.

Los modelos anteriores a 2017 no podían hacer esto eficientemente. Procesaban el texto palabra por palabra, en orden, y para cuando llegaban a «negro» ya se habían olvidado de «gato».

El mecanismo de atención, presentado en el artículo «Attention Is All You Need»,⁵ cambió esto radicalmente. Permite al modelo mirar todas las palabras de la entrada simultáneamente y decidir, para cada palabra que va a generar, cuáles de las palabras de entrada son relevantes y en qué medida.

Es el mecanismo que hizo posibles los LLMs modernos. Sin atención, los modelos no podrían manejar contextos largos ni capturar dependencias entre palabras separadas por decenas de miles de tokens. El facsímil 3 está dedicado íntegramente a abrir esta caja negra y entenderla por dentro.

Scaling laws: escala, coste y límites

En 2020, un grupo de investigadores de OpenAI se preguntó algo aparentemente simple: ¿qué pasa si entrenamos modelos cada vez más grandes con más datos y más computación? La respuesta, publicada en el artículo «Scaling Laws for Neural Language Models»,⁶ fue sorprendentemente ordenada: el rendimiento mejora de forma predecible con la escala.

La relación simplificada es: más datos + más parámetros + más computación = modelo más capaz. Pero escrita así puede engañar. No significa que cualquier modelo grande sea mejor en cualquier tarea, ni que puedas ignorar la calidad de los datos, la arquitectura, el entrenamiento o la evaluación. Significa que, bajo ciertas condiciones experimentales, la pérdida baja siguiendo una relación bastante regular cuando aumentan parámetros, datos y cómputo.

Ejemplo de fórmula. Una forma simplificada de leer una ley de escala es esta:

L(N, D) \approx L_\infty + \frac{A}{N^\alpha} + \frac{B}{D^\beta}

Símbolo	Significado	Ejemplo
$L(N, D)$	Pérdida esperada del modelo entrenado con $N$ parámetros y $D$ tokens	1,72
$L_\infty$	Límite inferior aproximado: pérdida que no desaparece aunque escales	1,55
$N$	Número de parámetros del modelo	7B, 70B, 405B
$D$	Cantidad de datos de entrenamiento, normalmente tokens	1T tokens
$A, B$	Constantes ajustadas empíricamente	dependen del experimento
$\alpha, \beta$	Exponentes que dicen cuánto ayuda escalar parámetros o datos	valores pequeños, no milagrosos

Esta fórmula es una forma pedagógica de leer la idea, no una receta para presupuestar tu modelo ni una garantía de rendimiento. Las constantes y exponentes se estiman empíricamente en un experimento concreto; cambian con arquitectura, datos, régimen de entrenamiento y métrica. La intuición importante es que hay rendimientos decrecientes. Añadir diez veces más parámetros no suele darte diez veces más calidad. Además, Hoffmann y coautores mostraron con Chinchilla que muchos modelos grandes estaban infraentrenados: para un presupuesto de cómputo fijo, no basta con aumentar parámetros; también hay que aumentar datos de entrenamiento en proporción razonable.⁷

Esto explica por qué la industria invierte miles de millones en clústeres de GPUs, pero también explica por qué un equipo serio no compra «el modelo más grande» sin medir. Las scaling laws sirven para razonar sobre tendencias de entrenamiento; tu decisión de producto se toma con evals, latencia, coste por token, privacidad, facilidad de operación y calidad en tu tarea.

La lectura menos optimista es clara: mejorar el rendimiento requiere inversiones crecientes. Pasar de un modelo bueno a uno excelente cuesta mucho más que pasar de uno malo a uno aceptable. Entender esta dinámica es clave para tomar decisiones realistas sobre qué modelos usar y cuándo.

En el día a día

Cada uno de estos principios se traduce en decisiones de ingeniería.

Si tu problema tiene datos etiquetados, el aprendizaje supervisado —posiblemente mediante fine-tuning— es tu primer candidato. Clasificar tickets de soporte, detectar fraude, predecir abandono de clientes: todo esto es supervisado.

Si solo tienes datos sin etiquetar y necesitas encontrar estructura —agrupar clientes, detectar anomalías, reducir dimensiones—, el aprendizaje no supervisado es la herramienta. Pero cuidado: que el modelo encuentre grupos no significa que esos grupos signifiquen algo útil para tu negocio. Lo veremos en el capítulo sobre clustering.

Si estás integrando un LLM en un producto, primero separa qué problema tienes. Si falta conocimiento que cambia —políticas internas, catálogo, normativa, documentación— normalmente necesitas recuperación de información, no tocar pesos. Si falta formato, tono, criterios de abstención o una conducta repetida y medible, entonces puede tener sentido post-training, fine-tuning o adaptadores. No basta con un buen prompt, pero tampoco se responde a todo con fine-tuning: necesitas saber qué pieza del sistema está fallando.

Si necesitas que el modelo maneje contexto largo, la atención es tu aliada y tu enemiga. Permite procesar documentos extensos, pero su coste computacional crece cuadráticamente con la longitud de la secuencia. Cada vez que duplicas el contexto, el coste se multiplica por cuatro. Diseñar estrategias de ventana de contexto —cuánto texto incluir, cuánto resumir, cuánto recuperar— es una decisión de arquitectura que depende de entender cómo funciona la atención.

Si estás decidiendo qué modelo usar, las scaling laws te dicen que más grande no siempre es mejor para ti. Un modelo de 7 000 millones de parámetros puede ser suficiente para tu caso de uso, y uno de 70 000 millones puede ser excesivamente caro y lento sin aportar una mejora proporcional. La decisión correcta depende de tus requisitos de calidad, latencia y coste.

Por qué debería importarte

Estos cinco principios no son trivia académica. Son el vocabulario con el que se toman todas las decisiones técnicas en IA.

Cuando alguien te diga «vamos a hacer fine-tuning», necesitas saber que está hablando de aprendizaje supervisado sobre un modelo pre-entrenado. Cuando escuches «este modelo tiene mejor atención», necesitas entender qué significa eso para tu caso de uso. Cuando un proveedor te diga «nuestro modelo es más grande, por tanto mejor», las scaling laws te dan el marco para evaluar si ese «mejor» justifica el coste.

Cada capítulo a partir de ahora asume que conoces este mapa. La neurona artificial es la pieza mínima del aprendizaje supervisado. La retropropagación es cómo se ajustan los parámetros. El Transformer es la atención llevada a la práctica. El fine-tuning es aprendizaje supervisado aplicado. Todo encaja.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Creer que el aprendizaje no supervisado no necesita validación	Que un modelo encuentre patrones no significa que esos patrones sean útiles, reales o accionables. Un cluster puede ser un artefacto estadístico sin significado de negocio.	Valida siempre los resultados no supervisados contra conocimiento del dominio. Un grupo de clientes debe tener sentido para el equipo de negocio, no solo para el algoritmo.
Asumir que más parámetros siempre es mejor	Un modelo más grande es más caro, más lento y no necesariamente mejor para tu caso de uso concreto. Las scaling laws predicen rendimiento agregado, no rendimiento en tu tarea específica.	Evalúa el modelo en tus datos y tu tarea. No delegues la decisión en el número de parámetros.
Responder “fine-tuning” antes de diagnosticar	Un dominio especializado puede fallar por muchas razones: falta contexto, datos obsoletos, formato de salida inestable, vocabulario técnico, criterios de abstención o evaluación pobre. Ajustar pesos no arregla documentos desactualizados ni permisos mal diseñados.	Decide por causa: RAG para conocimiento vivo, reglas o herramientas para acciones verificables, fine-tuning o LoRA para comportamiento repetido y estable, y evaluación antes de cambiar nada.
Ignorar el coste cuadrático de la atención	Duplicar la longitud del contexto multiplica por cuatro el coste computacional. Diseñar sin tener esto en cuenta lleva a sistemas lentos y caros en producción.	Mide el coste real con tu volumen de datos y tu latencia objetivo. Considera estrategias de ventana deslizante, resumen previo o recuperación selectiva.

Manos a la obra

Este capítulo es un mapa, sí, pero un mapa también se puede usar. He dejado un kit ejecutable en kit descargable para convertir los cinco principios en una matriz de decisión técnica.

El ejercicio parte de cinco casos realistas: clasificar tickets con datos etiquetados, descubrir segmentos sin etiquetas, construir un asistente que debe abstenerse, resumir contratos largos y elegir un modelo local con baja latencia. El script decide qué principio domina cada caso —supervisado, no supervisado, post-training, atención/contexto o scaling/coste— y qué artefactos mínimos habría que producir antes de construir.

Qué creas.

output/principle_report.json: matriz estructurada con principio dominante, principios secundarios, riesgos y entregables.
output/principle_decision.md: decisión legible que podrías defender en una práctica o en una reunión técnica.
Makefile: atajos para ejecutar, probar y limpiar la práctica.
tests/test_principle_router.py: prueba ejecutable de que el router genera una decisión completa.
requirements.txt: deja claro que no hay dependencias externas.

Cómo lo ejecutas.

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/route_ai_principles.py --write
cat output/principle_decision.md

Como mini proyecto reproducible:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

Qué deberías ver. Clasificar tickets se apoya en aprendizaje supervisado porque hay etiquetas y métrica. Descubrir segmentos se apoya en no supervisado, pero exige validación de dominio. El asistente de becas mezcla post-training, atención/contexto y revisión porque debe saber abstenerse. Los contratos largos fuerzan presupuesto de contexto. El modelo local obliga a mirar coste, latencia y calidad, no solo tamaño.

Cómo lo adaptas a tu caso. Añade dos casos propios a data/project_cases.json: uno donde creas que basta un modelo pequeño y otro donde sospeches que hace falta post-training o RAG. Cambia contracts/principle_policy.json para modificar el umbral de ejemplos etiquetados, el límite de contexto largo o la latencia objetivo.

Qué entregaría un alumno. El Markdown generado, dos casos propios, una explicación de por qué el principio dominante no basta por sí solo, un cambio de política que altere al menos una decisión y el resultado de make test.

Cómo encaja todo

Este mapa se lee de izquierda a derecha. Hereda de los dos capítulos anteriores dos ideas: la IA no es una mente y sus salidas son probabilísticas. El capítulo 3 añade el primer vocabulario de diseño: qué tipo de aprendizaje o arquitectura estás invocando cuando dices «vamos a usar IA».

La decisión que enseña es práctica: no todos los problemas piden el mismo principio. Un caso con etiquetas pide supervisado; uno sin etiquetas pide exploración; uno con preferencias pide post-training; uno con contexto largo pide entender atención; uno limitado por coste pide mirar escala y evals. Ese mapa reaparece en casi todo lo que viene después.

graph LR
    subgraph "Viene de los capítulos 1 y 2"
        IA["IA no es oráculo\n(cap. 1)"]
        ESTOC["Salida probabilística\n(cap. 2)"]
    end

    subgraph "Capítulo 3: principios para decidir"
        SUP["Supervisado\nsi hay etiquetas"]
        NOSUP["No supervisado\nsi buscas estructura"]
        POST["Post-training\nsi necesitas preferencias"]
        ATENCION["Atención\nsi importa el contexto"]
        SCALING["Scaling laws\nsi decides coste/calidad"]
    end

    subgraph "Artefactos que deberías pedir"
        DATASET["Dataset etiquetado\ny métrica"]
        CLUSTERS["Perfilado de grupos\ny validación de dominio"]
        PREFS["Pares de preferencia\ny política de rechazo"]
        CONTEXT["Presupuesto de contexto\ny recuperación"]
        EVALS["Curva coste/calidad/latencia"]
    end

    subgraph "Dónde se profundiza después"
        NEURONA["Neurona y gradiente\n(cap. 4-6)"]
        TRANSFORMER["Transformer\n(fasc. 3)"]
        TOOLBOX["RAG y modelos\n(fasc. 4)"]
        EVALF["Evaluación\n(fasc. 7)"]
        REFUERZO["Preferencias y recompensa\n(fasc. 10)"]
    end

    IA -->|"obliga a elegir mecanismo"| SUP
    IA -->|"también permite"| NOSUP
    ESTOC -->|"hace necesaria"| POST
    ESTOC -->|"se mide con"| EVALS

    SUP -->|"pide"| DATASET
    NOSUP -->|"pide"| CLUSTERS
    POST -->|"pide"| PREFS
    ATENCION -->|"pide"| CONTEXT
    SCALING -->|"pide"| EVALS

    DATASET -->|"se entrena con"| NEURONA
    CONTEXT -->|"se implementa en"| TRANSFORMER
    CONTEXT -->|"se combina con"| TOOLBOX
    EVALS -->|"se formaliza en"| EVALF
    PREFS -->|"se conecta con"| REFUERZO

    style IA stroke-dasharray: 5 5
    style ESTOC stroke-dasharray: 5 5
    style NEURONA stroke-dasharray: 5 5
    style TRANSFORMER stroke-dasharray: 5 5
    style TOOLBOX stroke-dasharray: 5 5
    style EVALF stroke-dasharray: 5 5
    style REFUERZO stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Aprendizaje supervisado	Paradigma donde el modelo aprende a partir de ejemplos etiquetados con la respuesta correcta, ajustando sus parámetros para minimizar el error de predicción.
Aprendizaje no supervisado	Paradigma donde el modelo encuentra patrones en datos sin etiquetar, sin una respuesta correcta predefinida contra la que comparar.
Pre-entrenamiento	Fase inicial masiva de entrenamiento no supervisado donde el modelo aprende patrones generales del lenguaje a partir de cantidades inmensas de texto.
RLHF	Técnica de post-entrenamiento donde la señal de aprendizaje proviene de personas que comparan y puntúan respuestas del modelo.
DPO	Técnica de optimización por preferencias que aprende de pares de respuestas elegidas y rechazadas sin entrenar un modelo de recompensa separado.
*Fine-tuning*	Proceso de tomar un modelo pre-entrenado y ajustarlo con ejemplos etiquetados de un dominio específico. Es aprendizaje supervisado sobre una base pre-entrenada.
Atención	Mecanismo que permite al modelo evaluar la relevancia de cada palabra de entrada para cada palabra de salida, procesando todas las relaciones simultáneamente.
*Scaling law*	Relación predecible entre los recursos invertidos en entrenamiento y el rendimiento del modelo.

Antes de pasar página

¿Puedo explicar la diferencia entre aprendizaje supervisado y no supervisado con un ejemplo concreto? (Si no, vuelve a las dos primeras secciones.)
¿Entiendo qué aporta el post-training que no aporta el pre-entrenamiento? (Si no, vuelve a «Post-training: enseñar preferencias».)
¿Sé qué hace el mecanismo de atención y por qué fue revolucionario? (Si no, vuelve a «Atención: mirar todo a la vez».)
¿Puedo explicar por qué las scaling laws son importantes para decidir qué modelo usar? (Si no, vuelve a «Scaling laws» y a «En el día a día».)
¿Entiendo por qué más parámetros no siempre es la respuesta correcta? (Si no, vuelve a «Dónde solía tropezar yo», error «Asumir que más parámetros siempre es mejor».)
¿He ejecutado kit descargable y puedo justificar qué principio domina un caso propio? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
La IA moderna se apoya en cinco principios.	Aprendizaje supervisado, no supervisado, post-training, atención y scaling laws. Entenderlos es tener el mapa antes de adentrarse en el territorio.
El aprendizaje supervisado entrena con ejemplos etiquetados; el no supervisado encuentra patrones sin etiquetas.	El primero es la base del fine-tuning; el segundo, del pre-entrenamiento de los LLMs.
El mecanismo de atención permite procesar todas las palabras a la vez.	Es la innovación arquitectónica que hizo posibles los modelos de lenguaje modernos. Sin ella, no hay Transformer.
Las scaling laws demuestran que el rendimiento mejora de forma predecible con la escala.	Pero también advierten de que la mejora tiene un coste creciente. Más grande no siempre es la respuesta correcta para tu caso.

Para saber más

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

Hoffmann, J. et al. (2022). Training compute-optimal large language models. arXiv:2203.15556. https://doi.org/10.48550/arXiv.2203.15556

Kaplan, J. et al. (2020). Scaling laws for neural language models. arXiv:2001.08361. https://doi.org/10.48550/arXiv.2001.08361

Ouyang, L. et al. (2022). Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems 35, 27730-27744. https://papers.nips.cc/paper_files/paper/2022/hash/b1efde53be364a73914f58805a001731-Abstract-Conference.html

Rafailov, R., Sharma, A., Mitchell, E., Ermon, S., Manning, C. D. y Finn, C. (2023). Direct preference optimization: Your language model is secretly a reward model. Advances in Neural Information Processing Systems 36. https://arxiv.org/abs/2305.18290

Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Notas

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson. Los capítulos 18 a 21 cubren en profundidad los paradigmas de aprendizaje supervisado, no supervisado y por refuerzo. ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 14 aborda los autoencoders y las representaciones no supervisadas, fundamentos del pre-entrenamiento moderno. ↩
Ouyang, L. et al. (2022). Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems 35, 27730-27744. https://papers.nips.cc/paper_files/paper/2022/hash/b1efde53be364a73914f58805a001731-Abstract-Conference.html ↩
Rafailov, R., Sharma, A., Mitchell, E., Ermon, S., Manning, C. D. y Finn, C. (2023). Direct preference optimization: Your language model is secretly a reward model. Advances in Neural Information Processing Systems 36. https://arxiv.org/abs/2305.18290 ↩
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł. y Polosukhin, I. (2017). Attention is all you need. En Advances in Neural Information Processing Systems 30 (pp. 5998-6008). https://papers.nips.cc/paper/7181-attention-is-all-you-need ↩
Kaplan, J. et al. (2020). Scaling laws for neural language models. arXiv:2001.08361. https://doi.org/10.48550/arXiv.2001.08361 ↩
Hoffmann, J. et al. (2022). Training compute-optimal large language models. Advances in Neural Information Processing Systems 35. https://doi.org/10.48550/arXiv.2203.15556 ↩

Capítulo 04

Facsímil 1 · Los cimientos

Capítulo 04: La neurona artificial: el átomo del aprendizaje

Entrando en el tema

Has oído hablar de modelos con miles de millones de parámetros. De redes que escriben código, generan imágenes y mantienen conversaciones. Es fácil imaginar que dentro de todo eso hay algo increíblemente complejo, inabarcable.

Y lo hay. Pero también es verdad que todo empieza con una pieza que cabe en tres líneas de código.

Esa pieza es la neurona artificial. No es una metáfora biológica vaga: es una función matemática concreta, con entradas, pesos, un sesgo y una salida. Si entiendes una neurona, entiendes el átomo del aprendizaje profundo. El resto —capas, redes, arquitecturas, Transformers— es composición.

Este capítulo es el primero con fórmulas. No te asustes. Vamos a desmenuzar cada símbolo, a ponerle números concretos y a escribir el código que lo implementa. Si al final entiendes y = max(0, w₁x₁ + w₂x₂ + b), has entendido lo esencial.

Qué es una neurona artificial

Una neurona artificial es una función matemática que recibe números, los multiplica por pesos, suma un sesgo y aplica una función de activación.¹ Punto. No hay biología. Hay aritmética.

Lo de «neurona» es un nombre prestado de la biología, pero la semejanza es superficial. Una neurona biológica es una célula con dendritas, axones y neurotransmisores. Una neurona artificial es una operación de multiplicación, suma y comparación. El nombre ayuda a visualizar, pero no te lleves a engaño: estás ante álgebra lineal, no ante neurociencia.

La capacidad del sistema no está en una neurona individual. Está en los miles de millones de parámetros —pesos, sesgos, matrices de proyección, normalizaciones y otras piezas aprendidas— ajustados durante el entrenamiento. Una neurona sola no aprende nada útil. Muchas operaciones paramétricas organizadas en una arquitectura moderna pueden generar código, traducir idiomas y responder preguntas.

La fórmula

En 1943, Warren McCulloch y Walter Pitts publicaron el primer modelo matemático de una neurona artificial.² Su neurona era binaria —encendida o apagada— y no aprendía: los pesos eran fijos. Quince años después, Frank Rosenblatt dio el paso decisivo: el perceptrón, una neurona cuyos pesos se ajustaban automáticamente a partir de ejemplos.³ Era la primera neurona que aprendía.

Hoy, ochenta años después, esta idea sigue viva dentro de los modelos modernos: tomar números de entrada, multiplicarlos por parámetros aprendidos, combinarlos y aplicar no linealidades. Pero un LLM no es simplemente una pila gigante de perceptrones: añade embeddings, atención, normalización, conexiones residuales y bloques MLP. La fórmula de la neurona no explica todo el Transformer, pero sí la operación mínima que veremos repetida dentro de sus bloques:

y = f\left(\sum_{i=1}^{n} w_i \cdot x_i + b\right)

Símbolo	Significado	Ejemplo
$y$	Salida de la neurona	0,76
$f$	Función de activación	ReLU (la más común)
$n$	Número de entradas	3
$x_i$	Entrada $i$ (un número)	$x_1 = 0{,}5$ , $x_2 = 0{,}3$ , $x_3 = 0{,}8$
$w_i$	Peso de la conexión $i$	$w_1 = 0{,}2$ , $w_2 = -0{,}4$ , $w_3 = 0{,}7$
$b$	Sesgo (bias)	0,1

En palabras: multiplicas cada entrada por su peso, sumas todo, añades el sesgo, y pasas el resultado por la función de activación. Eso es todo.

En ingeniería se suele escribir la misma idea en forma vectorial:

z = \mathbf{w}^{T}\mathbf{x} + b

y = f(z)

Símbolo	Significado	Ejemplo
$\mathbf{x}$	Vector de entradas	$[0{,}5, 0{,}3, 0{,}8]$
$\mathbf{w}$	Vector de pesos	$[0{,}2, -0{,}4, 0{,}7]$
$\mathbf{w}^{T}\mathbf{x}$	Producto escalar entre pesos y entradas	$0{,}54$
$z$	Suma ponderada antes de activar	$0{,}64$
$y$	Salida final de la neurona	$0{,}64$ con ReLU

Esta forma vectorial te obliga a mirar algo que en producción rompe más cosas de las que parece: las dimensiones. Si $\mathbf{x}$ tiene 3 valores, $\mathbf{w}$ debe tener 3 pesos. Si una entrada tiene cuatro columnas y el modelo espera tres, no tienes un problema filosófico: tienes un contrato de datos roto.

Con los números del ejemplo:

\text{suma} = (0{,}5 \times 0{,}2) + (0{,}3 \times -0{,}4) + (0{,}8 \times 0{,}7) + 0{,}1

\text{suma} = 0{,}10 + (-0{,}12) + 0{,}56 + 0{,}1 = 0{,}64

Si usamos ReLU como activación: $y = \max(0, 0{,}64) = 0{,}64$ .

Si usamos sigmoide: $y = \frac{1}{1 + e^{-0{,}64}} \approx 0{,}65$ .

La diferencia entre 0,64 y 0,65 parece pequeña, pero la elección de la función de activación determina qué puede aprender la red. Lo veremos a continuación.

Cómo funciona por dentro

En código, una neurona es literalmente esto:

function neurona(inputs, weights, bias) {
  const sum = inputs.reduce((acc, x, i) => acc + x * weights[i], 0);
  return activation(sum + bias);
}

// Ejemplo: neurona con 3 entradas
const entradas = [0.5, 0.3, 0.8];
const pesos    = [0.2, -0.4, 0.7];
const sesgo    = 0.1;

neurona(entradas, pesos, sesgo);
// sum = 0.5*0.2 + 0.3*(-0.4) + 0.8*0.7 + 0.1 = 0.64
// output = activation(0.64)

Observa tres cosas:

Una neurona es una función pura. Dadas las mismas entradas, pesos y sesgo, siempre produce la misma salida. El no determinismo del que hablamos en el capítulo 2 no está en la neurona individual: está en el muestreo que ocurre muchas capas después, al final del modelo.

Los pesos pueden ser negativos. Fíjate en $w_2 = -0{,}4$ . Un peso negativo significa que la entrada correspondiente reduce la activación de la neurona. Es análogo a las sinapsis inhibitorias en biología, pero aquí es simplemente un número negativo multiplicando.

El sesgo desplaza todo. Sin sesgo ( $b = 0$ ), nuestra neurona produciría $y = 0{,}54$ con ReLU. Con sesgo ( $b = 0{,}1$ ), produce $y = 0{,}64$ . El sesgo permite a la neurona activarse incluso cuando todas las entradas son cero. Es un parámetro más que se aprende durante el entrenamiento.

Funciones de activación

La función de activación $f$ es lo que hace que una red neuronal no sea simplemente una combinación lineal de sus entradas. Sin ella, diez capas de neuronas serían equivalentes a una sola operación lineal: no podrían aprender patrones complejos. La no linealidad es la que permite que las capas profundas capturen relaciones que una sola capa no podría.⁴

Función	Fórmula	Salida	Se usa en
ReLU	$\max(0, x)$	$[0, +\infty)$	Capas ocultas. La más usada. Simple, rápida y evita que los gradientes se desvanezcan.⁵
Sigmoide	$\dfrac{1}{1 + e^{-x}}$	$(0, 1)$	Capa de salida para clasificación binaria. Convierte cualquier número en una probabilidad entre 0 y 1.
Tanh	$\dfrac{e^x - e^{-x}}{e^x + e^{-x}}$	$(-1, 1)$	RNNs y LSTMs. Similar a la sigmoide pero centrada en cero, lo que ayuda al entrenamiento.
Softmax	$\dfrac{e^{x_i}}{\sum_{j} e^{x_j}}$	Probabilidades que suman 1	Capa final de clasificación multiclase. Convierte un vector de puntuaciones en una distribución de probabilidad.

En el día a día

La neurona artificial no es un concepto académico que aparece una vez en el capítulo 1 y no vuelves a ver. Aparece en cada capa de cada red neuronal que uses. Cuando llamas a una API de OpenAI, miles de millones de estas operaciones se ejecutan en paralelo en las GPUs del proveedor. Cuando haces fine-tuning de un modelo, estás ajustando los pesos y sesgos de neuronas como esta.

A nivel de código, aunque uses bibliotecas como PyTorch o TensorFlow que abstraen la neurona individual, entender qué hay debajo te permite depurar problemas de entrenamiento, elegir funciones de activación adecuadas y entender por qué ciertas arquitecturas funcionan mejor para ciertos problemas.

Por ejemplo: si tu red no aprende, una de las primeras cosas que comprobarás es si tus funciones de activación son adecuadas. Una ReLU en la capa de salida de un problema de clasificación binaria no tiene sentido: necesitas una sigmoide. Si todas tus activaciones son cero, puede que tengas «neuronas muertas» por ReLU en un rango donde todas las entradas son negativas. Estos diagnósticos solo son posibles si entiendes qué hace cada pieza.⁶

Por qué debería importarte

La neurona artificial es uno de los conceptos más importantes del deep learning. No porque sea compleja —es lo más simple que verás en este libro—, sino porque te enseña la operación elemental: pesos aprendidos, combinación lineal y no linealidad.

Una capa básica es un conjunto de neuronas que reciben las mismas entradas. Una red es una composición de capas. Un Transformer es una arquitectura más rica: combina atención, proyecciones, MLPs, normalizaciones y conexiones residuales. Pero en el fondo matemático seguimos viendo el mismo patrón: multiplicar matrices, sumar parámetros aprendidos, aplicar funciones y encadenar transformaciones.

Si entiendes y = f(w₁x₁ + w₂x₂ + b), estás a una capa de distancia de entender una red neuronal completa. Y a unas pocas capas más de entender un Transformer.⁷

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Olvidar la función de activación	Sin activación no lineal, una red de cien capas es matemáticamente equivalente a una sola capa. No puede aprender patrones complejos.	Comprueba siempre que cada capa (excepto la de salida en algunos casos) tenga una función de activación no lineal.
Usar la activación equivocada para la tarea	Usar ReLU en la capa de salida para clasificación binaria produce valores sin sentido. Usar sigmoide en capas ocultas profundas causa desvanecimiento del gradiente.	ReLU para capas ocultas, sigmoide para salida binaria, softmax para salida multiclase, tanh para RNNs.
Ignorar el sesgo	Poner el sesgo a cero o eliminarlo limita lo que la neurona puede aprender. Sin sesgo, la neurona solo puede representar funciones que pasan por el origen.	Incluye siempre el sesgo. Es un parámetro más y se aprende igual que los pesos.
Pensar que cada neurona «entiende» algo concreto	Una neurona individual no codifica un concepto reconocible. La representación emerge de la combinación de muchas neuronas. Intentar interpretar neuronas individuales suele llevar a conclusiones erróneas.	No busques significado en una neurona. Búscalo en los patrones de activación del conjunto.

Manos a la obra

Esta es la primera práctica matemática fuerte del facsímil. Puedes copiar el código mínimo de abajo para entender la operación, pero el entregable real está en kit descargable: un kit que valida dimensiones, calcula salidas, detecta casos inválidos y genera un informe de sensibilidad.

Primero, el núcleo de la neurona cabe en pocas líneas:

import math

# Funciones de activación
def relu(x):
    return max(0, x)

def sigmoid(x):
    return 1 / (1 + math.exp(-x))

# La neurona
def neurona(entradas, pesos, sesgo, activacion):
    suma = sum(x * w for x, w in zip(entradas, pesos)) + sesgo
    return activacion(suma)

# Probamos con los números del ejemplo
entradas = [0.5, 0.3, 0.8]
pesos    = [0.2, -0.4, 0.7]
sesgo    = 0.1

print("Suma ponderada:", sum(x*w for x,w in zip(entradas, pesos)) + sesgo)
print("Salida ReLU:", neurona(entradas, pesos, sesgo, relu))
print("Salida sigmoide:", neurona(entradas, pesos, sesgo, sigmoid))

Resultado esperado:

Suma ponderada: 0.64
Salida ReLU: 0.64
Salida sigmoide: 0.654...

Para reflexionar: cambia los pesos uno a uno. ¿Qué pasa si pones w₁ = 10? ¿Y si todos los pesos son cero? ¿Y si el sesgo es -10? Juega con los valores hasta que entiendas intuitivamente cómo cada parámetro afecta a la salida.

Después ejecuta el kit operativo:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/run_neuron_contract.py --write
cat output/neuron_decision.md

Para validar que la práctica sigue funcionando:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

El kit incluye Makefile, requirements.txt y tests/test_neuron_contract.py. La prueba no sustituye la reflexión matemática, pero evita que el ejercicio se convierta en una receta rota: comprueba que hay casos válidos, un caso inválido y salidas numéricas calculadas.

Qué deberías ver. El caso baseline_relu reproduce el ejemplo del capítulo. El caso negative_relu enseña cómo ReLU aplasta salidas negativas a cero. El caso binary_sigmoid muestra una salida interpretable como probabilidad. El caso invalid_dimension falla a propósito porque entradas y pesos no tienen la misma dimensión.

Cómo lo adaptas a tu caso. Añade un ejemplo nuevo en data/neuron_cases.json con cuatro entradas y cuatro pesos. Después cambia contracts/neuron_policy.json para modificar la tolerancia numérica o las activaciones permitidas.

Qué entregaría un alumno. El Markdown generado, un caso nuevo válido, un caso inválido explicado, el resultado de make test y una frase técnica sobre qué peso o sesgo mueve más la salida según el bloque de sensibilidad.

Cómo encaja todo

Este mapa se lee desde la fórmula hacia fuera. Los capítulos anteriores explican por qué necesitamos modelos que aprendan y por qué sus salidas finales pueden ser probabilísticas. Este capítulo baja al nivel mínimo: una neurona individual sí es determinista; lo que se aprende son sus pesos y su sesgo.

La decisión práctica que aparece aquí es nueva: antes de hablar de redes grandes, hay que respetar contratos pequeños. Dimensiones correctas, activación adecuada y cálculo reproducible. Si eso falla en una neurona, fallará multiplicado por millones en una red.

graph LR
    subgraph "Viene de antes"
        SUP["Aprendizaje supervisado\n(cap. 3)"]
        DET["Determinismo local\n(cap. 2)"]
        DATA["Datos como números\n(cap. 1-3)"]
    end

    subgraph "Capítulo 4: mecanismo mínimo"
        X["Vector de entradas x"]
        W["Vector de pesos w"]
        B["Sesgo b"]
        Z["z = w^T x + b"]
        F["Activación f(z)"]
        Y["Salida y"]
    end

    subgraph "Contrato de ingeniería"
        DIM["Misma dimensión\npara x y w"]
        ACT["Activación adecuada\na la tarea"]
        TEST["Caso esperado\ny sensibilidad"]
    end

    subgraph "Se reutiliza después"
        RED["Redes neuronales\n(cap. 5)"]
        BACKPROP["Retropropagación\n(cap. 6)"]
        OPT["Pérdida y optimización\n(cap. 7)"]
        TRANSFORMER["Transformer\n(fasc. 3)"]
    end

    DATA -->|"se convierte en"| X
    SUP -->|"ajusta durante entrenamiento"| W
    DET -->|"permite verificar"| Z
    X -->|"entra en"| Z
    W -->|"pondera"| Z
    B -->|"desplaza"| Z
    Z -->|"pasa por"| F
    F -->|"produce"| Y

    X -->|"debe cumplir"| DIM
    W -->|"debe cumplir"| DIM
    F -->|"debe cumplir"| ACT
    Y -->|"se comprueba con"| TEST

    Y -->|"se apila en"| RED
    BACKPROP -->|"actualiza"| W
    OPT -->|"usa gradientes sobre"| W
    RED -->|"escala hasta"| TRANSFORMER

    style SUP stroke-dasharray: 5 5
    style DET stroke-dasharray: 5 5
    style DATA stroke-dasharray: 5 5
    style RED stroke-dasharray: 5 5
    style BACKPROP stroke-dasharray: 5 5
    style OPT stroke-dasharray: 5 5
    style TRANSFORMER stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Neurona artificial	Función matemática que recibe entradas numéricas, las multiplica por pesos, suma un sesgo y aplica una función de activación para producir una salida.
Peso	Número que multiplica una entrada de la neurona. Representa la importancia de esa entrada para la salida. Se ajusta durante el entrenamiento.
Sesgo (bias)	Valor que se suma a la suma ponderada para desplazar la salida. Permite a la neurona activarse incluso con entradas nulas.
Función de activación	Función no lineal aplicada a la suma ponderada más el sesgo. Sin ella, la red no podría aprender patrones complejos.
Producto escalar	Operación que multiplica dos vectores componente a componente y suma los resultados. En la neurona es $\mathbf{w}^{T}\mathbf{x}$ .
Dimensión	Número de componentes de un vector. Entradas y pesos deben tener la misma dimensión para poder calcular la neurona.
ReLU	Función de activación que devuelve max(0, x). La más usada en capas ocultas.
Sigmoide	Función de activación que comprime cualquier entrada a un valor entre 0 y 1. Útil para clasificación binaria.
Softmax	Función que convierte un vector de puntuaciones en una distribución de probabilidad que suma 1. Se usa en la capa final de clasificación multiclase.

Antes de pasar página

¿Puedo escribir de memoria la fórmula de una neurona artificial? (Si no, vuelve a «La fórmula».)
¿Puedo calcular a mano la salida para unas entradas, pesos y sesgo dados? (Si no, vuelve al ejemplo numérico en «La fórmula».)
¿Entiendo para qué sirve la función de activación y qué pasaría sin ella? (Si no, vuelve a «Funciones de activación».)
¿Sé qué función de activación usar en cada situación? (Si no, vuelve a la tabla en «Funciones de activación».)
¿He ejecutado kit descargable y puedo explicar por qué falla invalid_dimension? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
Una neurona artificial es `y = f(Σ wᵢxᵢ + b)`.	Entradas por pesos, más sesgo, pasado por una función de activación. Tres líneas de código.
La función de activación es lo que da poder a la red.	Sin ella, cien capas equivalen a una. Con ella, cada capa captura patrones cada vez más abstractos.
La inteligencia no está en una neurona: está en miles de millones de ellas.	Una neurona sola es una calculadora simple. Conectadas en capas y entrenadas con cantidades masivas de datos, producen los modelos que usas cada día.
Todo lo que viene se construye sobre esto.	Una capa es un conjunto de neuronas. Una red es una pila de capas. Un LLM es una arquitectura específica de red. Todo empieza aquí.

Para saber más

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

He, K., Zhang, X., Ren, S. y Sun, J. (2016). Deep residual learning for image recognition. En Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 770-778). https://doi.org/10.1109/CVPR.2016.90

LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539

McCulloch, W. S. y Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. The Bulletin of Mathematical Biophysics, 5(4), 115-133. https://doi.org/10.1007/BF02478259

Nair, V. y Hinton, G. E. (2010). Rectified linear units improve restricted Boltzmann machines. En Proceedings of the 27th International Conference on Machine Learning (pp. 807-814). https://www.cs.toronto.edu/~hinton/absps/reluICML.pdf

Rosenblatt, F. (1958). The perceptron: a probabilistic model for information storage and organization in the brain. Psychological Review, 65(6), 386-408. https://doi.org/10.1037/h0042519

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Notas

Rosenblatt, F. (1958). The perceptron: a probabilistic model for information storage and organization in the brain. Psychological Review, 65(6), 386-408. https://doi.org/10.1037/h0042519. Rosenblatt introdujo el perceptrón, la primera neurona artificial implementada en hardware, sentando las bases del aprendizaje supervisado. ↩
McCulloch, W. S. y Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. The Bulletin of Mathematical Biophysics, 5(4), 115-133. https://doi.org/10.1007/BF02478259. Este artículo fundacional propuso que las neuronas podían modelarse como dispositivos lógicos de umbral, estableciendo el puente conceptual entre biología y computación. ↩
Rosenblatt, F. (1958). The perceptron: a probabilistic model for information storage and organization in the brain. Psychological Review, 65(6), 386-408. https://doi.org/10.1037/h0042519. Rosenblatt implementó el perceptrón en hardware —la máquina Mark I— y demostró que podía aprender a clasificar patrones visuales simples, inaugurando el campo del aprendizaje automático. ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 6 aborda en profundidad las funciones de activación y su papel en la capacidad representacional de las redes profundas. ↩
Nair, V. y Hinton, G. E. (2010). Rectified linear units improve restricted Boltzmann machines. En Proceedings of the 27th International Conference on Machine Learning (pp. 807-814). https://www.cs.toronto.edu/~hinton/absps/reluICML.pdf. Nair e Hinton introdujeron las unidades lineales rectificadas (ReLU) demostrando que mejoraban significativamente el entrenamiento de redes profundas frente a las funciones sigmoidales. ↩
He, K., Zhang, X., Ren, S. y Sun, J. (2016). Deep residual learning for image recognition. En Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 770-778). https://doi.org/10.1109/CVPR.2016.90. He y sus colegas demostraron que arquitecturas con conexiones residuales permiten entrenar redes de cientos de capas sin degradación del rendimiento, un avance que depende críticamente de una correcta elección de funciones de activación en cada bloque. ↩
LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539. Esta revisión de los tres pioneros del deep learning explica cómo las redes profundas con muchas capas aprenden representaciones jerárquicas, desde patrones simples en las primeras capas hasta conceptos abstractos en las profundas. ↩

Capítulo 05

Facsímil 1 · Los cimientos

Capítulo 05: Redes neuronales: capas, arquitectura y flujo

Entrando en el tema

En el capítulo anterior construiste una neurona. Una. Tres entradas, tres pesos, un sesgo y una salida. Funciona. Pero una neurona sola no llega muy lejos: puede trazar una línea recta entre dos grupos de puntos y poco más.

El salto empieza cuando conectas neuronas entre sí. Miles, millones, miles de millones de ellas. Organizadas en capas, cada una transformando los datos un poco más, pasando el resultado a la siguiente. Como una cadena de montaje donde cada estación añade una capa de abstracción.

Eso es una red neuronal. Y este capítulo explica cómo se organiza.

De la neurona a la capa

Una capa es un conjunto de neuronas que reciben las mismas entradas pero tienen sus propios pesos y sesgos.¹ Si la capa anterior tiene 3 neuronas y esta capa tiene 5, hay 3 × 5 = 15 conexiones, cada una con su propio peso. Más 5 sesgos, uno por neurona.

Cada neurona de la capa hace exactamente lo que viste en el capítulo 4: multiplica entradas por pesos, suma, suma el sesgo, aplica activación. La diferencia es que ahora sus entradas no son los datos originales (como «horas de estudio» o «temperatura»), sino las salidas de las neuronas de la capa anterior.

Y así, capa tras capa, los datos se transforman. Lo que empezó como una fila de números crudos termina como una predicción.

En una red real no solemos escribir neurona por neurona. Escribimos capas con matrices. Si la capa anterior produce un vector de tamaño $d_{l-1}$ y la capa actual tiene $d_l$ neuronas, la capa se calcula así:

z^{(l)} = W^{(l)}a^{(l-1)} + b^{(l)}

a^{(l)} = f^{(l)}(z^{(l)})

Símbolo	Forma	Qué significa
$a^{(l-1)}$	$d_{l-1}$	Activaciones que llegan desde la capa anterior. En la primera capa, es el vector de entrada $x$ .
$W^{(l)}$	$d_l \times d_{l-1}$	Matriz de pesos. Una fila por neurona de la capa actual y una columna por entrada recibida.
$b^{(l)}$	$d_l$	Vector de sesgos. Uno por neurona de la capa actual.
$z^{(l)}$	$d_l$	Puntuaciones antes de aplicar activación.
$a^{(l)}$	$d_l$	Salida de la capa después de la activación.

La regla de ingeniería es simple: la salida de una capa debe tener la misma dimensión que la entrada esperada por la siguiente. Si una capa entrega 64 valores, la siguiente necesita una matriz de pesos con 64 columnas. Este contrato parece una minucia, pero es una de las primeras cosas que se comprueban cuando una arquitectura no arranca.

También podemos contar parámetros antes de entrenar:

\text{parámetros de la capa } l = d_l \cdot d_{l-1} + d_l

El primer término son pesos. El segundo, sesgos. Para una red con capas $[4, 32, 16, 3]$ , el conteo sería:

Conexión	Cálculo	Parámetros
Entrada 4 → Oculta 32	$32 \cdot 4 + 32$	160
Oculta 32 → Oculta 16	$16 \cdot 32 + 16$	528
Oculta 16 → Salida 3	$3 \cdot 16 + 3$	51
Total	—	739

Este número no mide inteligencia. Mide coste y capacidad potencial. Si tienes 200 filas de datos y una red con 3 millones de parámetros, probablemente no estás haciendo ciencia: estás dando al modelo demasiadas formas de memorizar.

La arquitectura de una red

La estructura más básica se llama perceptrón multicapa (MLP, multilayer perceptron). Tiene tres tipos de capas:

Capa de entrada → Capa(s) oculta(s) → Capa de salida

Capa de entrada. No hace cálculos. Simplemente recibe los datos y los distribuye a la primera capa oculta. Si tu dataset tiene 10 columnas, tu capa de entrada tiene 10 neuronas. Una por feature.

Capas ocultas. Aquí ocurre el aprendizaje. Una red puede tener una, diez o cien capas ocultas. Cada una transforma la representación de los datos en algo ligeramente más abstracto. Son «ocultas» porque no las ves desde fuera: solo ves lo que entra y lo que sale.

Capa de salida. Produce la predicción final. Si estás clasificando imágenes de dígitos (0-9), tu capa de salida tendrá 10 neuronas, una por clase, con softmax como activación. Si estás prediciendo el precio de una casa, tendrá 1 neurona, sin activación (o con activación lineal).

Para diseñarla con criterio, no empieces preguntando «¿cuántas capas pongo?». Empieza por el contrato del problema:

Pregunta de diseño	Decisión técnica	Ejemplo
¿Cuántas variables entran?	Tamaño de la capa de entrada.	24 columnas numéricas y categóricas codificadas → entrada de 24 dimensiones.
¿Qué debe salir?	Tamaño y activación de salida.	Binario → 1 salida + sigmoide. Multiclase excluyente → $k$ salidas + softmax. Regresión → 1 salida lineal.
¿Cuánta no linealidad necesito?	Número de capas ocultas.	Datos tabulares sencillos: 1-3 capas. Imagen, audio o lenguaje: arquitecturas especializadas.
¿Cuánta capacidad puedo permitirme?	Ancho de cada capa y número total de parámetros.	64 neuronas pueden bastar para un clasificador interno; millones de parámetros exigen más datos y GPU.
¿Cómo voy a medir si funciona?	Métrica y conjunto de validación antes de entrenar.	Accuracy sola no basta si las clases están desbalanceadas; mira F1, recall, calibración o error absoluto según tarea.

Esta tabla evita una trampa común: diseñar una red como quien elige muebles. En ingeniería, arquitectura no es estética; es una hipótesis medible sobre datos, tarea, capacidad y coste.

Qué aprende cada capa

Una de las intuiciones más poderosas del deep learning es que las capas aprenden representaciones jerárquicas. No es una metáfora: es lo que se observa empíricamente al visualizar las activaciones de redes entrenadas.²

Capas tempranas. Detectan los patrones más elementales. En visión: bordes, colores, orientaciones. En texto: combinaciones de letras, prefijos y sufijos frecuentes. Son patrones que aparecen en cualquier imagen o texto, independientemente del contenido.

Capas intermedias. Combinan los patrones simples en conceptos más complejos. En visión: formas, texturas, partes de objetos (una rueda, un ojo, una esquina). En texto: frases hechas, relaciones sintácticas entre palabras.

Capas profundas. Abstracciones de alto nivel. En visión: objetos completos, rostros, escenas. En texto: significado semántico, intención del hablante, estructura argumental.

Esta jerarquía explica por qué el transfer learning funciona: las primeras capas de una red entrenada para reconocer imágenes sirven para casi cualquier tarea visual. Los bordes son bordes en todas partes. Son las capas profundas las que necesitan especializarse.³

Qué significa «deep» en deep learning

«Deep» significa «muchas capas». Una red con dos o tres capas es shallow (superficial). Una con decenas o cientos es deep. No hay un umbral oficial: la profundidad es una cuestión de grado.

Más capas permiten más abstracción, pero también traen problemas:

Más parámetros que entrenar: más memoria, más computación, más datos necesarios.
Gradientes que se desvanecen: en redes muy profundas, el gradiente puede hacerse tan pequeño en las primeras capas que dejan de aprender. Las funciones de activación como ReLU y arquitecturas como ResNet mitigan esto.⁴

La decisión de cuántas capas usar no es arbitraria: depende del problema, de los datos disponibles y del presupuesto computacional. Más capas no siempre es mejor. Pero cuando tienes datos masivos y tareas complejas —como procesar lenguaje natural—, la profundidad marca la diferencia.

Cómo fluyen los datos

El viaje de los datos a través de una red se llama propagación hacia delante (forward pass). Es determinista: dados los mismos datos de entrada y los mismos pesos, la salida es siempre la misma.

En el forward pass, cada capa:

Recibe un vector de números de la capa anterior.
Multiplica cada entrada por su peso correspondiente.
Suma todo y añade el sesgo.
Aplica la función de activación.
Pasa el resultado a la capa siguiente.

Al final de la última capa, tienes una predicción. En el siguiente capítulo veremos cómo, a partir del error de esa predicción, la red ajusta todos sus pesos hacia atrás. Pero por ahora, quédate con esto: una red neuronal es simplemente una función matemática compuesta, donde la salida de cada capa es la entrada de la siguiente.

En código de producción suele aparecer una dimensión adicional: el batch. No procesas una sola fila, sino muchas a la vez. Si tienes 128 ejemplos y cada uno tiene 24 variables, la entrada puede tener forma $128 \times 24$ . La capa no cambia su contrato interno: sigue esperando 24 columnas. Lo que cambia es que calcula 128 casos en paralelo.

Objeto	Forma típica	Lectura
Entrada de un ejemplo	$24$	Una fila con 24 variables.
Batch de entrada	$128 \times 24$	128 filas a la vez.
Pesos de la primera capa	$64 \times 24$	64 neuronas, cada una mira las 24 variables.
Salida de la primera capa	$128 \times 64$	128 filas, ahora representadas con 64 activaciones.
Salida final binaria	$128 \times 1$	Una probabilidad por ejemplo.

Cuando una librería te devuelve un error de dimensiones, normalmente te está diciendo que una de estas piezas no encaja. Un ingeniero no lo resuelve probando números al azar: imprime formas, revisa contrato y comprueba dónde se rompió la cadena.

Presupuesto de una arquitectura

Antes de entrenar, puedes hacer una revisión fría de la red: formas, parámetros y memoria aproximada. No predice la calidad final, pero evita diseños absurdos.

Imagina un clasificador para priorizar tickets internos. Cada ticket ya está convertido a 48 variables numéricas: señales del usuario, categoría, antigüedad, canal, idioma y métricas históricas. La salida tiene 3 clases: baja, media y alta.

Arquitectura	Capas	Parámetros	Lectura
MLP pequeño	$48 \rightarrow 32 \rightarrow 3$	1.667	Buen primer modelo. Barato, fácil de depurar y suficiente si las señales son fuertes.
MLP medio	$48 \rightarrow 128 \rightarrow 64 \rightarrow 3$	14.723	Más capacidad. Tiene sentido si hay bastantes ejemplos y relaciones no lineales.
MLP excesivo	$48 \rightarrow 1024 \rightarrow 1024 \rightarrow 3$	1.102.851	Puede funcionar, pero con pocos datos memorizará. También aumenta latencia, memoria y coste.

La comparación importante no es «qué red parece más profesional», sino qué red puedes justificar con datos. Si tienes 5.000 ejemplos limpios, empezar por un MLP pequeño o medio es razonable. Si tienes 200 ejemplos y clases desbalanceadas, el problema no se arregla con más capas: se arregla revisando datos, particiones, métrica y quizá usando un modelo más simple.

En el día a día

Cuando usas un LLM, no eliges cuántas capas tiene. El proveedor ya lo decidió por ti. Pero entender la arquitectura te permite tomar mejores decisiones:

Elegir el tamaño de modelo adecuado. Un modelo de 7B parámetros tiene menos capas (o capas más pequeñas) que uno de 70B. Más capas significan más capacidad de abstracción, pero también más latencia y más coste. Si tu tarea es clasificar el sentimiento de reseñas de producto, un modelo pequeño probablemente baste. Si necesitas análisis jurídico sobre documentos de cien páginas, necesitas profundidad, contexto y evaluación específica.

Hacer fine-tuning con criterio. Cuando ajustas un modelo pre-entrenado, la pregunta no es solo «qué capas entreno». En visión clásica sí era habitual congelar capas tempranas y entrenar capas finales. En LLMs modernos muchas veces se usan adaptadores, LoRA, QLoRA o entrenamiento parcial de módulos concretos, porque tocar todos los pesos es caro y puede degradar capacidades previas. La idea de fondo es la misma: decidir qué parte de la arquitectura permites modificar y cómo comprobarás que no empeora lo que ya funcionaba.

Depurar problemas de entrenamiento. Si tu fine-tuning no converge, entender la arquitectura te ayuda a diagnosticar: ¿tienes demasiadas capas para los datos que tienes? ¿El gradiente se está desvaneciendo en las capas tempranas? ¿La función de activación de la última capa es la adecuada para tu tarea?

Por qué debería importarte

La arquitectura de una red neuronal no es un detalle de implementación. Es la decisión de diseño más importante después de elegir los datos.

La diferencia entre un MLP de 3 capas y un Transformer de 96 capas no es solo de escala: es cualitativa. El MLP puede clasificar dígitos escritos a mano. El Transformer puede mantener una conversación larga, escribir código y trabajar con documentos extensos dentro de su ventana de contexto. La arquitectura determina qué patrones puede aprender y qué coste tendrá usarlos.

Y sin embargo, ambos se construyen con transformaciones paramétricas diferenciables: matrices, sesgos, no linealidades, normalizaciones y conexiones entre bloques. Lo que cambia es la organización. Por eso este capítulo importa: es el puente entre entender una operación elemental y entender por qué una arquitectura grande es ingeniería de formas, coste y flujo de información.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Añadir capas sin criterio	Más capas no siempre mejoran el rendimiento. Pueden causar overfitting si no tienes suficientes datos, o underfitting si el gradiente se desvanece.	Empieza con una arquitectura sencilla y añade complejidad solo cuando los datos y la tarea lo justifiquen. Mide el rendimiento en validación, no en entrenamiento.
Ignorar la función de activación de la capa de salida	Usar ReLU en la salida de un clasificador binario produce valores sin sentido. Usar softmax para regresión fuerza una distribución de probabilidad donde no aplica.	Elige la activación según la tarea: sigmoide para binario, softmax para multiclase, lineal para regresión, ninguna para valores sin restricción.
Creer que las capas profundas «entienden» conceptos humanos	Una capa profunda puede activarse fuertemente ante «gatos», pero no «sabe» qué es un gato. Reconoce un patrón estadístico, no un concepto.	No interpretes las activaciones como comprensión. Son correlaciones aprendidas. La interpretabilidad requiere técnicas específicas (facsímil 7).
*Olvidar que el forward pass* es determinista**	Si obtienes resultados distintos con los mismos datos y pesos, el problema no está en la red. Está en el preprocesamiento, en el batch o en el muestreo posterior.	Aísla cada componente. El forward pass de una red con pesos fijos es determinista. Si hay variabilidad, búscala fuera.
No mirar las formas de los tensores	Muchos errores no son conceptuales: una capa entrega 128 valores y la siguiente espera 64, o la salida tiene 10 clases y la etiqueta viene como binaria.	Antes de entrenar, escribe la secuencia de dimensiones y cuenta parámetros. Si no puedes hacerlo en papel, tampoco lo depurarás bien en código.
Confundir más parámetros con más rigor	Una red grande puede parecer más seria, pero si el conjunto de datos es pequeño solo aumenta la capacidad de memorizar ruido.	Compara parámetros con ejemplos disponibles, mira validación y mantén una arquitectura base sencilla como control.

Manos a la obra

La práctica útil de este capítulo no es entrenar una red grande: es auditar una arquitectura antes de entrenarla. He dejado un kit ejecutable en kit descargable que calcula formas, parámetros, memoria aproximada y una señal de riesgo comparando parámetros con ejemplos disponibles.

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/audit_architectures.py --write
cat output/architecture_decision.md

Como mini proyecto reproducible:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

El kit contiene varios candidatos: un MLP pequeño para tickets, un MLP medio, un diseño excesivo para pocos datos y un caso inválido que rompe el contrato de salida. La idea no es que memorices esos números, sino que aprendas a defender una arquitectura antes de gastar GPU.

Además de datos, contrato y script, el kit incluye Makefile, requirements.txt y tests/test_architecture_budget.py. La prueba comprueba que se calculan parámetros, que aparecen advertencias cuando toca y que el informe habla de capacidad con números.

Qué deberías mirar.

Campo	Qué te dice	Por qué importa
`layer_shapes`	Forma de cada matriz de pesos.	Verifica que cada capa encaja con la anterior.
`total_parameters`	Pesos + sesgos de toda la red.	Aproxima capacidad, memoria y riesgo de sobreajuste.
`memory_estimate`	Memoria mínima aproximada de pesos en FP32, BF16 e INT8.	No incluye activaciones ni optimizador, pero sirve para comparar diseños.
`examples_per_parameter`	Relación entre ejemplos disponibles y parámetros.	Si es muy baja, la arquitectura merece sospecha.
`status`	`ok`, `warning` o `invalid`.	Resume si el diseño se puede justificar con el contrato actual.

Cómo lo adaptas a tu caso. Cambia data/architecture_candidates.json: define input_dim, output_dim, task, hidden_layers, training_examples y class_balance. Después ejecuta el informe y defiende por qué elegirías una arquitectura frente a otra.

TensorFlow Playground sigue siendo útil para intuición visual.⁵ Úsalo como complemento: empieza con una capa oculta de 2 neuronas, prueba un dataset circular, añade capas y cambia ReLU por Tanh. Pero el entregable de ingeniería es el informe del kit: contrato, parámetros, coste y decisión.

Qué entregaría un alumno. El Markdown generado, una arquitectura nueva justificada, una explicación de por qué su salida coincide con la tarea, el resultado de make test y una decisión escrita: entrenar, simplificar, recoger más datos o cambiar de familia de modelo.

Cómo encaja todo

Este capítulo es el puente entre una neurona aislada y una red entrenable. Hereda del capítulo 4 la operación mínima $y=f(w^Tx+b)$ , pero la convierte en una arquitectura: matrices, capas, formas, activaciones y salida. Esa arquitectura no aprende todavía; solo calcula. Aprenderá en el capítulo 6, cuando la pérdida viaje hacia atrás y modifique pesos.

La idea que conviene guardar es esta: una red neuronal es una función compuesta con contratos de forma. Si respetas esos contratos, puedes apilar capas, medir coste y elegir salidas coherentes con la tarea. Si no los respetas, el modelo no falla por misterioso: falla porque la ingeniería básica no encaja.

graph LR
    subgraph "Viene de antes"
        NEURONA["Neurona artificial\n(cap. 4)"]
        DET["Forward determinista\n(cap. 2)"]
        SUP["Aprendizaje supervisado\n(cap. 3)"]
    end

    subgraph "Capítulo 5: arquitectura"
        MATRIX["Matriz de pesos\nW(l)"]
        SHAPE["Contrato de forma\nd(l-1) -> d(l)"]
        LAYER["Capa\na(l)=f(Wa+b)"]
        STACK["Red MLP\ncapas apiladas"]
        OUTPUT["Salida según tarea\nsigmoide / softmax / lineal"]
        BUDGET["Presupuesto\nparámetros y memoria"]
    end

    subgraph "Se reutiliza después"
        BACKPROP["Retropropagación\n(cap. 6)"]
        LOSS["Pérdida y optimizadores\n(cap. 7)"]
        CNNRNN["CNN y RNN\n(cap. 8)"]
        TRANSFORMER["Transformer y LLM\n(fasc. 3)"]
        FINETUNE["Fine-tuning y LoRA\n(fasc. 4)"]
    end

    NEURONA -->|"se vectoriza como"| MATRIX
    DET -->|"permite verificar"| LAYER
    SUP -->|"define etiqueta y salida"| OUTPUT
    MATRIX -->|"debe cumplir"| SHAPE
    SHAPE -->|"habilita"| LAYER
    LAYER -->|"se apila en"| STACK
    STACK -->|"termina en"| OUTPUT
    STACK -->|"se audita con"| BUDGET
    OUTPUT -->|"genera predicción para"| BACKPROP
    BACKPROP -->|"necesita perdida"| LOSS
    STACK -->|"se especializa en"| CNNRNN
    STACK -->|"escala hacia"| TRANSFORMER
    TRANSFORMER -->|"se adapta con"| FINETUNE

    style NEURONA stroke-dasharray: 5 5
    style DET stroke-dasharray: 5 5
    style SUP stroke-dasharray: 5 5
    style BACKPROP stroke-dasharray: 5 5
    style LOSS stroke-dasharray: 5 5
    style CNNRNN stroke-dasharray: 5 5
    style TRANSFORMER stroke-dasharray: 5 5
    style FINETUNE stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Red neuronal	Grafo dirigido de neuronas artificiales organizadas en capas que transforman datos secuencialmente.
Capa	Conjunto de neuronas que reciben las mismas entradas y producen salidas que alimentan la capa siguiente.
Capa oculta	Capa intermedia entre la entrada y la salida. Transforma los datos en representaciones progresivamente más abstractas.
MLP (multilayer perceptron)	Arquitectura donde cada neurona de una capa se conecta con todas las neuronas de la capa siguiente.
Deep learning	Entrenamiento de redes con muchas capas (decenas o cientos) que aprenden jerarquías de representaciones.
Forward pass	Recorrido de los datos desde la entrada hasta la salida. Es determinista: mismos pesos, misma salida.
Matriz de pesos	Conjunto de pesos de una capa escrito como matriz $W$ . Su forma $d_l \times d_{l-1}$ define cuántas entradas recibe cada neurona y cuántas neuronas tiene la capa.
Ancho	Número de neuronas de una capa. Aumenta capacidad y coste.
Profundidad	Número de capas con parámetros. Permite composiciones más complejas, pero complica entrenamiento y depuración.
Contrato de forma	Requisito de que la salida de una capa tenga la dimensión que espera la siguiente. Es una validación básica antes de entrenar.
Presupuesto de parámetros	Conteo de pesos y sesgos de la arquitectura. Sirve para comparar capacidad, memoria aproximada y riesgo de sobreajuste.

Antes de pasar página

¿Puedo dibujar (mentalmente o en papel) la estructura de una red neuronal con capa de entrada, dos ocultas y una de salida? (Si no, vuelve al diagrama en «La arquitectura de una red».)
¿Puedo escribir la fórmula de una capa $a^{(l)}=f(W^{(l)}a^{(l-1)}+b^{(l)})$ y explicar la forma de $W$ ? (Si no, vuelve a «De la neurona a la capa».)
¿Entiendo qué aprende cada capa y por qué las capas tempranas son más genéricas? (Si no, vuelve a «Qué aprende cada capa».)
¿Sé qué significa «deep» en deep learning y qué problemas trae? (Si no, vuelve a «Qué significa deep».)
¿Puedo explicar el forward pass? (Si no, vuelve a «Cómo fluyen los datos».)
¿He ejecutado kit descargable y puedo defender una arquitectura con parámetros, formas y salida? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
Una red neuronal es una composición de capas.	Cada capa aplica una transformación $W a + b$ , una activación y entrega una nueva representación.
Las dimensiones son contrato, no decoración.	Si una capa produce 64 valores, la siguiente debe aceptar 64 entradas. Muchos errores reales empiezan ahí.
Los parámetros se pueden contar antes de entrenar.	$d_l \cdot d_{l-1} + d_l$ por capa. Ese conteo ayuda a razonar sobre memoria, datos necesarios y riesgo de sobreajuste.
Profundidad y ancho son decisiones de ingeniería.	Más capas o más neuronas pueden dar más capacidad, pero también más coste, más latencia y más superficie de fallo.
El capítulo 6 necesita este capítulo.	La retropropagación solo tiene sentido cuando sabes qué pesos, sesgos y capas debe actualizar.

Para saber más

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539

Nielsen, M. (2015). Neural networks and deep learning. http://neuralnetworksanddeeplearning.com

Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L. y Polosukhin, I. (2017). Attention is all you need. En Advances in Neural Information Processing Systems 30. https://arxiv.org/abs/1706.03762

Notas

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 6 aborda en profundidad las arquitecturas de redes feedforward, desde el perceptrón simple hasta las redes profundas modernas. ↩
LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539. Los autores describen cómo las redes profundas aprenden representaciones jerárquicas: desde bordes y texturas en las primeras capas hasta partes de objetos y conceptos completos en las capas profundas. ↩
Krizhevsky, A., Sutskever, I. y Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. En Advances in Neural Information Processing Systems 25 (pp. 1097-1105). https://papers.nips.cc/paper/4824. AlexNet demostró que las características aprendidas por las capas tempranas de una CNN son transferibles entre tareas visuales, sentando las bases del transfer learning moderno. ↩
He, K., Zhang, X., Ren, S. y Sun, J. (2016). Deep residual learning for image recognition. En Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 770-778). https://doi.org/10.1109/CVPR.2016.90. Las conexiones residuales permiten que el gradiente fluya directamente a través de las capas, resolviendo el problema del desvanecimiento en redes de más de cien capas. ↩
TensorFlow Playground. https://playground.tensorflow.org. Una herramienta educativa que visualiza en tiempo real el entrenamiento de redes neuronales sobre conjuntos de datos sintéticos. ↩

Capítulo 06

Facsímil 1 · Los cimientos

Capítulo 06: Cómo aprende una red: retropropagación

Entrando en el tema

Imagina que estás en una montaña con niebla cerrada. No ves el valle. No ves el camino. Pero puedes sentir la pendiente bajo tus pies. Sabes, en cada punto, hacia dónde baja el terreno. Das un paso en esa dirección. Vuelves a tantear. Otro paso. Así, a ciegas pero con información local, acabas llegando al punto más bajo.

Eso es exactamente lo que hace una red neuronal cuando aprende. El «valle» es el mínimo de la función de pérdida —el punto donde el error es más pequeño—. La «pendiente» es el gradiente. Y los «pasos» son las actualizaciones de los pesos.

El algoritmo que calcula esa pendiente se llama retropropagación (backpropagation).¹ Es el motor del aprendizaje profundo. Sin él, las redes de más de dos capas no podrían entrenarse. Con él, una red de cien capas ajusta todos sus parámetros en cada iteración.

Este capítulo es denso. Respira hondo. Vamos a desmenuzarlo pieza a pieza.

El bucle de entrenamiento

Entrenar una red neuronal es un bucle de cuatro pasos que se repite millones de veces:

1. Forward pass → 2. Calcular pérdida → 3. Backward pass → 4. Actualizar pesos → (repetir)

En pseudocódigo:

for epoch in range(num_epochs):
    for batch in dataloader:
        optimizer.zero_grad()                      # Reset antes de acumular
        prediction = model.forward(batch.input)   # 1. Forward
        loss = loss_fn(prediction, batch.target)   # 2. Pérdida
        loss.backward()                            # 3. Gradientes
        optimizer.step()                           # 4. Actualizar

Cuatro líneas de código. Miles de millones de ejecuciones. Así se entrenan los LLMs.

Cada paso merece su propia explicación:

1. Forward pass. Los datos atraviesan la red de izquierda a derecha. Capa a capa, neurona a neurona. Al final, obtienes una predicción. Es determinista: mismos pesos, misma salida. Lo vimos en el capítulo 5.

2. Calcular la pérdida. Comparas la predicción con la respuesta real. ¿Cuánto se ha equivocado el modelo? La función de pérdida te da un número. Si la predicción es perfecta, la pérdida es cero. Cuanto mayor es el error, mayor es la pérdida.²

3. Backward pass. Aquí está la parte importante. El error viaja hacia atrás, de derecha a izquierda, desde la salida hasta la entrada. En cada neurona, en cada peso, el algoritmo calcula cuánto contribuyó ese parámetro al error total. Esto se llama gradiente. La herramienta matemática que lo permite es la regla de la cadena del cálculo.

4. Actualizar pesos. Conoces el gradiente. Sabes en qué dirección modificar cada peso para reducir el error. Aplicas un pequeño ajuste en esa dirección. La magnitud del ajuste la controla el learning rate: un paso demasiado grande y te pasas del mínimo; demasiado pequeño y tardas una eternidad en llegar.

La cadena completa: qué significa cada símbolo

Antes de lanzarnos a las derivadas, necesitamos ponernos de acuerdo en el vocabulario. Vamos a seguir el viaje de un solo dato a través de una neurona con activación sigmoide.³ Es el ejemplo más simple posible, pero contiene toda la mecánica que se repite en redes de miles de millones de parámetros.

Símbolo	Nombre	Significado	En el ejemplo
$x$	Entrada	El dato que llega a la neurona. Puede ser una feature del dataset o la salida de una capa anterior.	$x = 2$
$w$	Peso	Número aprendido que pondera la entrada. Si cambia, cambia la predicción.	$w = 0{,}40$
$b$	Sesgo	Ajuste aprendido independiente de la entrada. Permite desplazar la salida.	$b = -0{,}10$
$z$	Preactivación	Suma lineal antes de aplicar la activación. $z = wx + b$ . Es la puntuación cruda.	$z = 0{,}40 \times 2 - 0{,}10 = 0{,}70$
$\sigma$	Sigmoide	Función que comprime $z$ al intervalo $(0,1)$ . $\sigma(z) = \frac{1}{1 + e^{-z}}$ .	—
$a$	Activación	Salida de la neurona tras aplicar la activación. $a = \sigma(z)$ .	$a \approx 0{,}668$
$y$	Etiqueta real	La respuesta correcta del ejemplo de entrenamiento.	$y = 1$
$E$	Error (pérdida)	Medida numérica del fallo. Aquí usamos MSE: $E = \frac{1}{2}(a - y)^2$ .	$E \approx 0{,}055$
$\eta$	Learning rate	Tamaño del paso al actualizar. La dirección la marca el gradiente.	$\eta = 0{,}1$

Dos aclaraciones importantes:

No confundas $z$ y $a$ . $z$ es la puntuación cruda antes de la activación. Puede ser negativa, grande, pequeña. $a$ es la salida ya transformada por la sigmoide, siempre entre 0 y 1. El error se calcula con $a$ , no con $z$ : comparamos la predicción final con la realidad.

No entrenamos contra $z$ . La pérdida $E$ compara $a$ con $y$ . Pero para ajustar $w$ y $b$ necesitamos saber cómo afectan a $E$ . Y $w$ y $b$ afectan a $z$ , no directamente a $a$ . Por eso necesitamos la regla de la cadena: para propagar el error desde $a$ hasta $z$ , y desde $z$ hasta $w$ y $b$ .

Forward pass: la predicción

Con los números del ejemplo, el forward pass es:

x = 2, \quad w = 0{,}40, \quad b = -0{,}10, \quad y = 1

z = w \cdot x + b = 0{,}40 \times 2 + (-0{,}10) = 0{,}70

a = \sigma(z) = \frac{1}{1 + e^{-0{,}70}} \approx 0{,}668

E = \frac{1}{2}(a - y)^2 = \frac{1}{2}(0{,}668 - 1)^2 \approx 0{,}055

La neurona predice 0,668. La respuesta correcta es 1. La predicción se queda corta. Queremos empujar la salida hacia arriba: necesitamos que $a$ se acerque a 1.

Backward pass: cómo viaja el error hacia atrás

El objetivo del backward pass es calcular cuatro gradientes:

\frac{\partial E}{\partial a}, \quad \frac{\partial E}{\partial z}, \quad \frac{\partial E}{\partial w}, \quad \frac{\partial E}{\partial b}

Cada uno responde a una pregunta: «si cambio un poco esto, ¿cuánto cambia el error?». Se leen como derivadas parciales: la letra $\partial$ indica que solo estamos variando una variable y manteniendo el resto constantes.

Vamos paso a paso, de derecha a izquierda.

Paso 1: error respecto a la salida

\frac{\partial E}{\partial a}

Usamos la pérdida MSE: $E = \frac{1}{2}(a - y)^2$ . Su derivada respecto a $a$ es directa:

\frac{\partial E}{\partial a} = a - y = 0{,}668 - 1 = -0{,}332

Lectura: como la predicción es menor que la realidad, el gradiente es negativo. «Si subo $a$ , el error $E$ baja». El signo negativo nos dice la dirección correcta. La magnitud (0,332) nos dice cuánto impacto tiene.

Paso 2: error antes de la activación

\frac{\partial E}{\partial z}

Aquí entra la regla de la cadena. $E$ depende de $a$ , y $a$ depende de $z$ a través de la sigmoide. Por tanto:

\frac{\partial E}{\partial z} = \frac{\partial E}{\partial a} \cdot \sigma'(z)

La derivada de la sigmoide tiene una forma elegante: $\sigma'(z) = \sigma(z) \cdot (1 - \sigma(z)) = a(1 - a)$ .⁴ En nuestro caso:

\sigma'(z) = a(1 - a) = 0{,}668 \times 0{,}332 \approx 0{,}222

\frac{\partial E}{\partial z} = -0{,}332 \times 0{,}222 \approx -0{,}074

Lectura: la sigmoide ha atenuado el gradiente. De -0,332 hemos pasado a -0,074. Es la sigmoide diciendo: «en esta zona de la curva, un cambio en $z$ produce un cambio pequeño en $a$ ». Esto es el germen del problema del desvanecimiento del gradiente que mencionamos en el capítulo 5.

Paso 3: culpa asignada al peso

\frac{\partial E}{\partial w}

$E$ depende de $z$ , y $z = wx + b$ . La derivada de $z$ respecto a $w$ es simplemente $x$ . Regla de la cadena:

\frac{\partial E}{\partial w} = \frac{\partial E}{\partial z} \cdot \frac{\partial z}{\partial w} = \frac{\partial E}{\partial z} \cdot x

\frac{\partial E}{\partial w} \approx -0{,}074 \times 2 = -0{,}148

Lectura: el gradiente es negativo. Si aumentamos $w$ , el error disminuye. Tiene sentido: la predicción era demasiado baja, y aumentar $w$ aumenta $z$ , lo que aumenta $a$ , lo que reduce $E$ . Además, el gradiente respecto a $w$ es proporcional a $x$ : las entradas más grandes reciben actualizaciones más grandes.

Paso 4: culpa asignada al sesgo

\frac{\partial E}{\partial b}

$z = wx + b$ . La derivada de $z$ respecto a $b$ es 1. Por tanto:

\frac{\partial E}{\partial b} = \frac{\partial E}{\partial z} \cdot \frac{\partial z}{\partial b} = \frac{\partial E}{\partial z} \cdot 1 \approx -0{,}074

Lectura: el gradiente respecto al sesgo es igual al gradiente respecto a $z$ . El sesgo se ajusta directamente con la señal de error que llega a la neurona, sin la mediación de la entrada.

La actualización final

Conocidos los gradientes, actualizamos los parámetros. La regla es siempre la misma:

w \leftarrow w - \eta \cdot \frac{\partial E}{\partial w}

b \leftarrow b - \eta \cdot \frac{\partial E}{\partial b}

El signo menos es crucial: nos movemos en la dirección que reduce la pérdida, no en la que la aumenta. Con $\eta = 0{,}1$ :

w_{\text{nuevo}} = 0{,}40 - 0{,}1 \times (-0{,}148) \approx 0{,}415

b_{\text{nuevo}} = -0{,}10 - 0{,}1 \times (-0{,}074) \approx -0{,}093

Ambos parámetros han subido. La próxima vez que esta misma entrada pase por la neurona, $z$ será mayor, $a$ se acercará más a 1, y el error $E$ bajará. Una iteración. Quedan miles de millones.

Resumen de gradientes

Gradiente	Lectura	Fórmula	Valor
$\partial E / \partial a$	Error respecto a la salida final	$a - y$ (con MSE)	-0,332
$\partial E / \partial z$	Error traducido al espacio preactivación	$\partial E / \partial a \cdot \sigma'(z)$	-0,074
$\partial E / \partial w$	Culpa asignada al peso	$\partial E / \partial z \cdot x$	-0,148
$\partial E / \partial b$	Culpa asignada al sesgo	$\partial E / \partial z$	-0,074

Observa el patrón: el gradiente fluye hacia atrás, atenuándose en cada paso (la sigmoide reduce -0,332 a -0,074). En redes profundas, esta atenuación se acumula capa tras capa. Es el problema del desvanecimiento del gradiente, y es la razón por la que las arquitecturas modernas usan ReLU en lugar de sigmoide en las capas ocultas.

En el día a día

En la práctica, nunca calculas gradientes a mano. PyTorch, TensorFlow y JAX lo hacen automáticamente mediante diferenciación automática (autograd).⁵ Tú escribes el forward pass y la biblioteca construye el grafo de operaciones y calcula los gradientes por ti.

Pero entender qué hay debajo te permite:

Depurar gradientes que se desvanecen o explotan. Si tu red no aprende, mira los gradientes. Si son casi cero en las primeras capas, tienes un problema de desvanecimiento. Si son enormes, tienes un problema de explosión.
Elegir la función de activación correcta. La sigmoide atenúa el gradiente (lo viste: 0,332 → 0,074). ReLU no: su gradiente es 1 para valores positivos. Por eso ReLU es la activación estándar en capas ocultas.
Entender por qué el learning rate importa. Si $\eta$ es demasiado grande, los pesos oscilan y no convergen. Si es demasiado pequeño, el entrenamiento es innecesariamente lento. La magnitud del gradiente (0,148 en nuestro ejemplo) interactúa con $\eta$ para determinar el tamaño del paso.

Cómo se depura en ingeniería

Cuando una red no aprende, una respuesta floja sería «prueba otro modelo». La respuesta de ingeniería es más aburrida y más útil: mirar señales. Antes de cambiar arquitectura, conviene saber si el backward pass está calculando algo coherente.

La comprobación clásica se llama gradient check o comprobación por diferencias finitas. Si quieres estimar el gradiente respecto a un peso $w$ , perturbas ese peso un poco hacia arriba y hacia abajo, calculas la pérdida en ambos casos y comparas:

\frac{\partial E}{\partial w} \approx \frac{E(w + \epsilon) - E(w - \epsilon)}{2\epsilon}

Aquí $\epsilon$ es un número pequeño, por ejemplo $10^{-5}$ . Si el gradiente analítico que calculas con backpropagation y el gradiente numérico por diferencias finitas no se parecen, algo está mal: signo, derivada, activación, pérdida, broadcasting o acumulación.

No se usa este método para entrenar porque sería lentísimo: por cada parámetro tienes que ejecutar al menos dos forward passes. Se usa para comprobar implementaciones pequeñas, depurar capas nuevas y explicar por qué confiar ciegamente en loss.backward() no basta cuando tú has escrito parte de la función.

Señal	Qué mirar	Qué puede indicar
Pérdida antes/después	La pérdida debería bajar tras una actualización razonable.	Si sube siempre, revisa signo, learning rate o etiqueta.
Norma del gradiente	Tamaño global de los gradientes.	Casi cero: gradiente desvanecido. Enorme: gradiente explosivo.
Ratio de actualización	$	\Delta w
NaN o infinito	Valores no numéricos en pérdida o gradientes.	Activaciones saturadas, división por cero, learning rate excesivo o datos mal escalados.
Diferencias finitas	Gradiente numérico frente a gradiente analítico.	Detecta errores de implementación en derivadas o signo.

Esta tabla es pequeña, pero cambia la forma de trabajar. Dejas de mirar el entrenamiento como una caja negra y empiezas a tratarlo como un sistema observable.

Por qué debería importarte

La retropropagación no es un detalle de implementación. Es el algoritmo que hace posible el deep learning. Sin él, solo podríamos entrenar redes de una capa.

Cuando un modelo mejora durante entrenamiento, post-training o fine-tuning, ocurre una variante de este mismo proceso: se mide un error o una preferencia, se calcula una señal de gradiente y se ajustan parámetros. En una conversación normal con un LLM, en cambio, el modelo no aprende por el simple hecho de recibir feedback del usuario; responde con pesos ya fijados. Esa distinción importa: una cosa es usar un modelo y otra es cambiarlo.

Entender la retropropagación es entender cómo aprende una máquina. No hay atajos. Pero una vez que lo entiendes, todo lo demás —arquitecturas, optimizadores, fine-tuning, RLHF— son variaciones sobre este mismo tema.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
No resetear los gradientes entre iteraciones	Los gradientes se acumulan por defecto en PyTorch. Si no llamas a `zero_grad()`, cada iteración suma su gradiente al anterior, produciendo actualizaciones incorrectas.	`optimizer.zero_grad()` al inicio de cada iteración, antes del `forward` y del `backward`. Así sabes que el gradiente que miras pertenece a ese lote.
Confundir la dirección del gradiente	El gradiente apunta en la dirección de máximo crecimiento del error. Por eso actualizamos con signo menos: para ir en dirección contraria, hacia el mínimo.	Grábate: `w = w - η * grad`. El signo menos no es negociable.
Interpretar el gradiente como magnitud absoluta de error	Un gradiente de -0,148 no significa que el peso esté «un 14,8 % mal». Significa que un cambio unitario en el peso cambia el error en -0,148 unidades. Es una sensibilidad, no un porcentaje de error.	Lee el gradiente como «si aumento esto en 1, el error cambia en X». No como «esto está X % equivocado».
*Olvidar que el forward pass* es determinista pero el resultado del entrenamiento no**	Con los mismos datos iniciales y los mismos hiperparámetros, el entrenamiento puede converger a soluciones distintas. El paisaje de la función de pérdida tiene muchos mínimos locales.	No esperes reproducibilidad exacta en el entrenamiento. Fija semillas aleatorias si necesitas comparar experimentos.
Confiar en autograd sin comprobar nada	Que una biblioteca calcule gradientes no significa que tu pérdida, tu salida, tus etiquetas o tu capa personalizada estén bien planteadas.	En problemas pequeños, compara con diferencias finitas. En problemas reales, registra norma del gradiente, pérdida y ratio de actualización.

Manos a la obra

La práctica de este capítulo está en kit descargable. Implementa el ejemplo de la neurona sigmoide, calcula gradientes analíticos, los compara contra diferencias finitas y prueba varios learning rates.

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/check_backprop.py --write
cat output/backprop_decision.md

Como práctica reproducible:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

La carpeta incluye Makefile, requirements.txt y tests/test_backprop_check.py. La prueba exige que el gradiente analítico y el numérico coincidan en todos los casos: es el tipo de comprobación pequeña que salva horas cuando una red “no aprende”.

El objetivo no es escribir un mini PyTorch. El objetivo es que veas tres cosas que sí usarás como ingeniero:

Comprobación	Qué demuestra	Por qué sirve
Gradiente analítico	Lo que calcula la regla de la cadena.	Es el backward pass que usaría una librería de autograd.
Gradiente numérico	Lo que estima la pérdida al perturbar pesos.	Sirve como control externo para detectar errores de derivada o signo.
Barrido de learning rate	Qué pasa con pasos pequeños, razonables o grandes.	Enseña por qué una actualización puede mejorar, no mover nada o empeorar.

Qué deberías ver. El caso base reproduce el ejemplo del capítulo y la pérdida baja con $\eta=0{,}1$ . El caso saturado muestra gradientes muy pequeños aunque la pérdida sea alta: ahí se intuye el desvanecimiento. El informe también compara la actualización correcta con una actualización de signo contrario para que el error de signo deje de ser una frase abstracta.

Cómo lo adaptas a tu caso. Añade un ejemplo en data/backprop_cases.json con otros valores de $x$ , $w$ , $b$ e $y$ . Después modifica contracts/backprop_policy.json para cambiar $\epsilon$ , tolerancia o learning rates.

Qué entregaría un alumno. El Markdown generado, un caso nuevo, una lectura de por qué el gradiente analítico coincide o no con el numérico, el resultado de make test y una decisión sobre qué learning rate usaría en el primer entrenamiento.

Cómo encaja todo

La retropropagación conecta dos mundos: el cálculo hacia delante, que produce una predicción, y la optimización, que decide cómo corregir pesos. En capítulos anteriores ya teníamos neuronas, capas y salida; aquí aparece la pregunta nueva: qué parámetro tuvo qué responsabilidad en el error.

En ingeniería, este capítulo también introduce una costumbre que seguirá apareciendo: no basta con que algo entrene; hay que observarlo. Pérdida, gradientes, ratios de actualización y comprobaciones numéricas son señales de salud del sistema.

graph LR
    subgraph "Viene de antes"
        NEURONA["Neurona artificial\n(cap. 4)"]
        RED["Capas y arquitectura\n(cap. 5)"]
        DET["Forward determinista\n(cap. 2)"]
    end

    subgraph "Capítulo 6: aprender de un error"
        FORWARD["Forward pass\npredicción"]
        LOSS["Pérdida\nE(a,y)"]
        CHAIN["Regla de la cadena"]
        GRAD["Gradientes\ndE/dw, dE/db"]
        UPDATE["Actualización\nw <- w - eta grad"]
        CHECK["Gradient check\npor diferencias finitas"]
    end

    subgraph "Se reutiliza después"
        OPTI["Pérdidas y optimizadores\n(cap. 7)"]
        CNNRNN["CNN y RNN\n(cap. 8)"]
        FINETUNE["Fine-tuning\n(fasc. 4)"]
        LORA["LoRA y QLoRA\n(fasc. 3-4)"]
        EVAL["Evaluación de runs\n(fasc. 6)"]
    end

    NEURONA -->|"aporta pesos y sesgo"| FORWARD
    RED -->|"apila capas para"| FORWARD
    DET -->|"permite reproducir"| FORWARD
    FORWARD -->|"produce"| LOSS
    LOSS -->|"se deriva con"| CHAIN
    CHAIN -->|"asigna responsabilidad"| GRAD
    GRAD -->|"corrige"| UPDATE
    CHECK -->|"valida"| GRAD
    UPDATE -->|"nuevo forward"| FORWARD
    LOSS -->|"define objetivo para"| OPTI
    GRAD -->|"entrena"| CNNRNN
    GRAD -->|"actualiza pocos o muchos pesos en"| FINETUNE
    FINETUNE -->|"puede limitar gradientes a adaptadores"| LORA
    CHECK -->|"inspira observabilidad de"| EVAL

    style NEURONA stroke-dasharray: 5 5
    style RED stroke-dasharray: 5 5
    style DET stroke-dasharray: 5 5
    style OPTI stroke-dasharray: 5 5
    style CNNRNN stroke-dasharray: 5 5
    style FINETUNE stroke-dasharray: 5 5
    style LORA stroke-dasharray: 5 5
    style EVAL stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Retropropagación	Algoritmo que propaga el error desde la salida hacia las capas anteriores usando la regla de la cadena para calcular cómo ajustar cada parámetro.
Gradiente	Vector de derivadas parciales que indica cuánto cambia el error al modificar cada parámetro. Apunta en la dirección de máximo crecimiento.
Regla de la cadena	Propiedad del cálculo que permite derivar funciones compuestas: $\frac{\partial E}{\partial w} = \frac{\partial E}{\partial z} \cdot \frac{\partial z}{\partial w}$ .
Learning rate ( $\eta$ )	Tamaño del paso en la actualización de pesos. La dirección la marca el gradiente; $\eta$ controla la magnitud.
Pérdida (loss)	Medida numérica del error entre la predicción y la realidad. El objetivo del entrenamiento es minimizarla.
Derivada de la sigmoide	$\sigma'(z) = \sigma(z)(1 - \sigma(z)) = a(1-a)$ . Tiende a 0 en los extremos, causando desvanecimiento del gradiente.
Diferenciación automática	Técnica que calcula gradientes a partir del grafo de operaciones. PyTorch, TensorFlow y JAX la usan para implementar `backward()`.
Diferencias finitas	Aproximación numérica del gradiente perturbando un parámetro: $(E(w+\epsilon)-E(w-\epsilon))/(2\epsilon)$ . Sirve para comprobar derivadas.
Norma del gradiente	Medida del tamaño global de los gradientes. Ayuda a detectar gradientes demasiado pequeños, demasiado grandes o inestables.

Antes de pasar página

¿Puedo explicar los cuatro pasos del bucle de entrenamiento? (Si no, vuelve a «El bucle de entrenamiento».)
¿Entiendo qué significa cada símbolo de la tabla (x, w, b, z, a, y, E, η)? (Si no, vuelve a «La cadena completa».)
¿Puedo calcular a mano el forward pass y el backward pass para un ejemplo sencillo? (Si no, vuelve a «Forward pass» y «Backward pass».)
¿Sé por qué actualizamos con signo menos? (Si no, vuelve a «La actualización final».)
¿Puedo explicar qué es un gradient check por diferencias finitas? (Si no, vuelve a «Cómo se depura en ingeniería».)
¿He ejecutado kit descargable y puedo defender qué learning rate usaría? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
El entrenamiento es un bucle: predecir, medir el error, calcular gradientes, actualizar pesos.	Cuatro pasos que se repiten millones de veces. La retropropagación es el paso 3: cómo calcular los gradientes.
La regla de la cadena es la herramienta matemática que propaga el error hacia atrás.	$\partial E / \partial w = \partial E / \partial a \cdot \partial a / \partial z \cdot \partial z / \partial w$ . El error fluye de derecha a izquierda, atenuándose en cada activación.
El gradiente dice «dirección y sensibilidad». El learning rate dice «tamaño del paso».	$w \leftarrow w - \eta \cdot \partial E / \partial w$ . El signo menos va hacia el mínimo; $\eta$ controla la velocidad.
Un backward pass sano se puede comprobar.	Diferencias finitas, norma del gradiente y pérdida antes/después ayudan a distinguir fallo matemático, fallo de escala y fallo de configuración.
Sin retropropagación no hay deep learning.	Las redes de más de dos capas dependen de este algoritmo. Todo lo demás —arquitecturas, optimizadores, fine-tuning— son variaciones sobre este mismo tema.

Para saber más

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539

McCulloch, W. S. y Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. The Bulletin of Mathematical Biophysics, 5(4), 115-133. https://doi.org/10.1007/BF02478259

Nielsen, M. (2015). Neural networks and deep learning. http://neuralnetworksanddeeplearning.com

Rosenblatt, F. (1958). The perceptron: a probabilistic model for information storage and organization in the brain. Psychological Review, 65(6), 386-408. https://doi.org/10.1037/h0042519

Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Notas

Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0. Este artículo demostró que la retropropagación permitía entrenar redes con capas ocultas, resolviendo el problema que Minsky y Papert habían señalado en 1969 y abriendo la puerta al deep learning moderno. ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 6.2 aborda en detalle cómo las funciones de pérdida cuantifican el error y guían el aprendizaje mediante el gradiente. ↩
McCulloch, W. S. y Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. The Bulletin of Mathematical Biophysics, 5(4), 115-133. https://doi.org/10.1007/BF02478259. Este artículo fundacional estableció el modelo de neurona como unidad de cómputo con entradas ponderadas y umbral de activación, el ancestro conceptual de la neurona artificial moderna. ↩
LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539. Los autores explican cómo la derivada de la sigmoide $\sigma'(z) = a(1-a)$ tiende a cero en los extremos, causando el desvanecimiento del gradiente en redes profundas, y cómo ReLU mitiga este problema. ↩
Nielsen, M. (2015). Neural networks and deep learning. http://neuralnetworksanddeeplearning.com. El capítulo 2 explica la retropropagación desde cero con ejemplos detallados y código Python, incluyendo una implementación completa sin bibliotecas de deep learning. ↩

Capítulo 07

Facsímil 1 · Los cimientos

Capítulo 07: Funciones de pérdida y optimizadores

Entrando en el tema

En el capítulo anterior construiste el motor: la retropropagación. Sabe calcular gradientes. Sabe en qué dirección ajustar cada peso para reducir el error. Pero le faltan dos piezas para funcionar: qué error medir y cómo aplicar los ajustes.

La primera pieza es la función de pérdida: la regla que decide qué cuenta como «error». La segunda es el optimizador: el algoritmo que decide cómo traducir los gradientes en actualizaciones concretas de los pesos.

Elegir mal cualquiera de las dos es como tener un coche con un motor excelente pero sin volante o sin frenos. El motor hace su trabajo, pero el coche no va a ninguna parte.

Funciones de pérdida: cómo medir el error

Una función de pérdida toma dos cosas —la predicción del modelo y la respuesta real— y devuelve un número: el error.¹ Cuanto mayor es el número, peor es la predicción. El objetivo del entrenamiento es hacer ese número lo más pequeño posible.

Hay tres funciones que cubren la inmensa mayoría de casos prácticos:

Función	Se usa en	Qué mide
Cross-entropy	Clasificación, LLMs	Diferencia entre la distribución de probabilidad predicha y la real. Penaliza fuertemente las predicciones confiadas pero equivocadas.
MSE (error cuadrático medio)	Regresión	Media de los errores al cuadrado. Penaliza más los errores grandes que los pequeños (por el cuadrado).
Contrastive loss	Embeddings, búsqueda semántica	Acerca representaciones de ejemplos similares y aleja las de ejemplos diferentes.

Las fórmulas importan porque te dicen qué está castigando exactamente el entrenamiento:

Pérdida	Fórmula simplificada	Lectura
Binary cross-entropy	$-[y\log(p)+(1-y)\log(1-p)]$	Para una salida binaria $p$ . Castiga mucho estar seguro y equivocarse.
Cross-entropy multiclase	$-\log(p_y)$	Para $k$ clases. Solo mira la probabilidad asignada a la clase correcta.
MSE	$\frac{1}{n}\sum_i(\hat{y_i}-y_i)^2$	Para valores continuos. Los errores grandes pesan más por el cuadrado.
Contrastive / triplet	margen entre distancias	Para representaciones. No busca una clase: busca geometría útil en el espacio vectorial.

Ejemplo concreto: si la clase correcta es alta y el modelo le da probabilidad $p_y=0{,}01$ , la cross-entropy es $-\log(0{,}01)\approx4{,}61$ . Si le da $p_y=0{,}90$ , baja a $-\log(0{,}90)\approx0{,}105$ . No es una penalización lineal: fallar con mucha confianza duele mucho más. Por eso esta pérdida encaja tan bien con clasificación y predicción de siguiente token.

Cross-entropy es la reina indiscutible de la IA moderna. Cada vez que un LLM predice el siguiente token, está minimizando una cross-entropy entre la distribución que predice y la distribución real (que asigna probabilidad 1 al token correcto y 0 al resto).² Funciona especialmente bien porque su gradiente es proporcional a la diferencia entre la probabilidad predicha y la real: si el modelo asigna un 99 % de probabilidad al token correcto, el gradiente es pequeño (ya lo hace bien). Si asigna un 1 %, el gradiente es enorme (tiene mucho que aprender).

MSE es la elección natural cuando predices valores numéricos: el precio de una casa, la temperatura de mañana, los ingresos del próximo trimestre. El cuadrado en la fórmula ((predicción - realidad)²) hace que los errores grandes pesen mucho más que los pequeños: equivocarse por 100 es cien veces peor que equivocarse por 10, pero la penalización es diez mil veces mayor. Esto empuja al modelo a evitar errores graves a toda costa.

Contrastive loss no se usa para predecir, sino para representar. Su objetivo es que dos imágenes del mismo objeto tengan vectores de embedding cercanos, y dos imágenes de objetos distintos los tengan lejanos. Es la base de los sistemas de búsqueda por similitud y del aprendizaje de representaciones.

Optimizadores: cómo aplicar los ajustes

Una vez que la retropropagación ha calculado los gradientes, el optimizador decide cómo actualizar los pesos. La regla básica es siempre la misma:

w \leftarrow w - \eta \cdot \frac{\partial E}{\partial w}

Pero los optimizadores modernos añaden memoria estadística y adaptación a este proceso.³

Optimizador	Idea clave	Cuándo usarlo
SGD	Gradiente descendente con mini-lotes. El más simple.	Cuando necesitas control total sobre el learning rate y el momentum.
Adam	Learning rate adaptativo por parámetro. Funciona bien sin ajuste.	El estándar para la mayoría de tareas. Buen punto de partida.
AdamW	Adam + weight decay correcto (desacoplado).	El estándar para entrenar LLMs y Transformers.

SGD (Stochastic Gradient Descent) es el abuelo de todos los optimizadores. Actualiza los pesos en la dirección del gradiente, con un tamaño de paso fijo ( $\eta$ ). Es simple, funciona, pero requiere ajustar el learning rate con cuidado: si es muy alto, el entrenamiento diverge; si es muy bajo, tarda una eternidad.

Adam (Adaptive Moment Estimation) mantiene una estimación del momentum (media móvil de los gradientes pasados) y una estimación de la varianza. Con estas dos, adapta el learning rate para cada parámetro individualmente. Un parámetro que recibe gradientes grandes y consistentes recibe pasos grandes. Uno que recibe gradientes pequeños o ruidosos recibe pasos pequeños. Esto hace que Adam funcione sorprendentemente bien sin necesidad de ajustar el learning rate.

AdamW corrige un error sutil en la implementación original de Adam: la forma en que aplica la regularización weight decay. En Adam clásico, la weight decay está acoplada a la tasa de aprendizaje adaptativa, lo que reduce su efectividad.⁴ AdamW la desacopla, aplicando la regularización directamente a los pesos. Es el optimizador estándar para entrenar LLMs y Transformers.

Una forma práctica de leer los optimizadores:

Señal observada	Qué probar	Por qué
La pérdida baja, pero muy lenta	Subir un poco el learning rate o usar Adam/AdamW.	El paso puede ser demasiado pequeño.
La pérdida oscila o explota	Bajar el learning rate, aplicar gradient clipping o revisar escalado de datos.	Los pasos son demasiado grandes o los gradientes son inestables.
Entrenamiento mejora y validación empeora	Añadir weight decay, dropout, más datos o early stopping.	Hay sobreajuste: el modelo memoriza.
Las clases minoritarias fallan	Ponderar la pérdida, cambiar métrica o revisar muestreo.	La pérdida media puede esconder que una clase casi no aprende.
La regresión castiga demasiado valores extremos	Probar MAE, Huber o revisar outliers.	MSE amplifica mucho errores grandes.

Problemas comunes del entrenamiento

Incluso con la función de pérdida y el optimizador correctos, el entrenamiento puede fallar. Dos problemas aparecen una y otra vez:

Overfitting (sobreajuste). El modelo memoriza los datos de entrenamiento pero falla estrepitosamente con datos nuevos. Es como un estudiante que se aprende las respuestas del examen de memoria sin entender la materia: saca un 10 en el simulacro y suspende el examen real.⁵ Soluciones: dropout (apagar neuronas aleatoriamente durante el entrenamiento), regularización (penalizar pesos grandes), más datos (la mejor medicina), data augmentation (generar variaciones de los datos existentes).

Vanishing gradients (desvanecimiento del gradiente). En redes profundas, el gradiente puede hacerse tan pequeño en las primeras capas que dejan de aprender. Es como si el profesor susurrara la corrección al alumno de la última fila, y el mensaje se fuera atenuando fila a fila hasta que los de delante no oyen nada.⁶ Soluciones: ReLU en lugar de sigmoide (su gradiente es 1 para valores positivos), skip connections (atajos que permiten al gradiente saltar capas), batch normalization (normalizar las activaciones de cada capa).

El contrato mínimo de una run

Una run de entrenamiento no debería ser «he lanzado un modelo y ya veremos». Debería tener un contrato mínimo antes de empezar:

Elemento	Decisión	Ejemplo
Tarea	Clasificación binaria, multiclase, regresión o representación.	Priorizar tickets: multiclase.
Salida	Número de salidas y activación final.	3 clases → softmax.
Pérdida	Función que coincide con la tarea.	Cross-entropy multiclase.
Métrica	Qué miras para decidir si sirve.	F1 macro si hay desbalance; accuracy si las clases están equilibradas.
Optimizador	Algoritmo y sus hiperparámetros.	AdamW, `lr=1e-3`, `weight_decay=1e-2`.
Validación	Partición que no actualiza pesos.	80/20 estratificado o validación temporal si hay fechas.
Criterio de parada	Cuándo dejar de entrenar.	Parar si validación no mejora en 5 épocas.
Observabilidad	Qué registras por época.	Train loss, val loss, métrica, norma del gradiente, learning rate.

Este contrato es una defensa contra el autoengaño. Si cambias pérdida, métrica y partición cada vez que algo sale mal, no estás optimizando: estás persiguiendo resultados. Una run seria deja claro qué cuenta como mejora antes de mirar el resultado.

En el día a día

En la práctica, casi nunca eliges la función de pérdida desde cero. Los frameworks ya tienen las implementaciones optimizadas. Pero sí tomas decisiones que dependen de entenderlas:

¿Cross-entropy o MSE? Si tu tarea es clasificar (spam o no, gato o perro, siguiente token), usa cross-entropy. Si es predecir un número, usa MSE. Parece obvio, pero equivocarse es sorprendentemente común.
¿Qué optimizador? Empieza con Adam. Funciona en el 90 % de los casos. Si necesitas el último 10 % de rendimiento o estás entrenando un modelo desde cero, prueba AdamW.
¿Overfitting o underfitting? Si el error en entrenamiento es bajo pero en validación es alto, tienes overfitting: regulariza, añade dropout, consigue más datos. Si ambos son altos, tienes underfitting: tu modelo es demasiado simple o no has entrenado suficiente.

Por qué debería importarte

La función de pérdida es lo que le dices al modelo que quieres. No es un detalle técnico: es la especificación formal de tu objetivo.

Si usas MSE para clasificar, el modelo intentará minimizar la distancia numérica entre probabilidades, no maximizar la probabilidad de la clase correcta. Aprenderá algo, pero no lo que quieres. Si usas cross-entropy para regresión, el modelo asumirá que la salida es una distribución de probabilidad, no un valor continuo. Los resultados serán inconsistentes.

El optimizador, por su parte, determina si el modelo converge, a qué velocidad y a qué solución. Adam con un learning rate por defecto funciona en la mayoría de casos. Pero si tu modelo no converge, cambiar de optimizador o ajustar sus hiperparámetros puede ser la diferencia entre el éxito y el fracaso.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Usar MSE para clasificación	MSE asume errores continuos y simétricos. La clasificación necesita comparar distribuciones de probabilidad. MSE penaliza igual una predicción de 0,4 cuando la respuesta es 1 que una predicción de 0,9 cuando la respuesta es 0.	Cross-entropy para clasificación. Siempre.
No monitorizar la pérdida de validación	Si solo miras la pérdida de entrenamiento, no detectas el overfitting hasta que es demasiado tarde. La pérdida de entrenamiento siempre baja; la de validación es la que importa.	Separa un conjunto de validación y monitoriza ambas curvas. Si divergen, estás sobreajustando.
*Usar el learning rate* por defecto sin comprobarlo**	El valor por defecto de Adam (0,001) funciona en muchos casos, pero no en todos. Un learning rate demasiado alto hace que la pérdida oscile; uno demasiado bajo hace que el entrenamiento sea innecesariamente lento.	Prueba con 0,01, 0,001 y 0,0001. Observa la curva de pérdida: si oscila, baja el learning rate; si baja muy lentamente, súbelo.
Olvidar el weight decay	Sin regularización, los pesos pueden crecer descontroladamente, llevando a overfitting. AdamW incluye weight decay por defecto, pero SGD no.	Añade weight decay (típicamente 1e-4 a 1e-2). Observa si mejora la pérdida de validación.
Elegir métrica que contradice la pérdida	Puedes optimizar cross-entropy y celebrar accuracy mientras la clase minoritaria queda destrozada. La pérdida entrena; la métrica decide si te vale.	Define pérdida y métrica juntas. En desbalance, mira F1 macro, recall por clase o coste de error.
Comparar runs con particiones distintas	Si cada experimento usa otro split, no sabes si mejoró el modelo o si tuvo una validación más fácil.	Fija partición, semilla y protocolo antes de comparar optimizadores.

Manos a la obra

La práctica está en kit descargable. Entrena una regresión logística pequeña sin dependencias externas y compara combinaciones de pérdida y optimizador.

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/run_training_grid.py --write
cat output/training_decision.md

Y como práctica con validación:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

El kit incluye Makefile, requirements.txt y tests/test_training_grid.py. La prueba comprueba que cada run deja métricas de validación y que el grid compara optimizadores reales, no solo nombres en una tabla.

El kit genera un dataset sintético fijo, separa entrenamiento y validación, entrena varias configuraciones y produce un informe con pérdida, accuracy, F1, brecha train/validación y recomendación.

Comparación	Qué aprenderás	Por qué importa
BCE vs MSE	BCE suele entrenar mejor clasificación binaria.	La pérdida debe coincidir con la tarea.
SGD vs AdamW	AdamW suele ser más estable con menos ajuste manual.	El optimizador cambia velocidad y regularización.
Train vs validación	Detecta si mejoras de verdad o solo memorizas.	Sin validación no hay ingeniería, hay deseo.
Weight decay	Reduce pesos grandes y ayuda a generalizar.	Es una herramienta práctica contra sobreajuste.

No compares el número absoluto de BCE contra el número absoluto de MSE como si fueran la misma escala. Compáralas por comportamiento: métrica de validación, estabilidad de curva, calibración y coherencia con la tarea.

Cómo lo adaptas a tu caso. Cambia contracts/training_grid.json: número de épocas, learning rates, weight decay y configuraciones. El dataset sintético está dentro del script para que el resultado sea reproducible.

Qué entregaría un alumno. El Markdown generado, una configuración nueva, una explicación de por qué la pérdida elegida encaja con la tarea, el resultado de make test y una decisión explícita: qué run llevaría a una segunda iteración y cuál descartaría.

Cómo encaja todo

Este capítulo convierte el gradiente del capítulo 6 en una decisión de entrenamiento completa. La pérdida define qué significa fallar; el optimizador decide cómo moverse; la validación decide si esa mejora sirve fuera de los ejemplos que actualizan pesos.

También prepara una idea que volverá muchas veces: entrenar no es solo bajar una métrica interna. Es diseñar un contrato medible, ejecutarlo de forma reproducible y mirar si generaliza.

graph LR
    subgraph "Viene de antes"
        BACKPROP["Retropropagación\n(cap. 6)"]
        ARCH["Arquitectura y parámetros\n(cap. 5)"]
        DATA["Datos y etiquetas\n(cap. 3)"]
    end

    subgraph "Capítulo 7: contrato de entrenamiento"
        TASK["Tarea\nclasificación / regresión"]
        LOSS["Pérdida\nBCE / CE / MSE"]
        METRIC["Métrica\naccuracy / F1 / MAE"]
        OPT["Optimizador\nSGD / Adam / AdamW"]
        REG["Regularización\nweight decay / dropout"]
        VAL["Validación\ngeneralización"]
    end

    subgraph "Se reutiliza después"
        CNNRNN["CNN y RNN\n(cap. 8)"]
        TRAININF["Entrenar vs inferir\n(cap. 10)"]
        FINETUNE["Fine-tuning y LoRA\n(fasc. 4)"]
        EVALS["Evaluación de modelos\n(fasc. 6-7)"]
    end

    DATA -->|"define"| TASK
    TASK -->|"elige"| LOSS
    TASK -->|"elige"| METRIC
    ARCH -->|"aporta pesos a"| OPT
    BACKPROP -->|"entrega gradientes a"| OPT
    LOSS -->|"genera señal para"| BACKPROP
    OPT -->|"actualiza pesos y se controla con"| REG
    REG -->|"afecta a"| VAL
    METRIC -->|"se lee en"| VAL
    VAL -->|"decide si repetir, parar o cambiar"| OPT
    LOSS -->|"se especializa para"| CNNRNN
    OPT -->|"solo ocurre en"| TRAININF
    OPT -->|"fundamento de"| FINETUNE
    VAL -->|"se formaliza en"| EVALS

    style BACKPROP stroke-dasharray: 5 5
    style ARCH stroke-dasharray: 5 5
    style DATA stroke-dasharray: 5 5
    style CNNRNN stroke-dasharray: 5 5
    style FINETUNE stroke-dasharray: 5 5
    style TRAININF stroke-dasharray: 5 5
    style EVALS stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Función de pérdida	Función que mide el error entre la predicción y la realidad. El entrenamiento busca minimizarla.
Cross-entropy	Pérdida estándar para clasificación. Mide la diferencia entre la distribución predicha y la real.
MSE	Error cuadrático medio. Pérdida estándar para regresión. Penaliza fuertemente los errores grandes.
Optimizador	Algoritmo que actualiza los pesos a partir de los gradientes. Controla cómo y cuánto se ajusta cada parámetro.
Adam	Optimizador con learning rate adaptativo por parámetro. El más usado en la práctica.
AdamW	Variante de Adam con weight decay desacoplado. Es el estándar habitual para Transformers y muchos entrenamientos modernos.
Weight decay	Regularización que penaliza pesos grandes y ayuda a reducir sobreajuste.
Overfitting	El modelo memoriza los datos de entrenamiento pero no generaliza a datos nuevos.
Curva de validación	Evolución de pérdida o métrica en datos que no actualizan pesos. Permite detectar generalización, sobreajuste y parada temprana.
Early stopping	Detener el entrenamiento cuando la validación deja de mejorar durante varias épocas.

Antes de pasar página

¿Puedo explicar cuándo usar cross-entropy y cuándo MSE? (Si no, vuelve a la tabla de funciones de pérdida.)
¿Entiendo la diferencia entre SGD, Adam y AdamW? (Si no, vuelve a la sección de optimizadores.)
¿Sé qué es el overfitting y cómo combatirlo? (Si no, vuelve a «Problemas comunes».)
¿Puedo escribir el contrato mínimo de una run antes de entrenar? (Si no, vuelve a «El contrato mínimo de una run».)
¿He ejecutado kit descargable y comparado BCE, MSE, SGD y AdamW? (Si no, vuelve a «Manos a la obra».)
¿Entiendo por qué el learning rate no puede ser ni muy alto ni muy bajo? (Si no, vuelve a «Dónde solía tropezar yo».)

En resumen

Idea fuerza	Detalle
La función de pérdida define qué significa «equivocarse».	Cross-entropy para clasificar, MSE para regresión, contrastive para representaciones. Elegir mal la pérdida es pedirle al modelo que optimice lo incorrecto.
El optimizador decide cómo aplicar los gradientes.	SGD es simple pero necesita ajuste. Adam es adaptativo y funciona en la mayoría de casos. AdamW es el estándar para Transformers.
El overfitting y el vanishing gradient son los dos grandes enemigos.	Monitoriza la pérdida de validación, usa dropout y regularización, y elige bien tus funciones de activación.
Una run necesita contrato antes de empezar.	Tarea, salida, pérdida, métrica, optimizador, validación y criterio de parada deben estar definidos antes de mirar resultados.

Para saber más

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

Kingma, D. P. y Ba, J. (2015). Adam: a method for stochastic optimization. En International Conference on Learning Representations. https://arxiv.org/abs/1412.6980

LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539

Loshchilov, I. y Hutter, F. (2019). Decoupled weight decay regularization. En International Conference on Learning Representations. https://arxiv.org/abs/1711.05101

Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I. y Salakhutdinov, R. (2014). Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1), 1929-1958. http://jmlr.org/papers/v15/srivastava14a.html

Notas

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 6.2 aborda en profundidad las funciones de pérdida, su relación con la estimación de máxima verosimilitud y cómo la elección de la función de pérdida determina lo que el modelo aprende. ↩
Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0. Aunque el artículo se centra en la retropropagación con MSE, establece el marco general donde cualquier función de pérdida diferenciable puede usarse para entrenar redes multicapa. ↩
Kingma, D. P. y Ba, J. (2015). Adam: a method for stochastic optimization. En International Conference on Learning Representations. https://arxiv.org/abs/1412.6980. Kingma y Ba presentaron Adam, que combina las ventajas de AdaGrad (tasas de aprendizaje adaptativas) y RMSProp (media móvil del gradiente), convirtiéndose en el optimizador por defecto para la mayoría de aplicaciones de deep learning. ↩
Loshchilov, I. y Hutter, F. (2019). Decoupled weight decay regularization. En International Conference on Learning Representations. https://arxiv.org/abs/1711.05101. Los autores demostraron que desacoplar la weight decay de la actualización del gradiente en Adam mejora significativamente la generalización. ↩
Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I. y Salakhutdinov, R. (2014). Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1), 1929-1958. http://jmlr.org/papers/v15/srivastava14a.html. El dropout —desactivar aleatoriamente neuronas durante el entrenamiento— es una de las técnicas más efectivas para prevenir el overfitting. ↩
LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539. Los autores explican cómo las funciones de activación como ReLU y las arquitecturas con conexiones residuales mitigan el problema del desvanecimiento del gradiente. ↩

Capítulo 08

Facsímil 1 · Los cimientos

Capítulo 08: CNNs y RNNs: redes para visión y secuencias

Entrando en el tema

Hasta ahora hemos hablado de redes neuronales en abstracto: capas que se conectan con capas, neuronas que reciben entradas y producen salidas. Esa arquitectura genérica —el MLP— funciona para muchos problemas, pero tiene un punto débil: trata todos los datos como una lista plana de números, sin aprovechar su estructura.

Una imagen no es una lista plana. Es una rejilla de píxeles donde lo que importa son los patrones locales: un ojo está rodeado de ceja y párpado, no de píxeles aleatorios dispersos por la imagen. Un texto no es una lista plana. Es una secuencia donde el significado de una palabra depende de las que vinieron antes y de las que vendrán después.

Dos arquitecturas nacieron para resolver estos dos problemas. Las CNNs para la visión. Las RNNs para las secuencias. Y aunque los Transformers las han desplazado parcialmente, entenderlas es entender por qué el Transformer fue revolucionario.

CNNs: cómo ve una máquina

Una Convolutional Neural Network (CNN) no mira una imagen píxel a píxel. Aplica filtros: pequeñas matrices (3×3, 5×5) que se deslizan por la imagen detectando patrones locales.¹

Piensa en un filtro como una plantilla. Un filtro que detecta bordes horizontales tiene valores positivos arriba y negativos abajo. Cuando se desliza sobre una zona de la imagen donde hay un borde horizontal, produce un valor alto. Cuando pasa por una zona uniforme, produce un valor cercano a cero.

El flujo de una CNN es:

Imagen → Convoluciones → Pooling → Más convoluciones → Pooling → Clasificación

Convolución. El corazón de la CNN. Un filtro pequeño se desliza por toda la imagen. En cada posición, multiplica sus valores por los píxeles correspondientes y suma el resultado. Una capa convolucional típica tiene decenas o cientos de filtros, cada uno especializado en detectar un patrón distinto: bordes verticales, esquinas, texturas, colores específicos.²

Veamos un ejemplo concreto. Imagina una imagen de 5×5 píxeles en escala de grises y un filtro de 3×3 que detecta bordes verticales:

Imagen 5x5:       Filtro 3x3 (borde vertical):
 1  1  1  0  0      -1   0   1
 1  1  1  0  0      -1   0   1
 1  1  1  0  0      -1   0   1
 1  1  1  0  0
 1  1  1  0  0

El filtro se coloca en la esquina superior izquierda y multiplica elemento a elemento: (-1×1 + 0×1 + 1×1) + (-1×1 + 0×1 + 1×1) + (-1×1 + 0×1 + 1×1) = 0 + 0 + 0 = 0. En esa zona no hay borde vertical: todo son unos.

Ahora deslizamos el filtro a la derecha, donde están los ceros. En la zona de transición entre unos y ceros: (-1×1 + 0×1 + 1×0) + (-1×1 + 0×1 + 1×0) + (-1×1 + 0×1 + 1×0) = (-1) + (-1) + (-1) = -3. El valor absoluto alto indica un borde vertical.

Esto es lo que hacen decenas de filtros en paralelo, cada uno especializado en un patrón distinto. La red aprende los valores del filtro durante el entrenamiento: no los programa una persona, los descubre la retropropagación.

Pooling. Reduce la resolución espacial manteniendo la información importante. La operación más común es max pooling: divide la imagen en zonas (por ejemplo, 2×2) y se queda solo con el valor máximo de cada zona. Esto hace la red más eficiente (menos píxeles que procesar) y más robusta (invariante a pequeños desplazamientos: si el gato se mueve dos píxeles a la derecha, el max pooling probablemente siga detectándolo).

De patrones simples a conceptos. Las primeras capas detectan bordes y colores. Las capas intermedias combinan bordes en formas y texturas. Las capas profundas reconocen objetos: ojos, ruedas, letras. Es la misma jerarquía que vimos en el capítulo 5, pero especializada para datos visuales.

Skip connections (ResNet). En 2015, ResNet introdujo una idea simple pero revolucionaria: atajos que permiten a la información saltarse capas.³ En lugar de aprender la transformación completa, la capa aprende el «residuo»: la diferencia entre la entrada y la salida deseada. Si la transformación óptima es no hacer nada (la identidad), la capa puede aprender pesos cercanos a cero. Esto resolvió el problema de entrenar redes muy profundas y permitió arquitecturas de más de cien capas.

Relevancia actual. Las CNNs siguen siendo muy importantes en visión por computador porque aprovechan una estructura real de las imágenes: píxeles cercanos suelen estar relacionados. Ese sesgo inductivo las hace eficientes en detección, segmentación, clasificación y despliegues edge. Pero ya no son la única familia fuerte: los Vision Transformers tratan una imagen como parches y usan atención, y han demostrado que con suficientes datos y cómputo pueden competir o superar a las CNNs en muchas tareas.⁴ En generación de imágenes, además, conviven U-Nets convolucionales y modelos de difusión basados en Transformers, como DiT.⁵ La decisión de ingeniería no es “CNN vieja, Transformer nuevo”, sino qué estructura de datos, coste, volumen de entrenamiento y latencia tienes.

RNNs y LSTMs: cómo procesar secuencias

Antes de los Transformers, si querías que una red procesara texto, audio o series temporales, usabas una Recurrent Neural Network (RNN). Su idea es elegante: procesar la secuencia elemento a elemento, manteniendo un estado oculto que resume todo lo visto hasta ahora.⁶

Token 1 → RNN (estado oculto) → Token 2 + estado → RNN (actualiza estado) → Token 3 + estado...

Cuando la RNN lee la palabra «El», actualiza su estado oculto para reflejar que ha visto un artículo. Cuando lee «gato», el estado ahora codifica «El gato». Cuando llega a «es», el estado refleja «El gato es». Y así, token a token, el estado oculto acumula el contexto de toda la secuencia.

El problema es la memoria. Cuando llegas al token 500, el estado oculto ya ha sido sobrescrito cientos de veces. La información del token 1 se ha diluido hasta desaparecer. Es como el juego del teléfono: el mensaje se degrada con cada transmisión.⁷

LSTM: memoria con compuertas

La Long Short-Term Memory (LSTM) resuelve este problema con un mecanismo ingenioso: compuertas. En lugar de un solo estado oculto que se sobrescribe, la LSTM tiene:

Una compuerta de olvido: decide qué información antigua descartar.
Una compuerta de entrada: decide qué información nueva almacenar.
Una compuerta de salida: decide qué parte del estado actual exponer como salida.

Estas compuertas son pequeñas redes neuronales que aprenden cuándo abrir y cuándo cerrar. Si el modelo encuentra una palabra clave al principio de un documento que será relevante quinientos tokens después, la compuerta de olvido puede decidir conservarla. Si encuentra información irrelevante, la descarta.

Gracias a las LSTMs, las RNNs pudieron capturar dependencias bastante más largas que una RNN simple. No conviene convertir esto en una cifra universal: que un modelo recuerde 100, 500 o más pasos depende de datos, arquitectura, tamaño del estado, entrenamiento y tarea. Lo importante es la forma del límite: la información tiene que pasar por una cadena temporal, y cada paso puede degradar la señal.

GRU: la hermana pequeña de la LSTM

La Gated Recurrent Unit (GRU), presentada en 2014, simplifica la LSTM: tiene solo dos compuertas (reinicio y actualización) en lugar de tres, y fusiona el estado oculto con la memoria de largo plazo en un solo vector.⁸ Con menos parámetros que la LSTM, la GRU entrena más rápido y a menudo rinde igual de bien. Es la opción preferida cuando los recursos son limitados o cuando la LSTM no aporta una mejora significativa.

Bidireccional: mirar al pasado y al futuro

Una RNN estándar solo ve el pasado: cuando procesa la palabra 5, conoce las palabras 1 a 4 pero no tiene ni idea de lo que vendrá en la 6. Para muchas tareas —como etiquetar categorías gramaticales o traducir— el contexto futuro es tan importante como el pasado.

Las RNNs bidireccionales resuelven esto con dos RNNs en paralelo: una procesa la secuencia de izquierda a derecha y la otra de derecha a izquierda. Sus estados ocultos se concatenan, dando a cada posición acceso tanto al contexto anterior como al posterior. Son más caras computacionalmente pero notablemente más precisas en tareas donde el contexto completo importa.

El gradiente en las RNNs: un problema amplificado

El desvanecimiento del gradiente es especialmente dañino en las RNNs. En una red feedforward de 10 capas, el gradiente se atenúa 10 veces. En una RNN que procesa 100 tokens, el gradiente se atenúa 100 veces —porque la red se despliega en el tiempo y cada paso temporal equivale a una capa—. Es como si tuvieras una red de 100 capas, pero donde todas comparten los mismos pesos. Cada paso hacia atrás en el tiempo multiplica el gradiente por la misma matriz de pesos. Si los valores propios de esa matriz son menores que 1, el gradiente se desvanece exponencialmente. Si son mayores que 1, explota, produciendo actualizaciones caóticas.

Las LSTMs y GRUs mitigan esto con sus compuertas, que permiten que el gradiente fluya a través del estado de memoria con menos atenuación. Pero no eliminan el cuello de botella: la información sigue viajando paso a paso. Para secuencias muy largas, muchas tareas dejaron de intentar “mejorar la memoria recurrente” y pasaron a usar atención, recuperación o arquitecturas híbridas. Eso es exactamente lo que hizo el Transformer para lenguaje.

RNN vs LSTM vs Transformer

Característica	RNN	LSTM	Transformer
Procesamiento	Secuencial	Secuencial	Paralelo
Memoria/contexto práctico	Limitada por estado oculto y gradiente	Mejor que RNN simple, pero sigue siendo secuencial	Ventana explícita de atención; su tamaño depende del modelo y del coste
Paralelizable	No	No	Sí (aprovecha GPUs)
Velocidad	Lenta	Lenta	Rápida

El Transformer ganó por dos razones.⁹ Primero, paralelismo: mira todos los tokens de una ventana a la vez. Una RNN tiene que procesar el token 1 antes que el 2, y el 2 antes que el 3. Un Transformer procesa la ventana simultáneamente, aprovechando GPUs masivamente paralelas. Segundo, atención directa: en lugar de comprimir todo el contexto en un estado oculto de tamaño fijo, cada token puede «mirar» directamente a cualquier otro token de la ventana. Si la palabra 500 necesita información de la palabra 1, la atención le da un camino directo. Ese camino no es gratis: la atención estándar crece de forma cuadrática con la longitud de la ventana, por eso los contextos largos requieren ingeniería adicional.

En el día a día

Aunque los Transformers dominan el procesamiento de lenguaje, las CNNs y RNNs siguen siendo relevantes:

CNNs en visión. Si necesitas clasificar imágenes, detectar objetos o segmentar con poco dato, poco cómputo o despliegue en dispositivo, una CNN sigue siendo una primera candidata razonable. Si tienes muchos datos, infraestructura y quieres unificar visión con lenguaje o atención global, ViT entra en la conversación.
CNNs, U-Nets y DiT en generación de imágenes. La generación moderna mezcla familias: U-Nets convolucionales han sido centrales en difusión, y los Transformers aparecen en arquitecturas como DiT. Cuando generas una imagen con IA, no asumas una sola arquitectura: mira el modelo concreto.
LSTMs en series temporales. Para predicción de ventas, mantenimiento predictivo, análisis de señales, las LSTMs siguen siendo competitivas. No necesitas un Transformer de mil millones de parámetros para predecir la demanda de mañana.
RNNs en dispositivos pequeños. Una RNN simple consume mucha menos memoria y computación que un Transformer. En un microcontrolador o un dispositivo edge, una RNN puede ser la única opción viable.

Por qué debería importarte

Estas arquitecturas no son reliquias históricas que estudias por cultura general. Son las piezas que explican por qué los Transformers son como son.

Cada decisión de diseño del Transformer es una respuesta a una limitación de las RNNs. La atención existe porque el estado oculto de una RNN no bastaba para contexto largo. El paralelismo existe porque el procesamiento secuencial era demasiado lento. La capacidad de mirar posiciones lejanas dentro de una ventana explícita existe porque las LSTMs, incluso con compuertas, seguían obligando a que la información viajara paso a paso por la secuencia.

Entender de dónde venimos es entender hacia dónde vamos. Y en ingeniería, a veces la herramienta adecuada no es la más moderna, sino la que mejor se adapta a tus restricciones de recursos.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Usar un Transformer para todo	Para una serie temporal de 100 puntos, una LSTM puede ser más rápida, más barata e igual de precisa que un Transformer. Usar la arquitectura más grande no siempre mejora la decisión.	Evalúa la complejidad de tu problema antes de elegir la arquitectura. Si es secuencial y corto, prueba RNN/LSTM primero.
Aplicar CNNs a datos no espaciales	Las CNNs asumen que los datos tienen estructura local (píxeles cercanos están relacionados). Aplicarlas a datos tabulares donde las columnas no tienen orden espacial no aporta ventajas sobre un MLP.	CNNs para imágenes y datos con estructura de rejilla. MLPs para datos tabulares. Transformers para secuencias largas.
Ignorar el preprocesamiento en CNNs	Una CNN espera imágenes de un tamaño fijo. Si le pasas imágenes de tamaños variados sin redimensionar, los resultados serán inconsistentes.	Normaliza el tamaño de las imágenes, escala los valores de píxel a [0,1] o [-1,1] y aplica data augmentation durante el entrenamiento.
Asumir que las RNNs «entienden» el orden	Las RNNs procesan en orden, pero eso no garantiza que capturen dependencias a largo plazo. Una RNN simple puede fallar en capturar que la primera palabra de un párrafo es el sujeto de la última oración.	Si necesitas dependencias a largo plazo, usa LSTMs, GRUs o, directamente, Transformers.

Manos a la obra

La práctica de este capítulo está en kit descargable. El ejercicio no consiste en entrenar una CNN o una LSTM por entrenarlas. Consiste en hacer lo que debería hacerse antes de abrir un notebook: mirar la forma de los datos, estimar el coste de cada familia y justificar una primera arquitectura.

El kit trae cuatro casos: una inspección visual de piezas, una serie temporal de sensores, clasificación de tickets cortos y revisión de contratos largos. Para cada caso calcula señales útiles: parámetros aproximados de una primera convolución, coste de una LSTM, coste cuadrático de atención y riesgos de datos o latencia.

Archivo	Qué contiene
`Makefile`	Atajos para ejecutar, probar y limpiar.
`requirements.txt`	Declara que el kit usa solo Python estándar.
`data/problem_cases.json`	Casos con tipo de entrada, tamaño, ejemplos, latencia y despliegue.
`contracts/architecture_policy.json`	Umbrales y supuestos: filtros, tamaño oculto, `d_model` y límite de atención.
`ops/audit_architecture_triage.py`	Auditor de arquitectura sin dependencias externas.
`tests/test_architecture_triage.py`	Comprueba que la recomendación incluye señales de coste y arquitectura.
`output/architecture_triage_report.json`	Resultado estructurado por caso.
`output/architecture_triage_decision.md`	Informe que puedes entregar o discutir.

Ejecuta:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/audit_architecture_triage.py --write
cat output/architecture_triage_decision.md

Comprueba que el kit completo sigue sano:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

Después añade un quinto caso propio. Por ejemplo: audio corto de una máquina, imágenes médicas pequeñas, logs de una aplicación o textos legales de 30 páginas. No empieces escribiendo «usaría un Transformer». Escribe primero la forma de la entrada, el volumen de ejemplos, la latencia objetivo y qué error sería caro. La arquitectura tiene que salir de esas restricciones.

Qué entregaría un alumno. El Markdown generado, un caso propio añadido al JSON, el resultado de make test, una recomendación de arquitectura y una decisión explícita: entrenar, simplificar, cambiar de familia o recoger más datos antes.

Para explorar visualmente después de ejecutar el kit, merece la pena abrir CNN Explainer y observar cómo cambian los feature maps de una capa a otra. También puedes revisar Stanford CS231n si quieres profundizar en visión por computador.

Cómo encaja todo

Este mapa se lee como una decisión de arquitectura, no como una línea histórica. Venimos de redes, gradientes y capas; aquí aprendemos que la forma del dato importa. Si la estructura es espacial, una CNN aprovecha vecindarios. Si la estructura es temporal, una RNN o LSTM arrastra estado. Si la secuencia es larga, necesitamos atención, recuperación o arquitecturas híbridas.

La decisión que enseña el capítulo no es memorizar siglas, sino justificar una familia por contrato de datos, coste y despliegue. Esa misma forma de pensar reaparece cuando elijas embeddings, modelos locales, RAG o arquitecturas de Transformer.

graph LR
    subgraph "Hereda de F1"
        RED["Redes neuronales\n(cap. 5)"]
        BACKPROP["Retropropagación\n(cap. 6)"]
        LOSS["Pérdida y validación\n(cap. 7)"]
    end

    subgraph "Capítulo 8: decisión de arquitectura"
        SHAPE["Forma del dato"]
        CNN["CNN\nrejilla espacial"]
        CONV["Convolución\nfiltro local"]
        RNN["RNN / LSTM\nsecuencia temporal"]
        STATE["Estado oculto\ny compuertas"]
        ATT["Atención\nrelación directa"]
    end

    subgraph "Se reutiliza después"
        TOKEN["Tokens y embeddings\n(cap. 9)"]
        TRANSFORMER["Transformer\n(fasc. 3)"]
        RAG["RAG y contexto\n(fasc. 4)"]
        DEPLOY["Coste, latencia y despliegue\n(fasc. 6)"]
    end

    RED -->|"se especializa según"| SHAPE
    BACKPROP -->|"entrena"| CNN
    BACKPROP -->|"también entrena"| RNN
    LOSS -->|"mide si generaliza"| SHAPE
    SHAPE -->|"si hay vecindario espacial"| CNN
    CNN -->|"aprende mediante"| CONV
    SHAPE -->|"si hay orden temporal"| RNN
    RNN -->|"resume con"| STATE
    STATE -->|"limita contexto largo y motiva"| ATT
    ATT -->|"se convierte en"| TRANSFORMER
    TOKEN -->|"define la secuencia que mira"| TRANSFORMER
    TRANSFORMER -->|"se combina con"| RAG
    SHAPE -->|"también condiciona"| DEPLOY

    style RED stroke-dasharray: 5 5
    style BACKPROP stroke-dasharray: 5 5
    style LOSS stroke-dasharray: 5 5
    style TOKEN stroke-dasharray: 5 5
    style TRANSFORMER stroke-dasharray: 5 5
    style RAG stroke-dasharray: 5 5
    style DEPLOY stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
CNN	Red neuronal convolucional. Usa filtros que se deslizan por la entrada para detectar patrones locales. Especializada en imágenes y datos con estructura de rejilla.
Convolución	Operación que aplica un filtro sobre una entrada, deslizándolo por todas las posiciones y calculando la similitud en cada punto.
Pooling	Operación que reduce la resolución espacial manteniendo la información relevante. Max pooling toma el valor máximo de cada zona.
RNN	Red neuronal recurrente. Procesa secuencias elemento a elemento, manteniendo un estado oculto que resume el contexto previo.
LSTM	Variante de RNN con compuertas de olvido, entrada y salida. Permite aprender dependencias a más largo plazo que una RNN simple.
Estado oculto	Vector que resume la información de todos los elementos anteriores de una secuencia en una RNN.

Antes de pasar página

¿Puedo explicar cómo una CNN detecta patrones en una imagen? (Si no, vuelve a «CNNs: cómo ve una máquina».)
¿Entiendo qué hace el pooling y por qué es útil? (Si no, vuelve a la sección de CNNs.)
¿Sé cómo procesa una RNN una secuencia y cuál es su principal limitación? (Si no, vuelve a «RNNs y LSTMs».)
¿Puedo explicar por qué el Transformer superó a las RNNs? (Si no, vuelve a la tabla comparativa.)
¿He ejecutado kit descargable y puedo justificar una arquitectura por forma de datos, coste y despliegue? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
Las CNNs detectan patrones locales en imágenes mediante filtros que se deslizan por la entrada.	De bordes en las primeras capas a objetos completos en las profundas. Pooling reduce dimensionalidad y añade invarianza.
Las RNNs procesan secuencias manteniendo un estado oculto. Las LSTMs añaden compuertas para recordar a más largo plazo.	Mejoran el problema, pero siguen comprimiendo historia en estado recurrente y procesando paso a paso.
El Transformer ganó por paralelismo y atención directa.	Procesa una ventana completa a la vez y permite que cualquier token mire directamente a otro dentro de esa ventana, pagando coste de memoria y cómputo.

Para saber más

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani, M., Minderer, M., Heigold, G., Gelly, S., Uszkoreit, J. y Houlsby, N. (2021). An image is worth 16x16 words: Transformers for image recognition at scale. En International Conference on Learning Representations. https://openreview.net/forum?id=YicbFdNTTy

Hochreiter, S. y Schmidhuber, J. (1997). Long short-term memory. Neural Computation, 9(8), 1735-1780. https://doi.org/10.1162/neco.1997.9.8.1735

LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539

Peebles, W. y Xie, S. (2023). Scalable diffusion models with Transformers. En Proceedings of the IEEE/CVF International Conference on Computer Vision (pp. 4195-4205). https://doi.org/10.1109/ICCV51070.2023.00387

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Notas

Krizhevsky, A., Sutskever, I. y Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. En Advances in Neural Information Processing Systems 25 (pp. 1097-1105). https://papers.nips.cc/paper/4824. AlexNet demostró que las CNNs profundas, entrenadas con GPUs, podían superar ampliamente a los métodos tradicionales de visión por computador, iniciando la revolución del deep learning en visión. ↩
LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539. Los autores describen cómo las capas convolucionales aprenden jerarquías de características visuales, desde bordes simples en las primeras capas hasta objetos complejos en las profundas. ↩
He, K., Zhang, X., Ren, S. y Sun, J. (2016). Deep residual learning for image recognition. En Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 770-778). https://doi.org/10.1109/CVPR.2016.90. Las conexiones residuales permiten entrenar redes de más de cien capas sin degradación del rendimiento, resolviendo el problema del desvanecimiento del gradiente en arquitecturas muy profundas. ↩
Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani, M., Minderer, M., Heigold, G., Gelly, S., Uszkoreit, J. y Houlsby, N. (2021). An image is worth 16x16 words: Transformers for image recognition at scale. En International Conference on Learning Representations. https://openreview.net/forum?id=YicbFdNTTy. El trabajo popularizó ViT: dividir una imagen en parches y procesarlos con un Transformer. ↩
Peebles, W. y Xie, S. (2023). Scalable diffusion models with Transformers. En Proceedings of the IEEE/CVF International Conference on Computer Vision (pp. 4195-4205). https://doi.org/10.1109/ICCV51070.2023.00387. DiT muestra cómo sustituir bloques U-Net por Transformers escalables en modelos de difusión. ↩
Hochreiter, S. y Schmidhuber, J. (1997). Long short-term memory. Neural Computation, 9(8), 1735-1780. https://doi.org/10.1162/neco.1997.9.8.1735. Hochreiter y Schmidhuber introdujeron la LSTM para resolver el problema del desvanecimiento del gradiente en RNNs, permitiendo que las redes recurrentes aprendieran dependencias a largo plazo por primera vez. ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 10 aborda en detalle las RNNs, el problema del desvanecimiento del gradiente en secuencias largas y las arquitecturas con compuertas como LSTM y GRU. ↩
Cho, K., van Merriënboer, B., Gulcehre, C., Bahdanau, D., Bougares, F., Schwenk, H. y Bengio, Y. (2014). Learning phrase representations using RNN encoder-decoder for statistical machine translation. En Proceedings of EMNLP (pp. 1724-1734). https://doi.org/10.3115/v1/D14-1179. La GRU fue introducida como una alternativa más simple y computacionalmente eficiente a la LSTM, con rendimiento comparable en muchas tareas. ↩
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł. y Polosukhin, I. (2017). Attention is all you need. En Advances in Neural Information Processing Systems 30 (pp. 5998-6008). https://papers.nips.cc/paper/7181-attention-is-all-you-need. Los autores demostraron que eliminar la recurrencia y usar solo atención permitía entrenar modelos más rápido (por el paralelismo) y con mejor calidad (por la capacidad de atender a cualquier posición de la secuencia). ↩

Capítulo 09

Facsímil 1 · Los cimientos

Capítulo 09: Del token al embedding: cómo el modelo representa lenguaje

Entrando en el tema

Escribes «Hola, ¿cómo estás?» y pulsas Enviar. Para ti son cuatro palabras, un signo de interrogación y una intención. Para el modelo, son números. Solo números.

Este capítulo explica el viaje que transforma tu texto en algo que una red neuronal puede procesar. Tiene dos etapas: la tokenización (trocear el texto en unidades procesables) y el embedding (convertir cada unidad en un vector de números que representa regularidades semánticas y de uso). Si el capítulo 4 fue el átomo (la neurona) y el capítulo 5 la molécula (la red), este capítulo es el sistema de coordenadas que permite operar con lenguaje sin que el modelo vea letras como las vemos nosotros.

Qué es un token

Un token es la unidad mínima que el modelo procesa. No es una palabra, aunque a veces coincide. No es un carácter, aunque a veces también. Es lo que el tokenizador —un programa que trocea texto— decide que es la unidad óptima para ese modelo.¹

Algunos ejemplos con un tokenizador típico:

"Hola mundo"       → ["Hola", " mundo"]           (2 tokens)
"desarrolladores"  → ["des", "arrol", "ladores"]   (3 tokens)
"function get()"   → ["function", " get", "()"]   (3 tokens)

Observa tres cosas. Primero, los espacios importan: «mundo» y « mundo» son tokens distintos. El espacio indica que la palabra empieza tras otra. Segundo, las palabras largas o poco frecuentes se trocean en subtokens: «desarrolladores» se divide en tres piezas que el modelo puede recombinar. Tercero, el código se tokeniza de forma distinta al lenguaje natural: los paréntesis, llaves y operadores son tokens independientes.

El modelo no ve texto. Ve secuencias de números (IDs de token). Cada token tiene un identificador único en el vocabulario del modelo —típicamente entre 50 000 y 250 000 tokens distintos—. Cuando escribes «Hola mundo», el modelo recibe algo como [15496, 2159]. Nunca ve las letras.

Todo se mide en tokens. La ventana de contexto (cuánto texto puede procesar el modelo de una vez), el precio de la API, el límite de respuesta: todo se mide en tokens. Es la moneda de la IA generativa.

Cómo funciona la tokenización (BPE)

El algoritmo más usado se llama Byte Pair Encoding (BPE).² Funciona así:

Empieza con un vocabulario de caracteres individuales (a, b, c, ..., espacio, etc.).
Recorre todo el texto de entrenamiento y encuentra el par de tokens consecutivos más frecuente.
Fusiona ese par en un nuevo token y lo añade al vocabulario.
Repite miles de veces.

El resultado es un vocabulario donde las palabras muy frecuentes («el», «de», «y») son tokens únicos, mientras que las palabras raras o largas se descomponen en subtokens. «Desarrolladores» acaba siendo «des» + «arrol» + «ladores» porque esos fragmentos aparecen en muchas otras palabras («desarrollo», «arrollar», «desarrollado»). Es un equilibrio ingenioso: el vocabulario es manejable (50k-250k tokens) pero puede representar cualquier palabra.

El español gasta más tokens que el inglés. Como regla aproximada, un token equivale a 3-4 caracteres en texto latino. Pero el español, con sus tildes, sus conjugaciones verbales y sus palabras más largas, tiende a consumir más tokens que el inglés para expresar lo mismo. «Machine learning is great» son 4 tokens; «El aprendizaje automático es genial» son 7-8.

Qué es un embedding

Una vez que el texto se ha convertido en tokens, cada token necesita una representación numérica que la red pueda procesar. Esa representación es el embedding: un vector denso de números reales —típicamente entre 768 y 4096 dimensiones— que captura el significado del token en el contexto del modelo.³

«Denso» significa que casi todas las dimensiones tienen valores distintos de cero. Un vector sparse (disperso) tendría muchos ceros y unas pocas dimensiones activas. Un embedding es denso: cada dimensión contribuye un poco al significado global.

Las dimensiones no tienen etiquetas. No hay una dimensión que signifique «animalidad» y otra que signifique «tamaño». Cada dimensión es una coordenada en un espacio de alta dimensionalidad, y el significado emerge de la posición relativa del vector completo. Es como preguntar «¿qué significa la coordenada X = 0,23 en un mapa?». Nada por sí sola. Pero combinada con Y = -0,87 y las otras 1534 dimensiones, sitúa «gato» cerca de «felino» y lejos de «JavaScript».

"gato"       → [0.23, -0.87, 0.45, 0.12, ...]  (1536 dimensiones)
"felino"     → [0.21, -0.85, 0.48, 0.11, ...]  (muy cercano a "gato")
"JavaScript" → [-0.56, 0.33, -0.12, 0.78, ...] (completamente distinto)

Piensa en un mapa donde las palabras se colocan según su significado. «Perro» y «gato» están cerca (ambos son animales domésticos). «Python» y «JavaScript» están cerca (ambos son lenguajes de programación). Pero «perro» y «Python» están lejos. El embedding es la coordenada de cada palabra en ese mapa de miles de dimensiones.⁴

Embeddings en la práctica

Aritmética de significado

Una propiedad fascinante de los embeddings es que las relaciones semánticas a veces se expresan como operaciones vectoriales. Si el espacio de embeddings captura consistentemente las dimensiones de significado, las direcciones en ese espacio codifican relaciones:

rey - hombre + mujer ≈ reina
Madrid - España + Francia ≈ París

Estas analogías, popularizadas por Word2Vec,⁵ son ilustrativas, no garantizadas. Un embedding moderno no siempre produce estas operaciones limpiamente, pero el principio subyacente —que la dirección en el espacio codifica relaciones— es real y es la base de la búsqueda semántica.

Similitud semántica

La medida estándar para comparar embeddings es la similitud coseno: el coseno del ángulo entre dos vectores. Vale 1 si apuntan exactamente en la misma dirección (idénticos), 0 si son perpendiculares (sin relación) y -1 si son opuestos.

Par de palabras	Similitud	Interpretación
«gato» / «felino»	Alta (~0.95)	Cuasi-sinónimos
«gato» / «perro»	Media (~0.75)	Misma categoría
«gato» / «coche»	Baja (~0.15)	Sin relación
«deploy» / «desplegar»	Alta (~0.90)	Traducción (modelo multilingüe)

La clave: conceptos similares quedan cerca en el espacio vectorial. Esto permite buscar por significado, no por palabras exactas. «¿Cómo despliego en producción?» encuentra documentos sobre «deploy to prod» aunque no compartan ni una sola palabra.

Modelos de embedding (2026)

Fecha de corte: 10 de junio de 2026. Esta tabla no es un ranking universal: es una foto de familias útiles para entender decisiones de ingeniería. Antes de elegir proveedor hay que comprobar licencia, coste, límites, idioma, evaluación propia y si el índice vectorial ya existente obliga a re-embedar documentos.

Modelo	Proveedor	Dimensiones declaradas	Qué aporta realmente
`text-embedding-3-large`	OpenAI	3072 por defecto; reducible con `dimensions`	API madura y buen punto de partida general. Reducir dimensiones ahorra almacenamiento, pero hay que medir recuperación en tus datos.⁶
`voyage-4-large`	Voyage AI	1024 por defecto; 256, 512, 1024 o 2048	Familia orientada a recuperación y RAG multilingüe con dimensiones Matryoshka y compatibilidad dentro de la serie Voyage 4.⁷
`Qwen3-Embedding-8B`	Qwen (open weights)	hasta 4096; salida configurable de 32 a 4096	Opción autoalojable para equipos que necesitan control de pesos, idiomas y despliegue propio, a cambio de gestionar hardware y rendimiento.⁸
`BGE-M3`	BAAI (open weights)	1024	Modelo abierto multilingüe útil para búsqueda híbrida —densa, dispersa y multi-vector— y entornos donde se quiere controlar el índice y el runtime.⁹ Conviene evaluarlo frente al dominio concreto antes de asumir que “open” significa suficiente.
`embed-v4`	Cohere	1536 por defecto; 256, 512, 1024 o 1536	Embeddings multimodales de texto e imagen, útiles para documentos visuales, PDFs, catálogos o búsqueda mixta.¹⁰

Importante: el modelo de embedding convierte entradas en vectores para comparar, ordenar o recuperar. No genera texto. Es distinto del LLM generativo. En un RAG típico, el embedding sirve para buscar fragmentos relevantes; el LLM sirve para redactar una respuesta usando esos fragmentos. Confundir ambas piezas lleva a arquitecturas caras y difíciles de depurar.

Cómo se entrenan los embeddings

El objetivo de entrenamiento es simple y brillante: dadas dos palabras que aparecen cerca en un texto, sus embeddings deben ser similares. Dadas dos palabras que no aparecen juntas, sus embeddings deben ser distintos.¹¹ El modelo aprende de millones de frases: si «gato» y «felino» aparecen en contextos similares («el _ _ _ _ duerme», «acaricié al _ _ _ _»), sus vectores se acercan. Si «gato» y «tornillo» nunca comparten contexto, sus vectores se alejan.

Este principio —«dime con qué palabras apareces y te diré qué significas»— se llama hipótesis distribucional y es la base de casi todos los embeddings modernos. No hace falta que nadie etiquete datos: el propio texto proporciona la señal de aprendizaje. Es aprendizaje auto-supervisado a escala masiva.

Embeddings Matryoshka: menos dimensiones sin perder calidad

Una innovación reciente son los embeddings Matryoshka (MRL, Matryoshka Representation Learning).¹² La idea: entrenar el embedding para que funcione bien a cualquier dimensionalidad. Puedes tomar las primeras 256 dimensiones de un embedding de 1024 y obtener una representación de calidad razonable, o usar las 1024 completas para máxima precisión. Es como tener varios embeddings de distinto tamaño dentro del mismo vector, como las muñecas rusas que le dan nombre.

Esto resuelve un problema práctico enorme: no necesitas elegir entre precisión y coste de antemano. Usas 256 dimensiones para búsquedas rápidas y baratas, y 1024 para cuando necesitas la máxima calidad. Modelos como voyage-4-large, Qwen3-Embedding y Cohere embed-v4 ya lo implementan.

En el día a día

Búsqueda semántica (RAG): conviertes tu base de documentos a embeddings, los guardas en una base de datos vectorial (Pinecone, Chroma, pgvector) y cuando llega una pregunta del usuario, buscas los fragmentos más cercanos para inyectarlos en el prompt.
Clasificación: agrupas tickets de soporte, correos o reseñas por similitud semántica, sin necesidad de definir categorías a mano.
Detección de duplicados: comparas embeddings para encontrar textos que dicen lo mismo con palabras distintas.
Traducción y multilingüe: los modelos multilingües colocan «deploy» cerca de «desplegar», «perro» cerca de «dog», permitiendo búsqueda entre idiomas.

Por qué debería importarte

Los embeddings son el pegamento que conecta el mundo del texto con el mundo de las matemáticas. Sin ellos, una red neuronal no podría procesar lenguaje: solo sabe multiplicar matrices de números.

Cada vez que usas un LLM, hay embeddings trabajando: los tokens de entrada se convierten en embeddings antes de entrar al Transformer. Cada vez que usas búsqueda semántica, hay embeddings trabajando: la consulta y los documentos se comparan en el espacio vectorial. Son ubicuos y silenciosos. Entenderlos te permite elegir el modelo adecuado, ajustar la dimensionalidad según tu presupuesto y depurar por qué tu búsqueda semántica devuelve resultados incoherentes.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Confundir token con palabra	«Hola mundo» son dos palabras, pero con BPE pueden ser 2-3 tokens. «Desarrolladores» es una palabra pero 3-4 tokens. Planificar costes en palabras te dará sorpresas en la factura.	Mide en tokens, no en palabras. Usa el tokenizador del proveedor para contar.
Tratar la métrica vectorial como una verdad universal	Coseno, producto escalar y distancia euclídea pueden comportarse distinto según normalización, modelo e índice. Decir “euclídea nunca sirve” es tan pobre como usarla sin pensar.	Lee la recomendación del modelo y de la base vectorial. Si los vectores están normalizados, coseno y producto escalar pueden ser equivalentes. Evalúa la métrica con consultas reales.
Usar el mismo modelo de embedding para todo	Un modelo optimizado para inglés puede rendir mal en español jurídico. Un modelo de código no sirve para reseñas de restaurantes.	Elige el modelo de embedding según tu dominio, idioma y tipo de contenido.
Asumir que más dimensiones siempre es mejor	Más dimensiones permiten más matices, pero también más memoria, más latencia y más coste de almacenamiento.	Evalúa con tus datos. A veces 256 dimensiones bastan; a veces necesitas 3072.

Manos a la obra

La práctica de este capítulo está en kit descargable. Es intencionadamente local: no requiere clave de API, no descarga modelos y no depende de librerías externas. Usa un tokenizador y un embedding de juguete para que puedas ver el mecanismo completo sin que una herramienta real oculte lo importante.

El kit toma pares de textos en español, inglés y código. Para cada texto muestra tokens, IDs deterministas, coste aproximado por token, un vector resumido y similitud coseno. La parte importante no es que los números coincidan con un proveedor real. La parte importante es que entiendas qué mide cada número antes de pagar, indexar documentos o construir un RAG.

Archivo	Qué contiene
`Makefile`	Ejecución, tests y limpieza del kit.
`requirements.txt`	Declara que no hay dependencias externas.
`data/text_cases.json`	Pares de textos para comparar coste, semántica, código y palabras largas.
`contracts/token_embedding_policy.json`	Dimensión del embedding de juguete, umbrales y coste por token de ejemplo.
`ops/inspect_tokens_embeddings.py`	Tokenizador simple, IDs, embedding hash y similitud coseno.
`tests/test_token_embedding_inspector.py`	Comprueba tokens, vectores resumidos y similitud coseno.
`output/token_embedding_report.json`	Informe estructurado con tokens, IDs y métricas.
`output/token_embedding_decision.md`	Lectura técnica para entregar.

Ejecuta:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/inspect_tokens_embeddings.py --write
cat output/token_embedding_decision.md

Valida el kit:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

Después añade dos pares propios. Uno debería ser semánticamente parecido con palabras distintas; otro debería tener muchas palabras compartidas pero intención diferente. Ese contraste es oro: te obliga a separar coincidencia literal, tokenización y similitud vectorial.

Qué entregaría un alumno. El Markdown generado, dos pares nuevos, el resultado de make test, una explicación de un caso donde el parecido literal engaña y una decisión sobre qué tokenizador y modelo de embedding mediría antes de estimar coste o montar un buscador semántico.

Cuando ya entiendas el mecanismo, prueba también el OpenAI Tokenizer o el contador del proveedor que vayas a usar. En producción no se estima en palabras: se mide con el tokenizador real.

Cómo encaja todo

Este mapa se lee como una tubería de representación. Venimos de neuronas, capas y arquitecturas que solo operan con números; este capítulo explica cómo el texto entra en ese mundo numérico sin fingir que el modelo “lee” como una persona. La decisión técnica nueva es doble: elegir cómo troceas el texto y elegir qué espacio vectorial usarás para comparar significado.

La consecuencia aparece después en casi todo el libro. Entrenar e inferir necesitan tokens; RAG necesita embeddings y métricas de similitud; evaluar sistemas semánticos exige saber cuándo una búsqueda recupera por significado y cuándo solo recupera ruido con buena pinta.

graph TD
    subgraph "Hereda de capítulos anteriores"
        NUM["Redes operan con números\n(cap. 4-5)"]
        SEQ["Secuencias y atención\n(cap. 8)"]
    end

    subgraph "Capítulo 9: representar lenguaje"
        TEXT["Texto humano"]
        TOKEN["Tokenización"]
        IDS["IDs de token"]
        EMB["Embeddings"]
        METRIC["Métrica de similitud"]
        INDEX["Índice vectorial"]
    end

    subgraph "Se reutiliza después"
        TRAIN["Entrenamiento e inferencia\n(cap. 10)"]
        LLM["Transformers y LLMs\n(fasc. 3)"]
        RAG["RAG y búsqueda semántica\n(fasc. 4)"]
        EVAL["Evaluación semántica\n(fasc. 7)"]
    end

    NUM -->|"exige representar como"| IDS
    SEQ -->|"explica por qué importa el orden"| TOKEN
    TEXT -->|"se trocea con"| TOKEN
    TOKEN -->|"produce"| IDS
    IDS -->|"se proyectan a"| EMB
    EMB -->|"se comparan mediante"| METRIC
    METRIC -->|"ordena resultados en"| INDEX
    IDS -->|"alimentan"| TRAIN
    EMB -->|"entran en"| LLM
    INDEX -->|"recupera contexto para"| RAG
    METRIC -->|"se mide en"| EVAL

    style NUM stroke-dasharray: 5 5
    style SEQ stroke-dasharray: 5 5
    style TRAIN stroke-dasharray: 5 5
    style RAG stroke-dasharray: 5 5
    style LLM stroke-dasharray: 5 5
    style EVAL stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Token	Unidad mínima de texto procesada por el modelo. Puede ser palabra, subtoken o carácter.
Tokenizador	Programa que convierte texto en secuencias de tokens según un vocabulario predefinido.
Embedding	Vector denso de números reales que representa un token, frase o documento en un espacio semántico de alta dimensionalidad.
Similitud coseno	Medida de similitud entre vectores basada en el coseno de su ángulo. Es muy habitual en embeddings, pero debe validarse con la recomendación del modelo y del índice.
Base de datos vectorial	Sistema de almacenamiento optimizado para buscar vectores cercanos por similitud.

Antes de pasar página

¿Puedo explicar la diferencia entre token y palabra con un ejemplo? (Si no, vuelve a «Qué es un token».)
¿Entiendo qué es un embedding y por qué las dimensiones no tienen etiquetas? (Si no, vuelve a «Qué es un embedding».)
¿Sé qué mide la similitud coseno? (Si no, vuelve a «Similitud semántica».)
¿Puedo nombrar al menos tres usos prácticos de los embeddings? (Si no, vuelve a «En el día a día».)
¿He ejecutado kit descargable y puedo explicar por qué dos textos parecidos pueden tener tokens distintos? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
Un token es la unidad mínima de texto para el modelo.	No es una palabra: «desarrolladores» son 3 tokens. Todo se mide en tokens: contexto, precio, límites.
Un embedding es un vector denso que representa regularidades semánticas y de uso.	Cientos o miles de números sitúan cada concepto en un espacio vectorial. Conceptos usados de forma parecida tienden a quedar cerca; conceptos distintos, lejos.
Los embeddings son el pegamento entre texto y matemáticas.	Sin ellos, las redes neuronales no podrían procesar lenguaje. Con ellos, puedes buscar por significado, no por palabras exactas.

Para saber más

Bengio, Y., Ducharme, R., Vincent, P. y Janvin, C. (2003). A neural probabilistic language model. Journal of Machine Learning Research, 3, 1137-1155. https://www.jmlr.org/papers/volume3/bengio03a/bengio03a.pdf

Chen, J., Xiao, S., Zhang, P., Luo, K., Lian, D. y Liu, Z. (2024). BGE M3-Embedding: Multi-lingual, multi-functionality, multi-granularity text embeddings through self-knowledge distillation. arXiv:2402.03216. https://arxiv.org/abs/2402.03216

Cohere. (2025). Announcing Embed Multimodal v4. https://docs.cohere.com/changelog/embed-multimodal-v4

Devlin, J., Chang, M. W., Lee, K. y Toutanova, K. (2019). BERT: pre-training of deep bidirectional transformers for language understanding. En Proceedings of NAACL-HLT (pp. 4171-4186). https://doi.org/10.18653/v1/N19-1423

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

Mikolov, T., Chen, K., Corrado, G. y Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv:1301.3781. https://arxiv.org/abs/1301.3781

OpenAI. (2026). Vector embeddings. https://developers.openai.com/api/docs/guides/embeddings

Qwen. (2025). Qwen3-Embedding-8B. Hugging Face. https://huggingface.co/Qwen/Qwen3-Embedding-8B

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Voyage AI. (2026). Text embeddings. https://docs.voyageai.com/docs/embeddings

Notas

Brown, T. B. et al. (2020). Language models are few-shot learners. En Advances in Neural Information Processing Systems 33 (pp. 1877-1901). https://papers.nips.cc/paper/2020/hash/1457c0d6bfcb4967418bfb8ac142f64a-Abstract.html. GPT-3 usó tokenización por pares de bytes (BPE), que equilibra el tamaño del vocabulario con la capacidad de representar palabras raras como secuencias de subtokens. ↩
Sennrich, R., Haddow, B. y Birch, A. (2016). Neural machine translation of rare words with subword units. En Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (pp. 1715-1725). https://doi.org/10.18653/v1/P16-1162. BPE se popularizó como método de tokenización por subpalabras, resolviendo el problema de las palabras fuera de vocabulario en traducción automática y siendo adoptado posteriormente por GPT y la mayoría de LLMs. ↩
Mikolov, T., Chen, K., Corrado, G. y Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv:1301.3781. https://arxiv.org/abs/1301.3781. Word2Vec demostró que las representaciones vectoriales densas de palabras capturan relaciones semánticas, permitiendo operaciones como «rey - hombre + mujer ≈ reina». ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 12 aborda las representaciones distribuidas y cómo los embeddings densos aprendidos permiten a los modelos capturar relaciones semánticas complejas. ↩
Mikolov, T., Chen, K., Corrado, G. y Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv:1301.3781. https://arxiv.org/abs/1301.3781. Las analogías semánticas vectoriales fueron una de las demostraciones más impactantes de Word2Vec, mostrando que los embeddings capturan relaciones sistemáticas entre conceptos. ↩
OpenAI. (2026). Vector embeddings. https://developers.openai.com/api/docs/guides/embeddings. La documentación indica 1536 dimensiones para text-embedding-3-small, 3072 para text-embedding-3-large y soporte para reducir dimensiones con el parámetro dimensions. ↩
Voyage AI. (2026). Text embeddings. https://docs.voyageai.com/docs/embeddings. La documentación de Voyage 4 declara contexto de 32 000 tokens y dimensiones 256, 512, 1024 y 2048 para voyage-4-large. ↩
Qwen. (2025). Qwen3-Embedding-8B. Hugging Face. https://huggingface.co/Qwen/Qwen3-Embedding-8B. La ficha declara 100+ idiomas, contexto de 32k y dimensiones configurables hasta 4096. ↩
Chen, J., Xiao, S., Zhang, P., Luo, K., Lian, D. y Liu, Z. (2024). BGE M3-Embedding: Multi-lingual, multi-functionality, multi-granularity text embeddings through self-knowledge distillation. arXiv:2402.03216. https://arxiv.org/abs/2402.03216. El artículo presenta BGE-M3 como modelo multilingüe, multifuncional y de granularidad variable, con entradas hasta 8192 tokens. ↩
Cohere. (2025). Announcing Embed Multimodal v4. https://docs.cohere.com/changelog/embed-multimodal-v4. Cohere declara dimensiones Matryoshka 256, 512, 1024 y 1536, contexto de 128k y soporte multimodal. ↩
Mikolov, T., Chen, K., Corrado, G. y Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv:1301.3781. https://arxiv.org/abs/1301.3781. Word2Vec popularizó dos arquitecturas: skip-gram (predecir contexto a partir de palabra) y CBOW (predecir palabra a partir de contexto), demostrando que ambas producen embeddings de alta calidad. ↩
Kusupati, A., Bhatt, G., Rege, A., Wallingford, M., Sinha, A., Ramanujan, V., Howard-Snyder, W., Chen, K., Kakade, S., Jain, P. y Farhadi, A. (2022). Matryoshka representation learning. En Advances in Neural Information Processing Systems 35. https://arxiv.org/abs/2205.13147. MRL entrena embeddings para que sean útiles a múltiples dimensionalidades, permitiendo elegir entre precisión y coste sin reentrenar. ↩

Capítulo 10

Facsímil 1 · Los cimientos

Capítulo 10: Entrenamiento frente a inferencia: dos mundos distintos

Entrando en el tema

Has pasado nueve capítulos entendiendo cómo funciona una red neuronal por dentro. Neuronas, capas, retropropagación, pérdidas, optimizadores. Todo eso ocurre durante el entrenamiento: el proceso de crear el modelo.

Pero tú, como ingeniera, probablemente nunca entrenarás un LLM desde cero. Lo que harás —cientos de veces al día— es inferencia: usar un modelo ya entrenado para obtener respuestas. Y estos dos mundos son radicalmente distintos. Confundirlos es como confundir construir una fábrica con comprar el producto que sale de ella.

Este capítulo traza la frontera. Y de paso, explica qué hay entre medias: el fine-tuning, la cuantización, y el pipeline que convierte una idea en un modelo funcionando en producción.

Entrenamiento vs inferencia

Aspecto	Entrenamiento	Inferencia
Qué hace	Ajusta parámetros para reducir una pérdida	Usa parámetros ya ajustados para responder
Duración	Desde minutos en un modelo pequeño hasta meses en un modelo fundacional	Desde milisegundos hasta minutos según modelo, contexto y carga
Hardware	CPU/GPU local para modelos pequeños; clústeres enormes para frontera	CPU, GPU local, servidor propio, API o clúster de inferencia
Coste	Barato en prácticas pequeñas; enorme en pre-entrenamiento a escala	Por petición, por token, por GPU/hora o por infraestructura propia
Quién	Estudiantes, equipos de datos, universidades y laboratorios; frontera: grandes organizaciones	Cualquier equipo que consuma o sirva un modelo
Frecuencia	Cuando cambian datos, objetivo o modelo	Cada petición de usuario o proceso automático

El entrenamiento es crear o modificar el modelo ajustando parámetros.¹ Si hablamos de un modelo fundacional de frontera, los datos curados se procesan durante semanas o meses en clústeres de GPUs. Si hablamos de un clasificador pequeño, una red de visión acotada o un fine-tuning con adaptadores, el entrenamiento puede ocurrir en un portátil potente, una única GPU o una instancia alquilada. La palabra es la misma; la escala no.

La inferencia es usar el modelo.² Tu prompt llega a un runtime, el modelo procesa tokens y recibes una salida. Puede ser una llamada de API, un modelo local con llama.cpp, un servidor vLLM, una función interna o un clúster con batching. En producción, inferir no es “apretar un botón”: hay latencia, memoria de KV cache, límites de contexto, colas, cuotas, coste por token y monitorización.

El fine-tuning está a medio camino: no creas un modelo desde cero, pero sí reentrenas parcialmente uno existente con tus propios datos. Es mucho más barato que el entrenamiento completo, pero más caro que la simple inferencia. Cambia el estilo y comportamiento del modelo, no le «enseña datos nuevos» en tiempo real. Para acceder a datos cambiantes, RAG es mejor opción.

Las tres fases del entrenamiento

El entrenamiento de un LLM moderno no es un solo paso: son tres fases encadenadas, cada una con un propósito distinto.

Fase 1: Pre-entrenamiento. El modelo se entrena sobre cantidades masivas de texto (billones de tokens) con un objetivo simple: predecir la siguiente palabra. No hay etiquetas humanas: el propio texto proporciona la señal. Esta fase consume el 99 % del coste total y produce un modelo que «sabe lenguaje» pero no sabe conversar. Es la fase que más se beneficia de las scaling laws: más datos + más parámetros + más cómputo = modelo más capaz.³

Fase 2: Post-entrenamiento (SFT). Se entrena al modelo con ejemplos de conversaciones de alta calidad escritas por personas. El modelo pre-entrenado ya sabe completar frases; el SFT le enseña a responder preguntas, seguir instrucciones y mantener un tono conversacional. Es mucho más barato que la fase 1: miles de ejemplos en lugar de billones de tokens.

Fase 3: Alineamiento (RLHF/DPO). Personas comparan pares de respuestas del modelo y eligen cuál es mejor. Esa señal de preferencia se usa para refinar el comportamiento: ser útil pero no peligroso, admitir cuando no sabe algo, rechazar peticiones inapropiadas. Es la fase más barata y la que marca la diferencia entre un modelo técnicamente capaz y uno con el que realmente quieres interactuar.

Programación clásica vs machine learning

El machine learning no sustituye a la ingeniería de software: cambia dónde escribes la lógica.

En software clásico, una persona escribe reglas explícitas: «si el email contiene 'gratis' y 'clic aquí', sube la puntuación de spam». La lógica vive en código mantenido por personas.

En machine learning, das ejemplos etiquetados y dejas que el modelo descubra las reglas. En lugar de escribir «si contiene X, entonces Y», le das diez mil emails etiquetados como spam o no spam y dejas que encuentre los patrones. La lógica queda codificada en parámetros aprendidos, no en sentencias if.

En inferencia, usas el modelo entrenado: llega un email nuevo y el modelo devuelve una probabilidad de spam.

Aspecto	Software clásico	Machine learning
Fuente de la lógica	Reglas escritas por personas	Patrones aprendidos de datos
Cómo se corrige	Modificar código	Mejorar datos, etiquetas o arquitectura
Testing	Casos deterministas	Evaluaciones estadísticas
Explicación	Se rastrea la rama de código	Se analizan pesos, datos y prompts

El riesgo principal: un bug en ML puede vivir en el dataset, no en el código. El modelo puede aprender atajos espurios —correlaciones que funcionan en entrenamiento pero fallan en producción— y tu código compilará perfectamente mientras el modelo toma decisiones incorrectas.

El pipeline: de los datos a producción

Un modelo útil no nace cuando termina el entrenamiento. Nace cuando puedes repetir el proceso, comparar versiones y desplegar con control:

Decisión → Datos → Etiquetas → Entrenamiento → Evaluación → Registro → Despliegue → Monitorización

Cada fase produce artefactos que deberías versionar:

Fase	Artefacto	Pregunta clave
Datos	Dataset versionado	¿Con qué datos exactos se entrenó?
Entrenamiento	Código, semilla, hiperparámetros	¿Puedo reproducir el modelo?
Evaluación	Informe con métricas y segmentos	¿Dónde mejora y dónde empeora?
Despliegue	Configuración de runtime	¿Qué latencia, coste y fallback tendrá?
Monitorización	Métricas y alertas	¿Cómo sé que en producción ha cambiado algo?

El criterio para desplegar no es «el modelo es mejor». Es: release_ok = data_ok AND eval_ok AND safety_ok AND rollback_ok. Si no puedes volver atrás, no despliegues.

Entrenar no es desplegar

El modelo que gana en métricas offline puede ser inviable en producción. Quizás tarda demasiado, consume demasiada memoria, no explica sus fallos o no se puede monitorizar. Desplegar no es copiar un archivo: es integrar un sistema.

Cinco técnicas cierran la brecha entre el modelo entrenado y el servicio desplegado:

Técnica	Qué hace	Cuándo ayuda	Contrapartida
Pruning	Elimina pesos o neuronas poco útiles	Reducir tamaño cuando hay redundancia	Puede degradar calidad
Cuantización	Guarda pesos con menos bits (FP16→INT8→INT4)	Inferencia local, edge	Puede perder precisión
Destilación	Un modelo grande enseña a uno pequeño	Casos repetitivos de bajo coste	El alumno hereda sesgos del maestro
Compilación	Optimiza para hardware concreto	Servir mucho tráfico con GPU/TPU específica	Más dependencia del runtime
Batching	Agrupa peticiones	Throughput alto	Puede aumentar latencia individual

Cuantización: modelos que caben en tu portátil

La cuantización merece un apartado propio porque es la técnica que ha democratizado el acceso a los LLMs.⁴

La idea es simple: en lugar de guardar cada peso como un número de 16 bits (FP16), lo guardas con 8 bits (INT8), 4 bits (INT4) o incluso 2 bits. Ocupa la mitad, un cuarto o un octavo de memoria. Un modelo de 7B parámetros que en FP16 ocupa ~14 GB, cuantizado a 4 bits ocupa ~3,5 GB. Cabe en un portátil.

La contrapartida es la precisión. Al reducir el número de bits, algunos pesos pierden matices. Para la mayoría de tareas, la pérdida puede ser pequeña. Para tareas que requieren cálculo preciso, seguimiento largo de instrucciones o respuestas muy sensibles al detalle, la degradación puede ser notable.⁵ La clave está en evaluar con tus datos y tu tarea.

Formatos comunes:

GGUF: para inferencia en CPU con llama.cpp. Ideal para portátiles.
GPTQ / AWQ: para inferencia en GPU con menor latencia.
BitsAndBytes: para cargar modelos cuantizados en Python con Hugging Face.

En el día a día

No entrenas, infieres. Tu día a día con IA es inferencia: llamadas a API, prompts, respuestas. El entrenamiento lo hacen los proveedores.
Haces fine-tuning cuando necesitas especialización. Si el modelo base no conoce tu dominio, el fine-tuning es la herramienta. Pero evalúa antes si RAG resuelve tu problema sin el coste de reentrenar.
Cuantizas para abaratar. Si usas modelos open weights, la cuantización te permite ejecutarlos en hardware más modesto. De 14 GB a 3,5 GB es la diferencia entre necesitar una GPU de 24 GB y poder usar una de 8 GB.
Versionas todo. El dataset, el código de entrenamiento, los hiperparámetros, la configuración de despliegue. Si no puedes reproducir tu modelo, no puedes depurarlo.

Por qué debería importarte

La frontera entre entrenamiento e inferencia es la frontera entre lo que haces tú y lo que hace el proveedor. Si no la entiendes, tomarás decisiones equivocadas: intentarás «entrenar» un modelo cuando bastaba con un buen prompt, o asumirás que el modelo «sabe» cosas que solo aprendió durante el entrenamiento y no puede actualizar.

Entender el pipeline completo —de los datos a la monitorización— es lo que separa un prototipo que funciona en una demo de un sistema que funciona en producción. Y la cuantización es la herramienta que convierte «necesito un clúster de GPUs» en «cabe en mi portátil».

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
*Confundir fine-tuning* con «enseñar datos nuevos»**	El fine-tuning ajusta el estilo y comportamiento, no inyecta conocimiento factual actualizable. Para datos cambiantes, usa RAG.	Si tus datos cambian cada día, RAG. Si necesitas que el modelo hable con tu jerga, fine-tuning.
Cuantizar sin evaluar	Pasar de FP16 a INT4 puede degradar el rendimiento en tareas que requieren precisión. Asumir que «no se nota» es peligroso.	Evalúa con tus datos y tu tarea antes y después de cuantizar. No delegues esta decisión.
Desplegar sin rollback	Si el modelo nuevo funciona peor en producción, necesitas volver al anterior en minutos, no en días.	Diseña el despliegue con rollback desde el primer día. No es opcional.
Tratar el modelo como una caja negra	Si no sabes con qué datos se entrenó, no puedes explicar sus sesgos. Si no versionas el pipeline, no puedes reproducir resultados.	Versiona datos, código, hiperparámetros y configuración. La trazabilidad no es burocracia: es ingeniería.

Manos a la obra

La práctica está en kit descargable. En vez de pedirte que cargues un modelo que quizá no cabe en tu máquina, el kit calcula primero el presupuesto: memoria de pesos, memoria aproximada de KV cache, margen de VRAM y memoria de entrenamiento.

Esto reproduce una conversación real de ingeniería: «¿lo sirvo local?», «¿uso API?», «¿hago LoRA?», «¿tiene sentido entrenar desde cero?». La respuesta no depende solo del tamaño del modelo. Depende de precisión, contexto, batch, GPU, datos disponibles, privacidad y evaluación.

Archivo	Qué contiene
`Makefile`	Atajos para ejecutar, probar y limpiar.
`requirements.txt`	Declara que el kit no requiere paquetes externos.
`data/model_scenarios.json`	Escenarios de inferencia local, API + RAG, LoRA y entrenamiento desde cero.
`contracts/deployment_policy.json`	Bytes por precisión, margen de VRAM y mínimos de datos.
`ops/plan_train_infer.py`	Calculadora de pesos, KV cache, memoria de entrenamiento y recomendación.
`tests/test_train_infer_budget.py`	Comprueba que el informe separa entrenamiento, inferencia y memoria de contexto.
`output/train_infer_report.json`	Informe estructurado por escenario.
`output/train_infer_decision.md`	Decisión técnica legible.

Ejecuta:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/plan_train_infer.py --write
cat output/train_infer_decision.md

Valida el kit:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

Después cambia un escenario: sube el contexto, cambia int4 por fp16, aumenta el batch_size o reduce la VRAM. Verás una cosa importante: cuantizar baja la memoria de pesos, pero el contexto largo sigue costando KV cache. Un modelo puede «caber» con un prompt corto y dejar de caber cuando lo usas como producto.

Qué entregaría un alumno. El Markdown generado, un escenario propio con GPU y contexto realistas, una comparación de FP16/INT8/INT4, el resultado de make test y una decisión escrita: API, local, RAG, fine-tuning o no construir todavía.

Si después quieres probar cuantización real, entonces sí tiene sentido ir a Hugging Face, bitsandbytes, Ollama, LM Studio o llama.cpp. Pero primero haz el presupuesto. Descargar un modelo no es una estrategia.

Cómo encaja todo

Este mapa separa tres decisiones que suelen mezclarse. Primero, de dónde viene el modelo: entrenamiento, post-entrenamiento o ajuste parcial. Segundo, cómo se usa: inferencia con una ventana de contexto, una KV cache y una política de servicio. Tercero, cómo se lleva a producción: presupuesto, cuantización, despliegue y observabilidad.

La herencia viene de backpropagation, pérdida y optimizadores: esas piezas explican cómo cambian los pesos. La reutilización aparece en los próximos facsímiles cuando elijas entre API, modelo local, RAG, fine-tuning o despliegue propio. Si no separas estas capas, confundirás “necesito más conocimiento” con “necesito entrenar” y gastarás tiempo en el sitio equivocado.

graph TD
    subgraph "Hereda de F1"
        BACKPROP["Retropropagación\n(cap. 6)"]
        LOSS["Pérdida y optimizadores\n(cap. 7)"]
        TOKENS["Tokens y embeddings\n(cap. 9)"]
    end

    subgraph "Capítulo 10: dos fases distintas"
        DATA["Datos + objetivo"]
        TRAIN["Entrenamiento"]
        MODEL["Pesos versionados"]
        INFER["Inferencia"]
        KVCACHE["KV cache y contexto"]
        QUANT["Cuantización"]
    end

    subgraph "Se reutiliza después"
        FINETUNE["Fine-tuning y LoRA\n(fasc. 4)"]
        LOCAL["Modelos locales y servidores\n(fasc. 4)"]
        PROD["Operación y observabilidad\n(fasc. 6)"]
        EVAL["Evaluación antes/después\n(fasc. 7)"]
    end

    BACKPROP -->|"calcula gradientes para"| TRAIN
    LOSS -->|"define qué error reducir"| TRAIN
    DATA -->|"alimenta"| TRAIN
    TRAIN -->|"produce"| MODEL
    MODEL -->|"se usa en"| INFER
    TOKENS -->|"determinan coste de"| INFER
    INFER -->|"consume"| KVCACHE
    QUANT -->|"reduce memoria de"| MODEL
    FINETUNE -->|"modifica parcialmente"| MODEL
    QUANT -->|"habilita"| LOCAL
    INFER -->|"requiere medir"| PROD
    EVAL -->|"decide si cambian pesos o servicio"| TRAIN

    style BACKPROP stroke-dasharray: 5 5
    style LOSS stroke-dasharray: 5 5
    style TOKENS stroke-dasharray: 5 5
    style FINETUNE stroke-dasharray: 5 5
    style LOCAL stroke-dasharray: 5 5
    style PROD stroke-dasharray: 5 5
    style EVAL stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Entrenamiento	Proceso de ajustar parámetros con datos y una función de pérdida. Puede ir desde una práctica pequeña hasta pre-entrenamiento de frontera.
Inferencia	Uso de un modelo ya entrenado para generar o calcular salidas a partir de entradas nuevas.
Fine-tuning	Reentrenamiento parcial de un modelo existente con datos propios para especializarlo.
Cuantización	Reducción de la precisión numérica de los pesos para ahorrar memoria y acelerar inferencia.
Pipeline ML	Secuencia de fases desde la decisión inicial hasta la monitorización en producción.

Antes de pasar página

¿Puedo explicar las diferencias entre entrenamiento, inferencia y fine-tuning? (Si no, vuelve a «Entrenamiento vs inferencia».)
¿Entiendo la diferencia fundamental entre programación clásica y ML? (Si no, vuelve a «Programación clásica vs machine learning».)
¿Puedo enumerar las fases del pipeline ML? (Si no, vuelve a «El pipeline».)
¿Sé qué es la cuantización y cuándo usarla? (Si no, vuelve a «Cuantización».)
¿He ejecutado kit descargable y puedo explicar por qué KV cache también consume memoria? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
Entrenar cambia pesos; inferir usa pesos.	Pre-entrenar un modelo fundacional puede costar millones y tardar meses; entrenar modelos pequeños o ajustar adaptadores puede ser mucho más accesible. La inferencia también escala: puede ser una llamada barata o un sistema complejo de servicio.
El ML no sustituye al software: cambia dónde vive la lógica.	De reglas escritas por personas a patrones aprendidos de datos. El bug puede estar en el dataset, no en el código.
La cuantización democratiza el acceso a los LLMs.	De 14 GB a 3,5 GB con 4 bits. Evalúa siempre antes de desplegar: la pérdida de precisión depende de tu tarea.

Para saber más

Dettmers, T., Pagnoni, A., Holtzman, A. y Zettlemoyer, L. (2023). QLoRA: efficient finetuning of quantized LLMs. En Advances in Neural Information Processing Systems 36. https://arxiv.org/abs/2305.14314

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

Jacob, B. et al. (2018). Quantization and training of neural networks for efficient integer-arithmetic-only inference. En Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 2704-2713). https://doi.org/10.1109/CVPR.2018.00286

Kaplan, J. et al. (2020). Scaling laws for neural language models. arXiv:2001.08361. https://doi.org/10.48550/arXiv.2001.08361

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Notas

Kaplan, J. et al. (2020). Scaling laws for neural language models. arXiv:2001.08361. https://doi.org/10.48550/arXiv.2001.08361. Los autores establecieron las leyes de escala que relacionan el tamaño del modelo, los datos de entrenamiento y la computación necesaria, demostrando que el rendimiento mejora de forma predecible con la inversión. ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 12.3 aborda las diferencias prácticas entre la fase de entrenamiento y la de inferencia, incluyendo técnicas de optimización específicas para cada una. ↩
Brown, T. B. et al. (2020). Language models are few-shot learners. En Advances in Neural Information Processing Systems 33 (pp. 1877-1901). https://papers.nips.cc/paper/2020/hash/1457c0d6bfcb4967418bfb8ac142f64a-Abstract.html. GPT-3 demostró que el pre-entrenamiento a escala masiva produce modelos capaces de realizar tareas para las que no fueron explícitamente entrenados (few-shot learning). ↩
Jacob, B. et al. (2018). Quantization and training of neural networks for efficient integer-arithmetic-only inference. En Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 2704-2713). https://doi.org/10.1109/CVPR.2018.00286. Los autores establecieron el marco para la cuantización de redes neuronales, demostrando que es posible mantener la precisión reduciendo la representación numérica de 32 a 8 bits. ↩
Dettmers, T., Pagnoni, A., Holtzman, A. y Zettlemoyer, L. (2023). QLoRA: efficient finetuning of quantized LLMs. En Advances in Neural Information Processing Systems 36. https://arxiv.org/abs/2305.14314. QLoRA combina cuantización de 4 bits con adaptadores LoRA, permitiendo hacer fine-tuning de modelos de 65B parámetros en una sola GPU de 48 GB. ↩

Capítulo 11

Facsímil 1 · Los cimientos

Capítulo 11: Machine learning clásico: el mapa antes de los LLM

Entrando en el tema

Hemos pasado diez capítulos construyendo los cimientos: neuronas, redes, retropropagación, embeddings. Todo eso es deep learning. Pero antes del deep learning —y todavía hoy, para la mayoría de problemas del mundo real— existe el machine learning clásico.

No es un primo pobre. Es un conjunto de herramientas más simples, más rápidas y más interpretables que resuelven la mayoría de problemas que te encontrarás. Clasificar correos, predecir ventas, detectar fraude, agrupar clientes: todo esto se hacía con ML clásico décadas antes de que existiera ChatGPT. Y se sigue haciendo.

Este capítulo es tu mapa. No te convertirá en experto en cada técnica, pero te dará el vocabulario para saber qué buscar cuando te enfrentes a un problema real.

El paisaje del ML clásico

El machine learning se organiza alrededor de una pregunta fundamental: ¿qué tipo de señal de aprendizaje tienes?¹

Supervisado. Tienes ejemplos etiquetados: cada entrada viene con su respuesta correcta. «Este email es spam», «esta imagen contiene un gato», «esta transacción es fraudulenta». El modelo aprende a imitar esas etiquetas. Es el paradigma más común y el que mejor funciona cuando tienes datos etiquetados de calidad.

No supervisado. No tienes etiquetas. Buscas estructura oculta: agrupar clientes por comportamiento, detectar anomalías, reducir la dimensionalidad de tus datos. El modelo encuentra patrones, pero tú tienes que interpretarlos. Que el algoritmo encuentre tres grupos no significa que esos tres grupos signifiquen algo útil para tu negocio.

Refuerzo. No tienes ejemplos etiquetados, pero sí una señal de recompensa. Un agente actúa en un entorno, recibe feedback y aprende a maximizar la recompensa acumulada. Es el paradigma de los juegos, la robótica y, cada vez más, del post-entrenamiento de LLMs (RLHF).

Semi-supervisado y auto-supervisado. Variantes híbridas. El semi-supervisado combina unos pocos ejemplos etiquetados con muchos sin etiquetar. El auto-supervisado genera sus propias etiquetas a partir de los datos: predecir la siguiente palabra en un texto, predecir la zona recortada de una imagen. Es el paradigma que hizo posibles los LLMs.

Anatomía de un dataset

Antes de elegir algoritmo, necesitas entender tus datos.²

Instancia (fila): un ejemplo concreto. Un cliente, una transacción, una imagen, un email.
Feature (columna, variable, atributo): una característica medible de la instancia. Edad, importe, número de caracteres, color promedio.
Label / target (etiqueta): lo que quieres predecir. «Fraude / No fraude», «150 000 €», «Categoría A».
Dataset: el conjunto de instancias con sus features y, si es supervisado, sus etiquetas.

Regla práctica: si no puedes explicar qué representa cada fila, qué significa cada columna y qué decisión habilita la predicción, no tienes un problema de ML. Tienes datos sueltos. Resolver esa ambigüedad es el primer paso de cualquier proyecto.

Clasificación vs regresión

La primera decisión técnica es el tipo de salida.³

Clasificación. La salida es una categoría discreta. «Spam / No spam», «Gato / Perro / Pájaro», «Fraude / No fraude». El modelo predice una clase o una distribución de probabilidad sobre las clases. Con esa probabilidad, tú decides el umbral: ¿bloqueo toda transacción con probabilidad de fraude > 0.3, o solo las que superan 0.9?

Regresión. La salida es un valor continuo. El precio de una casa, la temperatura de mañana, los ingresos del próximo trimestre. Aquí no existe «acertar o fallar» de forma binaria: importa cuánto te alejas del valor real. Un error de 1 000 € en una predicción de 300 000 € es aceptable; un error de 100 000 € no lo es.

Error común: convertir todo en clasificación porque es más cómodo. Si el valor numérico importa para decidir, usa regresión. Si solo importa el orden relativo, quizá necesitas ranking. Si una probabilidad dispara una acción, necesitas calibración, no solo clasificación.

Validación: cómo saber si generaliza

Entrenar un modelo es fácil. Lo difícil es saber si funcionará con datos que no ha visto nunca.⁴

Train / validation / test. Divide tus datos en tres conjuntos antes de tocar nada. Entrenas con train, ajustas hiperparámetros con validation y mides el rendimiento final con test. Si usas test para tomar decisiones, ya no es test: es validation y necesitas uno nuevo.

Cross-validation. Cuando tienes pocos datos, el k-fold entrena el modelo K veces, cada una con una partición distinta de train/validation. Te da una estimación más robusta del rendimiento y su variabilidad. No te fíes de una sola métrica con suerte.

Data leakage. El error más insidioso. Una columna que contiene información del futuro, un identificador que correlaciona con la etiqueta, un duplicado entre train y test. El modelo aprende una señal que no existirá en producción. Y tu métrica de validación será excelente... hasta que despliegues.

Data drift. El mundo cambia. Tus clientes cambian, los precios cambian, las campañas de marketing cambian. Un modelo entrenado con datos de 2023 puede fallar en 2026 aunque el código no haya cambiado. Monitoriza.

Overfitting y underfitting

Overfitting. El modelo memoriza los datos de entrenamiento. La pérdida de entrenamiento es mínima, pero la de validación es alta. Es el estudiante que se aprende las respuestas del examen de memoria: saca un 10 en el simulacro y suspende el examen real.⁵ Solución: más datos, regularización, dropout, modelos más simples.

Underfitting. El modelo es demasiado simple para capturar los patrones de los datos. Tanto la pérdida de entrenamiento como la de validación son altas. Es el estudiante que ni siquiera ha abierto el libro. Solución: modelo más complejo, más features, más tiempo de entrenamiento.

El diagnóstico rápido: si ambas pérdidas son altas → underfitting. Si la de entrenamiento es baja pero la de validación es alta → overfitting. Si ambas son bajas y cercanas → buen trabajo.

Matriz de confusión, precision y recall

Cuando clasificas, la exactitud (accuracy) no cuenta toda la historia. Imagina un detector de fraude: el 99 % de las transacciones son legítimas. Un modelo que diga «no fraude» siempre tendrá un 99 % de accuracy. Y será completamente inútil.

La matriz de confusión desglosa lo que realmente ocurre:

	Predicho: positivo	Predicho: negativo
Real: positivo	TP (verdadero positivo)	FN (falso negativo)
Real: negativo	FP (falso positivo)	TN (verdadero negativo)

De aquí salen las métricas que importan:

Precision: de todo lo que el modelo dijo «positivo», ¿cuánto era realmente positivo? TP / (TP + FP). Si predice fraude, ¿cuántas alertas son fraudes reales?
Recall (sensibilidad): de todo lo que era realmente positivo, ¿cuánto detectó el modelo? TP / (TP + FN). De todos los fraudes, ¿cuántos capturaste?
F1: media armónica de precision y recall. Útil cuando necesitas un equilibrio entre ambas.

La elección entre precision y recall depende del coste del error. En detección de fraude, un FN (dejar pasar un fraude) puede costar miles de euros; un FP (bloquear una compra legítima) puede costar un cliente. En diagnóstico médico, un FN (no detectar una enfermedad) puede costar una vida. No optimices accuracy a ciegas: optimiza la métrica que refleja el coste real del error en tu dominio.

Baseline, umbral y calibración

Un modelo no se evalúa en el vacío. Se evalúa contra una baseline: una regla simple que representa “lo mínimo que habría que superar”. Puede ser predecir siempre la clase mayoritaria, una regla de negocio escrita a mano o el sistema actual. Si tu modelo complejo no mejora claramente esa baseline en la métrica que importa, no has ganado ingeniería; has añadido complejidad.

Después viene el umbral. Muchos clasificadores no devuelven directamente una clase, sino una puntuación o probabilidad: “este ticket tiene 0,73 de probabilidad de ser urgente”. Convertir 0,73 en una acción exige una política: con umbral 0,5 quizá escalas demasiados tickets; con 0,9 quizá dejas pasar incidencias graves. El umbral no se elige por estética, sino por coste de FP y FN.

Y si vas a usar la probabilidad como probabilidad, necesitas calibración. Un modelo está bien calibrado si, entre todos los casos donde dice 0,8, aproximadamente el 80 % acaba siendo positivo.⁶ Esto importa cuando una puntuación dispara una acción real: revisión manual, bloqueo, reembolso, alerta médica, priorización de SLA. Un modelo puede ordenar bien los casos y aun así mentir en la escala de sus probabilidades.

Clustering: agrupar sin etiquetas

A veces no tienes etiquetas, pero sospechas que tus datos tienen estructura. El clustering agrupa instancias por similitud. El algoritmo más sencillo y usado es k-means:⁷

Elige K (el número de grupos que quieres encontrar).
Coloca K centroides aleatoriamente.
Asigna cada punto al centroide más cercano.
Recalcula los centroides como la media de los puntos asignados.
Repite hasta que los centroides se estabilizan.

Es simple, rápido y funciona sorprendentemente bien. Pero tiene trampas:

Tienes que elegir K. Si no sabes cuántos grupos hay, toca probar. Los métodos del codo (elbow) y la silueta (silhouette) ayudan, pero no sustituyen el criterio.
La distancia importa. Normalmente se usa distancia euclídea. Si una feature tiene valores en millones y otra entre 0 y 1, la primera domina completamente la agrupación. Normaliza.
La semilla importa. Distintas inicializaciones dan distintos resultados. No te cases con la primera agrupación que veas.

Cuándo no confiar en clusters. Que el algoritmo encuentre grupos no significa que esos grupos signifiquen algo. Un cluster puede ser un artefacto de la métrica de distancia, de una feature mal escalada o del azar. Valida siempre contra conocimiento del dominio: ¿tienen sentido esos grupos para quien conoce el negocio? Si no puedes explicar qué tienen en común los miembros de un cluster, probablemente no sea un hallazgo, sino ruido.

En el día a día

¿Tu problema es supervisado? Clasificación si la salida es una categoría, regresión si es un número. Empieza con una regresión logística o un árbol de decisión antes de saltar a redes neuronales.
¿No tienes etiquetas? Clustering para explorar, detección de anomalías para encontrar lo raro, reducción de dimensionalidad para visualizar.
¿Pocos datos? ML clásico. Los árboles, las SVMs y los ensembles funcionan con cientos o miles de ejemplos. El deep learning empieza a brillar con decenas de miles.
¿Necesitas explicar tus decisiones? Un árbol de decisión te dice exactamente por qué clasificó algo como lo clasificó. Una red neuronal de cien capas, no.

Por qué debería importarte

El deep learning no ha dejado obsoleto al ML clásico. Lo ha complementado. Para muchos problemas —especialmente con datos tabulares y pocos ejemplos—, un random forest o una regresión logística siguen siendo más rápidos, más baratos y más interpretables que cualquier red neuronal.

Además, el ML clásico te da el vocabulario para medir. Precision, recall, overfitting, cross-validation: estos conceptos no desaparecen cuando usas LLMs. Se vuelven más importantes. Un agente de IA que clasifica tickets de soporte necesita una matriz de confusión igual que un clasificador de spam de 2005.

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Medir solo accuracy	En conjuntos desbalanceados (1 % de fraude, 99 % legítimo), un modelo que siempre dice «legítimo» tiene 99 % de accuracy y es completamente inútil.	Mira precision, recall y F1. Si las clases están desbalanceadas, accuracy no te dice nada.
No separar train/validation/test	Si usas los mismos datos para entrenar y evaluar, el modelo parece perfecto... hasta que lo pones en producción.	Separa antes de tocar nada. Test se toca una sola vez, al final.
Ignorar la escala de las features	En k-means (y en cualquier algoritmo basado en distancia), una feature con valores grandes domina a las demás.	Normaliza o estandariza tus features antes de entrenar.
Interpretar clusters como realidades objetivas	El algoritmo siempre encuentra grupos, aunque los datos sean ruido puro.	Valida contra conocimiento del dominio. Si los grupos no tienen sentido para el negocio, no los uses para decidir.

Manos a la obra

La práctica está en kit descargable. Entrena una regresión logística pequeña sin dependencias externas sobre un dataset de tickets de soporte y la compara contra una baseline de mayoría.

No usamos scikit-learn en el primer paso porque aquí interesa ver el engranaje: separación train/test, normalización de features, entrenamiento, matriz de confusión, precision, recall y F1. Después podrás usar librerías profesionales; primero conviene entender qué están calculando.

Archivo	Qué contiene
`Makefile`	Atajos para ejecutar, probar y limpiar.
`requirements.txt`	Declara que el ejercicio usa solo Python estándar.
`data/support_tickets.csv`	Tickets con horas abiertas, tipo de cliente, SLA, incidentes, urgencia y etiqueta.
`contracts/ml_classic_policy.json`	Umbrales de recall, F1, threshold y regla frente a baseline.
`ops/run_ml_classic_baseline.py`	Regresión logística desde cero y cálculo de métricas.
`tests/test_ml_classic_baseline.py`	Comprueba que se compara contra mayoría y se calcula matriz de confusión.
`output/ml_classic_report.json`	Métricas, pesos, predicciones y matriz de confusión.
`output/ml_classic_decision.md`	Informe de decisión.

Ejecuta:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
python3 ops/run_ml_classic_baseline.py --write
cat output/ml_classic_decision.md

Valida el kit:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

Después añade cinco tickets propios. No busques que el modelo quede perfecto: busca que el ejercicio te obligue a decidir. Si un falso negativo significa que un cliente con SLA se queda sin atender, el recall pesa más que la accuracy. Si un falso positivo solo crea una revisión manual barata, quizá lo aceptas. La métrica nace del coste del error.

Qué entregaría un alumno. El Markdown generado, cinco filas nuevas en el CSV, el resultado de make test, una matriz de confusión explicada en lenguaje operativo y una decisión: usar baseline, probar otro modelo, recoger más datos o no automatizar.

Cuando el mecanismo esté claro, rehacer este mismo ejercicio con scikit-learn es natural: LogisticRegression, RandomForestClassifier, SVC, validación cruzada y calibración. Pero la primera práctica no debe esconder el concepto detrás de una llamada de librería.

Cómo encaja todo

Este mapa se lee desde la decisión, no desde el algoritmo. Venimos de los principios del capítulo 3 y de las pérdidas del capítulo 7, pero aquí aparece la disciplina que seguirá en todo el libro: definir salida, baseline, validación y métrica antes de enamorarse de una arquitectura.

Lo que se aprende en este capítulo vuelve después en evaluación de LLMs, calibración, interpretabilidad y operación. Un sistema con agentes o RAG también necesita train/test mental: qué casos pruebo, qué métrica acepto, qué coste tiene cada error y cuándo prefiero una regla simple.

graph TD
    subgraph "Hereda de F1"
        PRINC["Paradigmas de aprendizaje\n(cap. 3)"]
        LOSS["Pérdida y optimizadores\n(cap. 7)"]
        EMB["Embeddings y similitud\n(cap. 9)"]
    end

    subgraph "Capítulo 11: criterio ML clásico"
        QUESTION["Pregunta de decisión"]
        TARGET["Salida: clase, número o grupo"]
        SPLIT["Train / validation / test"]
        BASELINE["Baseline"]
        METRICS["Métricas + coste del error"]
        THRESHOLD["Umbral y calibración"]
        MODEL["Modelo clásico"]
    end

    subgraph "Se reutiliza después"
        EVALS["Evaluación de sistemas IA\n(fasc. 7)"]
        INTERP["Interpretabilidad\n(fasc. 7)"]
        OPS["Monitorización y drift\n(fasc. 6)"]
    end

    PRINC -->|"ayuda a formular"| QUESTION
    QUESTION -->|"define"| TARGET
    TARGET -->|"exige separar"| SPLIT
    SPLIT -->|"permite comparar contra"| BASELINE
    LOSS -->|"entrena"| MODEL
    MODEL -->|"se acepta solo si mejora"| BASELINE
    MODEL -->|"se juzga con"| METRICS
    METRICS -->|"elige"| THRESHOLD
    EMB -->|"también puede alimentar"| MODEL
    THRESHOLD -->|"anticipa"| EVALS
    MODEL -->|"necesita explicar"| INTERP
    SPLIT -->|"se vigila tras desplegar"| OPS

    style PRINC stroke-dasharray: 5 5
    style LOSS stroke-dasharray: 5 5
    style EMB stroke-dasharray: 5 5
    style EVALS stroke-dasharray: 5 5
    style INTERP stroke-dasharray: 5 5
    style OPS stroke-dasharray: 5 5

Vocabulario aprendido

Término	Definición
Clasificación	Tarea supervisada donde la salida es una categoría discreta entre un conjunto predefinido de clases.
Regresión	Tarea supervisada donde la salida es un valor numérico continuo.
Overfitting	El modelo memoriza los datos de entrenamiento y no generaliza a datos nuevos.
Underfitting	El modelo es demasiado simple para capturar los patrones de los datos.
Matriz de confusión	Tabla que cruza predicciones con valores reales, desglosando aciertos, falsos positivos y falsos negativos.
Precision	Proporción de predicciones positivas que son realmente correctas.
Recall	Proporción de casos positivos reales que el modelo detectó.
Baseline	Regla o sistema simple que el modelo debe superar para justificar su complejidad.
Calibración	Grado en que las probabilidades predichas se corresponden con frecuencias reales observadas.
Clustering	Técnica no supervisada que agrupa instancias por similitud sin etiquetas predefinidas.

Antes de pasar página

¿Puedo distinguir entre clasificación y regresión con ejemplos concretos? (Si no, vuelve a «Clasificación vs regresión».)
¿Sé interpretar una matriz de confusión? (Si no, vuelve a «Matriz de confusión».)
¿Entiendo la diferencia entre precision y recall? (Si no, vuelve a esa sección.)
¿Puedo explicar qué baseline usaría y qué umbral elegiría si el coste de FP y FN cambia? (Si no, vuelve a «Baseline, umbral y calibración».)
¿Puedo explicar qué es el overfitting y cómo detectarlo? (Si no, vuelve a «Overfitting y underfitting».)
¿He ejecutado kit descargable y puedo interpretar precision, recall, F1 y falsos negativos? (Si no, vuelve a «Manos a la obra».)

En resumen

Idea fuerza	Detalle
El ML clásico no ha muerto.	Para datos tabulares, pocos ejemplos o necesidad de explicabilidad, los árboles y las regresiones siguen siendo la mejor opción.
La pregunta no es «qué modelo», sino «qué salida, qué señal, cómo mido».	Define el problema antes de elegir la herramienta. Clasificación, regresión, clustering: cada uno tiene sus métricas.
Las métricas correctas dependen del coste del error.	No optimices accuracy a ciegas. Un FN en diagnóstico médico no vale lo mismo que un FP en recomendaciones de películas.
Una probabilidad no es una decisión hasta que eliges baseline, umbral y calibración.	Si el modelo no supera una regla simple o sus probabilidades no son fiables, todavía no tienes un sistema defendible.
El clustering encuentra estructura, no significado.	Valida siempre contra conocimiento del dominio. Un grupo no es un hallazgo hasta que alguien que conoce el negocio dice «esto tiene sentido».

Para saber más

Bishop, C. M. (2006). Pattern recognition and machine learning. Springer.

Breiman, L. (2001). Random forests. Machine Learning, 45(1), 5-32. https://doi.org/10.1023/A:1010933404324

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

Guo, C., Pleiss, G., Sun, Y. y Weinberger, K. Q. (2017). On calibration of modern neural networks. En Proceedings of the 34th International Conference on Machine Learning (pp. 1321-1330). PMLR. https://proceedings.mlr.press/v70/guo17a.html

Hastie, T., Tibshirani, R. y Friedman, J. (2009). The elements of statistical learning (2.ª ed.). Springer. https://web.stanford.edu/~hastie/ElemStatLearn/

LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539

MacQueen, J. (1967). Some methods for classification and analysis of multivariate observations. En Proceedings of the 5th Berkeley Symposium on Mathematical Statistics and Probability (Vol. 1, pp. 281-297). https://projecteuclid.org/euclid.bsmsp/1200512992

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Notas

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson. Los capítulos 18 a 21 cubren los paradigmas de aprendizaje y establecen el marco conceptual para clasificar cualquier problema de ML según el tipo de datos y retroalimentación disponible. ↩
Bishop, C. M. (2006). Pattern recognition and machine learning. Springer. El capítulo 1 establece los fundamentos de la teoría de la probabilidad y la decisión, y define la terminología básica de datasets, features y variables objetivo. ↩
Hastie, T., Tibshirani, R. y Friedman, J. (2009). The elements of statistical learning (2.ª ed.). Springer. https://web.stanford.edu/~hastie/ElemStatLearn/. El capítulo 2 ofrece una visión general de aprendizaje supervisado y establece la distinción fundamental entre problemas de clasificación y regresión. ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org. El capítulo 5.2 aborda las técnicas de validación y la importancia de separar correctamente los conjuntos de entrenamiento, validación y prueba para obtener estimaciones fiables del rendimiento. ↩
Breiman, L. (2001). Random forests. Machine Learning, 45(1), 5-32. https://doi.org/10.1023/A:1010933404324. Breiman demostró que los ensembles de árboles de decisión, como los random forests, mitigan el overfitting al promediar múltiples modelos entrenados con subconjuntos distintos de datos. ↩
Guo, C., Pleiss, G., Sun, Y. y Weinberger, K. Q. (2017). On calibration of modern neural networks. En Proceedings of the 34th International Conference on Machine Learning (pp. 1321-1330). PMLR. https://proceedings.mlr.press/v70/guo17a.html. El artículo muestra que modelos modernos pueden tener alta exactitud y estar mal calibrados, por lo que sus probabilidades no deben interpretarse sin comprobación. ↩
MacQueen, J. (1967). Some methods for classification and analysis of multivariate observations. En Proceedings of the 5th Berkeley Symposium on Mathematical Statistics and Probability (Vol. 1, pp. 281-297). https://projecteuclid.org/euclid.bsmsp/1200512992. MacQueen introdujo el algoritmo k-means, que sigue siendo uno de los métodos de clustering más utilizados por su simplicidad y eficiencia computacional. ↩

Capítulo 12

Facsímil 1 · Los cimientos

Capítulo 12: Lo que deberías saber: recapitulación de fundamentos

Entrando en el tema

Has recorrido once capítulos convertidos en una lectura lenta. Has construido una neurona, entrenado una red, propagado errores hacia atrás, tokenizado texto, explorado embeddings y contrastado paradigmas de aprendizaje.

Este capítulo no es un resumen. Es una revisión activa: cada sección recupera un concepto nuclear, lo reformula desde otro ángulo, lo conecta con el resto y te confronta con una pregunta. Si algo no te suena, el número de capítulo te dice exactamente dónde volver.

No es un examen. Es un espejo. Si te reconoces en estas páginas, puedes avanzar al facsímil 2.

1. Qué es y qué no es la IA

El concepto. La inteligencia artificial no es consciente, no «piensa» y no es infalible. Es un sistema de predicción estadística de tokens que opera sobre patrones aprendidos de cantidades masivas de datos.¹ La confusión entre elocuencia y corrección es el error más caro que puedes cometer al diseñar sistemas con IA.²

Para recordar. Cada vez que un LLM te responde con frases impecables, recuerda: está generando tokens a partir de patrones aprendidos, no deliberando como una persona que contrasta el mundo. La confianza con la que afirma algo no guarda relación directa con la veracidad de lo que afirma.

Ejemplo fresco. Imagina que le pides a un LLM que calcule 1573 × 2849. Si le obligas a descomponer el cálculo paso a paso, aumentas las probabilidades de que cada parte sea coherente y verificable. Si le pides la respuesta directa, puede inventarse un número con total seguridad. No es que «sepa multiplicar» o «no sepa»: es que el contexto y el procedimiento que le das cambian la distribución de tokens que generará.

Vuelve al capítulo 1 si: no puedes explicar por qué la IA no es un oráculo ni un buscador.

2. Sistemas deterministas frente a sistemas probabilísticos

El concepto. sumar(2, 3) siempre devuelve 5. preguntar("¿Qué es Rust?") puede devolver tres respuestas distintas, todas correctas. En IA generativa, la variabilidad suele aparecer en el muestreo, en la configuración de inferencia y en el sistema que rodea al modelo.³ Esto cambia cómo diseñas, cómo testeas y cómo despliegas.

Para recordar. No puedes hacer assert respuesta == "Rust es un lenguaje...". Validarás propiedades: ¿contiene las palabras clave?, ¿respeta el formato?, ¿menciona los conceptos correctos? El cambio de mentalidad —de igualdad exacta a validación de propiedades— es el paso más importante al trabajar con IA.

Ejemplo fresco. Un sistema de atención al cliente usa un LLM para clasificar la urgencia de tickets. Dos ejecuciones con el mismo ticket pueden dar «urgente» y «normal». Si tu sistema despacha automáticamente basándose en esa clasificación, necesitas un umbral de confianza y, probablemente, revisión humana para los casos límite. La variabilidad no es un bug: es una característica del sistema que debes diseñar.

Vuelve al capítulo 2 si: no puedes explicar por qué temperature = 0 no garantiza determinismo absoluto.

3. Los cinco principios

El concepto. Cinco ideas sostienen la IA moderna: aprendizaje supervisado (ejemplos etiquetados), no supervisado (encontrar estructura sin etiquetas), post-training (enseñar preferencias), atención (mirar todo a la vez) y scaling laws (relaciones empíricas entre datos, parámetros, cómputo y pérdida).⁴

Para recordar. No son compartimentos estancos. Un LLM se pre-entrena con aprendizaje auto-supervisado, se post-entrena con SFT (supervisado) y RLHF (refuerzo), y su arquitectura se basa en la atención. Las scaling laws ayudan a razonar sobre tendencias de escala bajo condiciones concretas; no sustituyen la evaluación de tu tarea, tu coste y tus datos.

Ejemplo fresco. Cuando OpenAI entrena un nuevo modelo, no es un solo paso. Primero, pre-entrenamiento masivo sobre texto de internet (auto-supervisado). Luego, SFT con conversaciones de alta calidad escritas por personas (supervisado). Finalmente, RLHF donde personas comparan respuestas (refuerzo). Tres paradigmas encadenados. La arquitectura Transformer con atención es el soporte que hace posibles los tres.

Vuelve al capítulo 3 si: no puedes nombrar los cinco principios y dar un ejemplo de cada uno.

4. La neurona artificial

El concepto. Una neurona artificial es una función matemática: y = f(Σ wᵢxᵢ + b). Entradas multiplicadas por pesos, sumadas, más un sesgo, pasadas por una función de activación.⁵ Tres líneas de código. El átomo del deep learning.⁶

Para recordar. La inteligencia no está en una neurona. Está en los miles de millones de parámetros ajustados durante el entrenamiento a lo largo de capas y capas de neuronas interconectadas. Pero la unidad mínima es siempre la misma.

Ejemplo fresco. ¿Cuántas neuronas se activan cuando escribes «Buenos días» en ChatGPT? Cada token de entrada atraviesa todas las capas del modelo. En un modelo de 70B parámetros, una sola predicción involucra miles de millones de operaciones y = f(Σ wᵢxᵢ + b). Tu «Buenos días» desencadena una cascada de multiplicaciones y sumas que recorre toda la red en milisegundos.

Vuelve al capítulo 4 si: no puedes escribir la fórmula de memoria y calcular la salida para x₁=0.5, x₂=0.3, w₁=0.2, w₂=-0.4, b=0.1 con activación ReLU.

5. Redes neuronales: capas y arquitectura

El concepto. Una red neuronal es un grafo de neuronas organizadas en capas.⁷ Cada capa transforma los datos y los pasa a la siguiente. Las primeras capas detectan patrones simples; las profundas, conceptos abstractos.⁸

Para recordar. «Deep» significa «muchas capas». Más capas permiten más abstracción, pero también requieren más datos, más computación y técnicas para evitar que el gradiente se desvanezca. La arquitectura determina lo que la red puede aprender.

Ejemplo fresco. Un MLP de 3 capas puede clasificar dígitos escritos a mano (MNIST). Un Transformer de 96 capas puede mantener una conversación de una hora. La neurona es la misma en ambos. Lo que cambia es la organización. La arquitectura es la decisión de diseño más importante después de elegir los datos.

Vuelve al capítulo 5 si: no puedes dibujar la estructura de una red con capa de entrada, dos ocultas y una de salida, y explicar qué aprende cada capa.

6. Retropropagación

El concepto. La retropropagación aplica la regla de la cadena para propagar el error desde la salida hacia atrás.⁹ Para cada peso, calcula ∂E/∂w: cuánto cambia el error si modifico este peso. La fórmula completa:

\frac{\partial E}{\partial w} = \frac{\partial E}{\partial a} \cdot \sigma'(z) \cdot x

Para recordar. El gradiente dice «dirección y sensibilidad». El learning rate dice «tamaño del paso». Actualizamos con signo menos porque queremos reducir el error, no aumentarlo. La regla w ← w - η · ∂E/∂w es la ecuación más importante del deep learning.

Ejemplo fresco. En el capítulo 6 calculaste que con x=2, w=0.40, b=-0.10, y=1, η=0.1, el gradiente ∂E/∂w = -0.148. Tras la actualización, w = 0.415. La nueva predicción se acerca más a 1. Una iteración. Millones por delante. Esto —multiplicado por miles de millones de parámetros y repetido durante semanas en clústeres de GPUs— es como se entrena un LLM.

Vuelve al capítulo 6 si: no puedes calcular a mano el gradiente para el ejemplo anterior.

7. Funciones de pérdida y optimizadores

El concepto. La función de pérdida define qué significa «equivocarse». El optimizador decide cómo corregirlo.¹⁰ Cross-entropy para clasificar, MSE para regresión. SGD es simple, Adam es adaptativo, AdamW es el estándar para Transformers.¹¹

Para recordar. La elección de la función de pérdida es la especificación formal de tu objetivo. Si usas MSE para clasificar, el modelo optimizará la distancia numérica entre probabilidades, no la probabilidad de la clase correcta. Aprenderá algo, pero no lo que quieres.

Ejemplo fresco. Tienes que clasificar 10 000 tickets de soporte en 5 categorías. Si usas MSE, el modelo tratará la diferencia entre «categoría 1» y «categoría 2» como numéricamente equivalente a la diferencia entre «categoría 1» y «categoría 5», lo cual no tiene sentido para categorías nominales. Cross-entropy con softmax respeta que las categorías son discretas y no ordenadas.

Vuelve al capítulo 7 si: no puedes explicar cuándo usar cross-entropy y cuándo MSE.

8. CNNs y RNNs

El concepto. Las CNNs detectan patrones locales en imágenes mediante filtros convolucionales.¹² Las RNNs procesan secuencias manteniendo un estado oculto. Las LSTMs añaden compuertas para recordar más tiempo.¹³ El Transformer las superó con paralelismo y atención directa.¹⁴

Para recordar. Cada limitación que el Transformer resolvió era una limitación real de las RNNs. El estado oculto no bastaba para contexto largo. El procesamiento secuencial era demasiado lento. La atención directa y el paralelismo fueron las respuestas.

Ejemplo fresco. Procesar «El gato que perseguía al ratón que robó el queso que estaba en la cocina es negro» con una RNN: cuando llega a «es negro», el estado oculto ya ha sido sobrescrito decenas de veces y probablemente ha olvidado que el sujeto era «gato». Con un Transformer, la atención conecta directamente «negro» con «gato» sin importar cuántas palabras haya en medio.

Vuelve al capítulo 8 si: no puedes comparar CNN, RNN, LSTM y Transformer en una frase cada una.

9. Tokens y embeddings

El concepto. Un token es la unidad mínima de texto que procesa el modelo.¹⁵ Un embedding es un vector denso de números que representa el significado de un token en un espacio de alta dimensionalidad.¹⁶ Los embeddings son el pegamento entre el mundo del texto y el mundo de las matemáticas.

Para recordar. El español gasta más tokens que el inglés. «Machine learning is great» son 4 tokens; «El aprendizaje automático es genial» son 7-8. Todo se mide en tokens: contexto, precio, límites. Y la similitud coseno es la medida estándar para comparar embeddings.

Ejemplo fresco. Construyes un buscador semántico para documentación interna. Conviertes 5 000 documentos a embeddings (modelo text-embedding-3-small, 1536 dimensiones). Cuando un empleado busca «cómo solicitar vacaciones», el sistema compara el embedding de la consulta con los 5 000 embeddings de documentos y devuelve los más cercanos por similitud coseno. Encuentra la política de vacaciones aunque la consulta no comparta ni una palabra con el título del documento.

Vuelve al capítulo 9 si: no puedes explicar la diferencia entre token y embedding, y para qué sirve cada uno.

10. Entrenamiento frente a inferencia

El concepto. Entrenar es cambiar pesos con datos y una función de pérdida. Pre-entrenar un modelo fundacional puede requerir semanas, clústeres enormes y presupuestos altísimos; entrenar modelos pequeños o ajustar adaptadores puede ser mucho más accesible.¹⁷ Inferir es usar pesos ya entrenados para responder. La cuantización reduce la precisión numérica de los pesos (FP16 → INT4) para que un modelo de 14 GB quepa en 3,5 GB.

Para recordar. Casi siempre harás inferencia, evaluación, RAG, integración o ajuste parcial antes que pre-entrenamiento de frontera. El fine-tuning está a medio camino. Y la cuantización es una herramienta para mover modelos a hardware más modesto, siempre que evalúes la pérdida de calidad en tu tarea.

Ejemplo fresco. Descargas un modelo de 7B parámetros en formato GGUF (cuantizado a 4 bits). Ocupa 3,5 GB. Lo ejecutas en tu portátil con llama.cpp, sin GPU, sin conexión a internet. La calidad es ligeramente inferior al modelo original en FP16, pero para resumir documentos internos, clasificar correos o generar primeras versiones, funciona perfectamente. Has pasado de depender de una API a tener el modelo en local.

Vuelve al capítulo 10 si: no puedes explicar la diferencia entre entrenamiento, inferencia, fine-tuning y cuantización.

11. Machine learning clásico

El concepto. Antes del deep learning —y todavía hoy para la mayoría de problemas— existe el ML clásico.¹⁸ Clasificación, regresión, clustering, validación, matriz de confusión, precision, recall: este vocabulario no desaparece con los LLMs, se vuelve más importante.

Para recordar. La pregunta no es «¿qué modelo uso?» sino «¿qué salida necesito, qué señal tengo y cómo sé que generaliza?». Un random forest con 500 árboles puede ser más rápido, más barato y más interpretable que una red neuronal para tu problema concreto.¹⁹

Ejemplo fresco. Tienes 2 000 transacciones etiquetadas (147 operaciones irregulares, 1 853 legítimas). Un random forest te da 94 % de recall en la clase irregular (detectas 138 de 147) con 3 % de falsos positivos. Entrenar tarda 3 segundos. No necesitas GPU. Puedes explicar exactamente qué features usa el modelo para decidir. ¿Necesitas un LLM para esto?

Vuelve al capítulo 11 si: no puedes definir precision, recall y explicar cuándo importa más uno que otro.

Cómo encaja todo

Este mapa no intenta repetir el facsímil entero. Léelo como una escalera: primero aclaramos qué puede y qué no puede hacer la IA, después construimos el mecanismo que aprende, luego convertimos texto e imágenes en representaciones matemáticas y, al final, aprendemos a usar, medir y comparar modelos.

La salida natural de este mapa es el facsímil 2. Allí la pregunta deja de ser «qué es un modelo» y pasa a ser «cómo busca, decide y planifica un sistema cuando tiene varias acciones posibles».

flowchart TD
  subgraph f1["Facsímil 01 · Los cimientos"]
    C01["01 · Qué es IA<br/>predicción, límites, no oráculo"]:::chapter
    C02["02 · Determinismo vs probabilidad<br/>variabilidad, validación por propiedades"]:::chapter
    C03["03 · Principios<br/>supervisado, no supervisado, post-training, atención, escala"]:::chapter
    C04["04 · Neurona<br/>suma ponderada, sesgo, activación"]:::chapter
    C05["05 · Redes<br/>capas, arquitectura, representaciones"]:::chapter
    C06["06 · Retropropagación<br/>gradiente y regla de la cadena"]:::chapter
    C07["07 · Pérdida y optimización<br/>objetivo, actualización, Adam"]:::chapter
    C08["08 · CNN, RNN, Transformer<br/>estructuras para visión y secuencia"]:::chapter
    C09["09 · Tokens y embeddings<br/>texto convertido en vectores"]:::chapter
    C10["10 · Entrenamiento e inferencia<br/>crear, usar, ajustar, cuantizar"]:::chapter
    C11["11 · ML clásico<br/>métricas, generalización, baseline"]:::chapter
    C12["12 · Recapitulación<br/>criterio antes de avanzar"]:::lab
  end

  subgraph puente["Puente al facsímil 02"]
    S["Búsqueda y estados"]:::next
    A["Agentes y planificación"]:::next
    E["Evaluación de decisiones"]:::next
  end

  C01 --> C02 --> C03
  C03 --> C04 --> C05 --> C06 --> C07
  C07 --> C08 --> C09 --> C10 --> C11 --> C12
  C02 --> C11
  C09 --> C10
  C11 --> E
  C12 --> S
  C12 --> A
  C12 --> E

  classDef chapter fill:#f7f7f7,stroke:#111,color:#111;
  classDef lab fill:#111,stroke:#111,color:#fff;
  classDef next fill:#fff,stroke:#111,stroke-dasharray:6 4,color:#111;

Dónde solía tropezar yo

Error	Por qué es un error	Antídoto
Creer que recordar títulos es entender el facsímil	Puedes recitar “tokens, embeddings, backpropagation” y aun así no saber conectar las piezas.	Reexplica cada capítulo con un ejemplo propio y una fórmula mínima cuando exista.
Saltar al facsímil 2 con cimientos flojos	La búsqueda, los agentes y la planificación se apoyan en los conceptos de coste, error, representación y evaluación.	Si fallas una pregunta de la checklist, vuelve al capítulo concreto antes de seguir.
Confundir uso práctico con comprensión	Saber llamar a una API no implica entender inferencia, tokens, embeddings o evaluación.	Para cada herramienta que uses, escribe qué entrada transforma, qué salida produce y cómo medirías si funciona.
No medir	Sin métricas, cualquier demo parece buena hasta que falla en producción.	Antes de avanzar, identifica para cada sistema qué métrica usarías: pérdida, precisión, recall, coste o latencia.

Vocabulario aprendido

Término	Qué deberías poder explicar ya
Inteligencia artificial	Sistema que transforma entradas en salidas útiles aprendiendo patrones, no una entidad consciente ni un oráculo.
Sistema probabilístico	Sistema cuya salida puede variar porque trabaja con distribuciones, muestreo e incertidumbre.
Neurona artificial	Función que combina entradas, pesos, sesgo y activación para producir una señal.
Red neuronal	Composición de muchas neuronas en capas que aprenden representaciones cada vez más útiles.
Gradiente	Dirección matemática que indica cómo cambiar un parámetro para modificar la pérdida.
Función de pérdida	Medida formal de error que define qué intenta mejorar el entrenamiento.
Token	Unidad mínima de texto que procesa un modelo de lenguaje.
Embedding	Vector numérico que representa texto, imagen u otra señal en un espacio matemático.
Inferencia	Uso de un modelo ya entrenado para producir una salida ante una entrada nueva.
Métrica	Medida que permite decidir si un modelo funciona para el objetivo real, no solo si parece convincente.

Antes de pasar página

Responde sin consultar los capítulos. Sé honesto con tu propio nivel: si fallas, el número te dice dónde volver.

Diagnóstico: 10-12 respuestas sólidas: puedes avanzar al facsímil 2. 7-9: repasa los capítulos que fallaste. Menos de 7: vuelve a leer el facsímil con calma. No hay prisa. Los cimientos son eso: cimientos.

En resumen

Idea fuerza	Detalle
La IA es predicción estadística, no conciencia.	Cada decisión de ingeniería depende de entender esto.
La neurona es el átomo, la red la molécula, la retropropagación el motor.	`y = f(Σ wᵢxᵢ + b)` → capas → `∂E/∂w` → `w ← w - η·∂E/∂w`. Todo se reduce a esto.
Los embeddings son el puente entre texto y matemáticas.	Sin ellos, las redes no podrían procesar lenguaje.
El ML clásico no ha muerto.	Para datos tabulares, pocos ejemplos o necesidad de explicabilidad, sigue siendo la mejor opción.
Si no sabes medir, no sabes si funciona.	Precision, recall, F1, validación, overfitting: el vocabulario para saber si tu modelo sirve.

Para saber más

Breiman, L. (2001). Random forests. Machine Learning, 45(1), 5-32. https://doi.org/10.1023/A:1010933404324

Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org

Hastie, T., Tibshirani, R. y Friedman, J. (2009). The elements of statistical learning (2.ª ed.). Springer. https://web.stanford.edu/~hastie/ElemStatLearn/

Kaplan, J. et al. (2020). Scaling laws for neural language models. arXiv:2001.08361. https://doi.org/10.48550/arXiv.2001.08361

Kingma, D. P. y Ba, J. (2015). Adam: a method for stochastic optimization. En International Conference on Learning Representations. https://arxiv.org/abs/1412.6980

LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539

McCulloch, W. S. y Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. The Bulletin of Mathematical Biophysics, 5(4), 115-133. https://doi.org/10.1007/BF02478259

Rosenblatt, F. (1958). The perceptron: a probabilistic model for information storage and organization in the brain. Psychological Review, 65(6), 386-408. https://doi.org/10.1037/h0042519

Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson.

Laboratorio

Un laboratorio, dentro de este libro, no es un examen escondido ni una lista de ejercicios para rellenar páginas. Es una mesa de trabajo. Aquí tomamos los conceptos del facsímil y los usamos para decidir, calcular, programar y explicar algo que se parece más a una situación real que a una pregunta de test.

En este primer laboratorio vamos a tocar cuatro cimientos:

Del capítulo 1 y el capítulo 2: una IA no es un oráculo determinista; produce salidas que hay que interpretar y verificar.
Del capítulo 7 y el capítulo 11: medir no es decorar el informe; medir es decidir qué significa que un sistema funcione.
Del capítulo 9: el texto puede convertirse en vectores y compararse matemáticamente.
Del capítulo 10: usar un modelo en inferencia tiene coste, límites y consecuencias de diseño.

La idea es que salgas de este facsímil con dos reflejos profesionales: no creerte una demo sin métricas y no hablar de embeddings como si fueran significado puro.

El kit real está en kit descargable. No es una ruta decorativa: en la versión web aparece como material descargable y contiene datos, contrato, scripts, solución de referencia y tests.

Ejecuta:

# Descomprime el ZIP del capítulo y ejecuta estos comandos dentro de esa carpeta
make run
make test

make run genera los artefactos de los dos retos y valida una solución de referencia. make test comprueba que el clasificador no se elige solo por una métrica bonita, que el buscador semántico deja trazas auditables y que el checker detecta una entrega completa.

Qué produce:

Archivo	Qué demuestra
`Makefile`	Punto de entrada reproducible para ejecutar y probar la práctica.
`requirements.txt`	Dependencias declaradas; aquí solo biblioteca estándar de Python 3.10+.
`tests/test_laboratorio_fundamentos.py`	Pruebas de regresión para métricas, trazas y entrega.
`output/classifier_metrics.json`	Precision, recall, F1 y cola prioritaria de cada modelo.
`output/classifier_decision.md`	Decisión operativa teniendo en cuenta capacidad diaria.
`output/semantic_search_report.json`	Hit@1, MRR y cobertura de trazas del mini buscador.
`output/semantic_search_decision.md`	Lectura técnica de los resultados.
`output/semantic_search_traces.jsonl`	Tokenización, vectorización, scoring y ranking por consulta.

Si quieres validar una entrega propia, copia esos cinco artefactos a una carpeta y ejecuta ops/check_student_submission.py contra ella. El checker no sustituye tu explicación, pero evita entregas vacías.

Reto 1: decidir si un clasificador sirve para revisar tickets

Contexto

Imagina que trabajas en un equipo que recibe tickets internos: problemas de acceso, dudas de facturación, solicitudes administrativas y preguntas técnicas. Queréis usar un modelo para marcar automáticamente los tickets que conviene revisar pronto.

La clase positiva será:

"Este ticket debe revisarse pronto".

El modelo no cierra tickets, no responde al usuario y no toma decisiones irreversibles. Solo ayuda a ordenar la cola. Aun así, si mide mal, puede hacer perder tiempo al equipo o dejar para más tarde tickets que sí necesitaban atención.

Objetivo

Tienes que comparar dos modelos candidatos y decidir cuál pondrías primero en producción. No basta con decir "el que tenga más aciertos". Debes justificarlo con métricas y con el contexto operativo.

Esto sale del capítulo 11, cuando hablamos de matriz de confusión, precision y recall. También sale del capítulo 2: al ser un sistema probabilístico, no esperamos igualdad exacta, sino comportamiento aceptable bajo incertidumbre.

Material base

Se evaluaron ambos modelos sobre 200 tickets ya revisados por una persona:

Modelo	Verdaderos positivos	Falsos positivos	Falsos negativos	Verdaderos negativos
Modelo A	44	28	6	122
Modelo B	36	8	14	142

Recuerda las fórmulas:

\text{precision} = \frac{TP}{TP + FP}

\text{recall} = \frac{TP}{TP + FN}

F1 = 2 \cdot \frac{\text{precision} \cdot \text{recall}}{\text{precision} + \text{recall}}

Símbolo	Significado	Ejemplo
$TP$	Casos marcados como importantes que sí lo eran	Ticket urgente marcado para revisión
$FP$	Casos marcados como importantes que no lo eran	Ticket normal que entra en la cola rápida
$FN$	Casos importantes que el modelo dejó pasar	Ticket que debería revisarse pronto y no se marcó
$TN$	Casos normales que el modelo dejó como normales	Ticket rutinario que no sube de prioridad

Enunciado

Calcula precision, recall y F1 para los dos modelos.
Calcula cuántos tickets enviaría cada modelo a revisión prioritaria.
Decide cuál usarías si el equipo puede revisar como máximo 60 tickets prioritarios al día.
Explica tu decisión a una persona que no viene de IA.

Resolución paso a paso

Primero calculamos el Modelo A.

\text{precision}_A = \frac{44}{44 + 28} = \frac{44}{72} \approx 0.61

\text{recall}_A = \frac{44}{44 + 6} = \frac{44}{50} = 0.88

F1_A = 2 \cdot \frac{0.61 \cdot 0.88}{0.61 + 0.88} \approx 0.72

El Modelo A manda a revisión prioritaria:

TP + FP = 44 + 28 = 72

Ahora calculamos el Modelo B.

\text{precision}_B = \frac{36}{36 + 8} = \frac{36}{44} \approx 0.82

\text{recall}_B = \frac{36}{36 + 14} = \frac{36}{50} = 0.72

F1_B = 2 \cdot \frac{0.82 \cdot 0.72}{0.82 + 0.72} \approx 0.77

El Modelo B manda a revisión prioritaria:

TP + FP = 36 + 8 = 44

Solución

Modelo	Precision	Recall	F1	Tickets enviados a revisión
Modelo A	0.61	0.88	0.72	72
Modelo B	0.82	0.72	0.77	44

Yo pondría primero el Modelo B si el límite real del equipo son 60 tickets prioritarios al día. Tiene mejor F1, genera menos ruido operativo y cabe dentro de la capacidad del equipo.

El Modelo A detecta más tickets importantes, porque su recall es mayor, pero manda 72 tickets a revisión. Si el equipo solo puede revisar 60, esos 12 tickets extra no desaparecen: se acumulan, retrasan la cola y pueden acabar empeorando el servicio. Aquí se ve una idea muy importante: una métrica no vive sola. Vive dentro de una operación real.

La decisión no significa que el Modelo A sea "malo". Significa que, con esta capacidad concreta, no es el primer candidato. Podría ser útil si aumentamos el equipo de revisión, si añadimos una segunda prioridad dentro de los 72 tickets o si el coste de dejar pasar un ticket importante fuera mucho más alto que el coste de revisar tickets de más.

Por qué funciona

Este reto junta tres ideas del facsímil:

Capítulo 1: una respuesta de IA no se acepta por sonar convincente; se verifica.
Capítulo 2: no pedimos determinismo perfecto, sino comportamiento medible.
Capítulo 11: precision y recall responden preguntas distintas. Precision pregunta "de lo que marco, cuánto acierto". Recall pregunta "de lo importante, cuánto encuentro".

La clave profesional está en no decir "el modelo tiene un 90 % de acierto" sin explicar qué se está midiendo. En problemas reales, un falso positivo y un falso negativo no cuestan lo mismo.

Cómo explicarlo a otra persona

"Tenemos dos ayudantes para ordenar tickets. El primero avisa de casi todo lo importante, pero también mete mucho ruido. El segundo avisa de menos casos importantes, pero cuando avisa suele tener razón y no satura al equipo. Como solo podemos revisar 60 tickets al día, empezaría con el segundo y seguiría midiendo."

Variaciones para seguir practicando

Cambia el límite de revisión diaria de 60 a 80 tickets. ¿Cambia tu decisión?
Imagina que cada falso negativo cuesta el triple que cada falso positivo. ¿Cómo lo justificarías?
Añade una tercera opción: usar el Modelo A solo para tickets de acceso y el Modelo B para el resto.

Reto 2: construir un mini buscador semántico para documentación interna

Contexto

Un equipo tiene seis documentos internos y quiere que la gente encuentre el documento correcto aunque no use las mismas palabras exactas. Alguien puede escribir "no puedo entrar en mi perfil" aunque el documento se llame "Restablecer contraseña y recuperar acceso a la cuenta".

En un proyecto real usarías un modelo de embeddings. Aquí construiremos una versión diminuta y transparente para ver la mecánica sin esconderla detrás de una API.

Objetivo

Vas a convertir textos en vectores, comparar esos vectores con similitud coseno y devolver los documentos más parecidos a una consulta.

Esto sale del capítulo 9, donde vimos tokens y embeddings. También conecta con el capítulo 10: en producción, esta búsqueda sería una inferencia sobre vectores ya calculados. Y conecta con el capítulo 11, porque luego podrías medir si el buscador devuelve el documento correcto.

Material base

Documentos disponibles:

ID	Documento
1	Restablecer contraseña y recuperar acceso a la cuenta
2	Cambiar tarjeta de pago y datos de facturación
3	Solicitar vacaciones y registrar una ausencia
4	Configurar doble factor de autenticación
5	Descargar factura mensual
6	Actualizar dirección de envío

Usaremos cinco dimensiones inventadas:

Dimensión	Qué representa
1	Acceso a cuenta
2	Pagos
3	Facturas
4	Personas y ausencias
5	Seguridad

No son embeddings reales. Son una maqueta pequeña. Precisamente por eso sirven: podemos ver los números.

Enunciado

Tokeniza cada texto.
Asigna a algunas palabras un vector de cinco dimensiones.
Calcula el vector medio de cada documento.
Calcula la similitud coseno entre la consulta y cada documento.
Devuelve los tres documentos más parecidos.

Resolución paso a paso

La similitud coseno mide si dos vectores apuntan en una dirección parecida:

\cos(\theta) = \frac{a \cdot b}{\|a\| \cdot \|b\|}

Símbolo	Significado	Ejemplo
$a$	Vector de la consulta	Vector de "no puedo entrar en mi perfil"
$b$	Vector de un documento	Vector de "Restablecer contraseña..."
$a \cdot b$	Producto escalar	Suma de multiplicar dimensión a dimensión
$\\|a\\|$	Longitud del vector $a$	Tamaño del vector de consulta
$\cos(\theta)$	Parecido entre los vectores	1 significa muy parecido; 0 significa casi sin relación

Ahora lo programamos con Python puro:

from math import sqrt
import re
import unicodedata

# Dimensiones: acceso, pagos, facturas, personas, seguridad.
word_vectors = {
    "contrasena": [1.00, 0.00, 0.00, 0.00, 0.10],
    "acceso": [1.00, 0.00, 0.00, 0.00, 0.10],
    "cuenta": [0.85, 0.00, 0.00, 0.00, 0.05],
    "entrar": [1.00, 0.00, 0.00, 0.00, 0.00],
    "perfil": [0.85, 0.00, 0.00, 0.00, 0.00],
    "login": [1.00, 0.00, 0.00, 0.00, 0.10],
    "autenticacion": [0.35, 0.00, 0.00, 0.00, 1.00],
    "factor": [0.20, 0.00, 0.00, 0.00, 1.00],
    "tarjeta": [0.00, 1.00, 0.10, 0.00, 0.00],
    "pago": [0.00, 1.00, 0.15, 0.00, 0.00],
    "facturacion": [0.00, 0.55, 0.80, 0.00, 0.00],
    "factura": [0.00, 0.10, 1.00, 0.00, 0.00],
    "recibo": [0.00, 0.05, 1.00, 0.00, 0.00],
    "mensual": [0.00, 0.00, 0.85, 0.00, 0.00],
    "mes": [0.00, 0.00, 0.85, 0.00, 0.00],
    "vacaciones": [0.00, 0.00, 0.00, 1.00, 0.00],
    "ausencia": [0.00, 0.00, 0.00, 1.00, 0.00],
    "permiso": [0.00, 0.00, 0.00, 0.95, 0.00],
    "direccion": [0.05, 0.15, 0.00, 0.20, 0.00],
    "envio": [0.00, 0.20, 0.00, 0.15, 0.00],
}

documents = [
    "Restablecer contraseña y recuperar acceso a la cuenta",
    "Cambiar tarjeta de pago y datos de facturación",
    "Solicitar vacaciones y registrar una ausencia",
    "Configurar doble factor de autenticación",
    "Descargar factura mensual",
    "Actualizar dirección de envío",
]

queries = [
    "No puedo entrar en mi perfil",
    "Necesito el recibo del mes",
]


def normalize(text):
    text = unicodedata.normalize("NFD", text.lower())
    text = "".join(ch for ch in text if unicodedata.category(ch) != "Mn")
    return re.findall(r"[a-z0-9]+", text)


def average_vector(text):
    vectors = [word_vectors[token] for token in normalize(text) if token in word_vectors]
    if not vectors:
        return [0.0, 0.0, 0.0, 0.0, 0.0]
    return [sum(values) / len(values) for values in zip(*vectors)]


def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    norm_a = sqrt(sum(x * x for x in a))
    norm_b = sqrt(sum(y * y for y in b))
    if norm_a == 0 or norm_b == 0:
        return 0.0
    return dot / (norm_a * norm_b)


for query in queries:
    query_vector = average_vector(query)
    ranked = sorted(
        ((cosine(query_vector, average_vector(document)), document) for document in documents),
        reverse=True,
    )

    print(f"Consulta: {query}")
    for score, document in ranked[:3]:
        print(f"{score:.3f}  {document}")
    print()

Salida esperada

Consulta: No puedo entrar en mi perfil
0.996  Restablecer contraseña y recuperar acceso a la cuenta
0.265  Configurar doble factor de autenticación
0.101  Actualizar dirección de envío

Consulta: Necesito el recibo del mes
1.000  Descargar factura mensual
0.406  Cambiar tarjeta de pago y datos de facturación
0.019  Actualizar dirección de envío

Solución

El buscador devuelve primero el documento correcto en las dos consultas:

Consulta	Primer resultado	Por qué encaja
No puedo entrar en mi perfil	Restablecer contraseña y recuperar acceso a la cuenta	"entrar" y "perfil" apuntan hacia la dimensión de acceso
Necesito el recibo del mes	Descargar factura mensual	"recibo" y "mes" apuntan hacia la dimensión de facturas

La parte importante no es que este mini sistema sea perfecto. No lo es. La parte importante es que ya reproduce la idea central: el texto se convierte en números, los números se comparan y la búsqueda deja de depender solo de palabras exactas.

Por qué funciona

Este reto junta tres ideas del facsímil:

Capítulo 9: un embedding representa texto como vector. Aquí lo hemos hecho a mano para poder mirar dentro.
Capítulo 10: una vez calculados los vectores de los documentos, buscar consiste en comparar la consulta con esos vectores. Eso es barato y rápido.
Capítulo 11: si esto fuera producción, no diríamos "parece que va bien"; mediríamos cuántas veces devuelve el documento correcto en la primera, segunda o tercera posición.

También recuerda algo del capítulo 1: el sistema no "entiende" que una persona está bloqueada fuera de su cuenta. Solo aproxima relaciones entre textos mediante números. La utilidad aparece cuando esa aproximación resuelve una necesidad concreta.

Cómo explicarlo a otra persona

"Hemos convertido cada frase en una flecha dentro de un espacio de temas. Si la pregunta y un documento apuntan en una dirección parecida, los consideramos relacionados. No buscamos palabras iguales: buscamos cercanía entre vectores."

Variaciones para seguir practicando

Añade una consulta nueva: "quiero cambiar dónde recibo los pedidos". ¿Qué documento debería salir primero?
Añade una dimensión nueva llamada "envíos" y ajusta los vectores de direccion y envio. ¿Mejora el resultado?
Cambia el ranking para mostrar solo resultados con similitud mayor que 0.30. ¿Qué pierdes y qué ganas?

Cierre del laboratorio

Si has hecho los dos retos, ya has practicado la idea central del facsímil: la IA no se entiende por una sola pieza, sino por el circuito completo. Representas datos, eliges una función, produces una salida, mides si sirve y decides qué hacer con ella.

Ese circuito vuelve una y otra vez en el resto del libro. En el facsímil 2 aparecerá con otros nombres: estados, acciones, costes, heurísticas, restricciones, planes y conocimiento simbólico. Pero el gesto mental es el mismo: definir bien el problema antes de admirar la herramienta.

Notas

Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson. ↩
Bender, E. M., Gebru, T., McMillan-Major, A. y Shmitchell, S. (2021). On the dangers of stochastic parrots: can language models be too big? En Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency (pp. 610-623). https://doi.org/10.1145/3442188.3445922 ↩
Russell, S. y Norvig, P. (2021). Artificial intelligence: a modern approach (4.ª ed.). Pearson. Los capítulos 13-14 abordan la incertidumbre y el razonamiento probabilístico. ↩
Kaplan, J. et al. (2020). Scaling laws for neural language models. arXiv:2001.08361. https://doi.org/10.48550/arXiv.2001.08361 ↩
McCulloch, W. S. y Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. The Bulletin of Mathematical Biophysics, 5(4), 115-133. https://doi.org/10.1007/BF02478259 ↩
Rosenblatt, F. (1958). The perceptron: a probabilistic model for information storage and organization in the brain. Psychological Review, 65(6), 386-408. https://doi.org/10.1037/h0042519 ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org ↩
LeCun, Y., Bengio, Y. y Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539 ↩
Rumelhart, D. E., Hinton, G. E. y Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536. https://doi.org/10.1038/323533a0 ↩
Goodfellow, I., Bengio, Y. y Courville, A. (2016). Deep learning. MIT Press. https://www.deeplearningbook.org ↩
Kingma, D. P. y Ba, J. (2015). Adam: a method for stochastic optimization. En International Conference on Learning Representations. https://arxiv.org/abs/1412.6980 ↩
Krizhevsky, A., Sutskever, I. y Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. En Advances in Neural Information Processing Systems 25 (pp. 1097-1105). https://papers.nips.cc/paper/4824 ↩
Hochreiter, S. y Schmidhuber, J. (1997). Long short-term memory. Neural Computation, 9(8), 1735-1780. https://doi.org/10.1162/neco.1997.9.8.1735 ↩
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł. y Polosukhin, I. (2017). Attention is all you need. En Advances in Neural Information Processing Systems 30 (pp. 5998-6008). https://papers.nips.cc/paper/7181-attention-is-all-you-need ↩
Brown, T. B. et al. (2020). Language models are few-shot learners. En Advances in Neural Information Processing Systems 33 (pp. 1877-1901). https://papers.nips.cc/paper/2020/hash/1457c0d6bfcb4967418bfb8ac142f64a-Abstract.html ↩
Mikolov, T., Chen, K., Corrado, G. y Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv:1301.3781. https://arxiv.org/abs/1301.3781 ↩
Kaplan, J. et al. (2020). Scaling laws for neural language models. arXiv:2001.08361. https://doi.org/10.48550/arXiv.2001.08361 ↩
Hastie, T., Tibshirani, R. y Friedman, J. (2009). The elements of statistical learning (2.ª ed.). Springer. https://web.stanford.edu/~hastie/ElemStatLearn/ ↩
Breiman, L. (2001). Random forests. Machine Learning, 45(1), 5-32. https://doi.org/10.1023/A:1010933404324 ↩