diff --git a/chapters/es/_toctree.yml b/chapters/es/_toctree.yml
index 10e3ce7a6..ce2a36725 100644
--- a/chapters/es/_toctree.yml
+++ b/chapters/es/_toctree.yml
@@ -113,6 +113,19 @@
- local: chapter8/2
title: ¿Qué hacer cuando se produce un error?
+- title: 12. Construir modelos de razonamiento
+ subtitle: Aprende a construir modelos de razonamiento como DeepSeek R1
+ new: true
+ sections:
+ - local: chapter12/1
+ title: Introducción
+ - local: chapter12/2
+ title: Aprendizaje por refuerzo en LLMs
+ - local: chapter12/3
+ title: El momento «¡Ajá!» en el artículo de DeepSeek R1
+ - local: chapter12/3b
+ title: Comprensión avanzada de GRPO en DeepSeekMath
+
- title: Glosario
sections:
- local: glossary/1
diff --git a/chapters/es/chapter12/1.mdx b/chapters/es/chapter12/1.mdx
new file mode 100644
index 000000000..781c7f968
--- /dev/null
+++ b/chapters/es/chapter12/1.mdx
@@ -0,0 +1,90 @@
+# Open R1 para estudiantes[[open-r1-para-estudiantes]]
+
+¡Te damos la bienvenida a un emocionante viaje al mundo de la IA de código abierto con aprendizaje por refuerzo! Este capítulo está diseñado para ayudar a los estudiantes a comprender el aprendizaje por refuerzo y su papel en los LLMs.
+
+También exploraremos [Open R1](https://github.com/huggingface/open-r1), un innovador proyecto comunitario que está haciendo accesible la IA avanzada para todos. Específicamente, este curso tiene como objetivo ayudar a los estudiantes y aprendices a utilizar y contribuir a [Open R1](https://github.com/huggingface/open-r1).
+
+## Qué aprenderás
+
+En este capítulo, desglosaremos conceptos complejos en partes fáciles de entender y te mostraremos cómo puedes formar parte de este emocionante proyecto para hacer que los LLMs razonen sobre problemas complejos.
+
+Los LLMs han mostrado un excelente rendimiento en muchas tareas generativas. Sin embargo, hasta hace poco tenían dificultades con problemas complejos que requerían razonamiento. Por ejemplo, les cuesta resolver acertijos o problemas matemáticos que requieren múltiples pasos de razonamiento.
+
+Open R1 es un proyecto que tiene como objetivo hacer que los LLMs razonen sobre problemas complejos. Lo hace utilizando el aprendizaje por refuerzo para animar a los LLMs a «pensar» y razonar.
+
+En términos sencillos, el modelo se entrena para generar pensamientos así como respuestas, y para estructurar estos pensamientos y respuestas de modo que el usuario pueda manejarlos por separado.
+
+Veamos un ejemplo. Si nos propusiéramos resolver el siguiente problema, podríamos pensar de esta manera:
+
+```sh
+Problema: "Tengo 3 manzanas y 2 naranjas. ¿Cuántas piezas de fruta tengo en total?"
+
+Pensamiento: "Necesito sumar la cantidad de manzanas y naranjas para obtener la cantidad total de piezas de fruta."
+
+Respuesta: "5"
+```
+
+Luego podemos estructurar este pensamiento y respuesta para que el usuario pueda manejarlos por separado. Para tareas de razonamiento, los LLMs pueden entrenarse para generar pensamientos y respuestas en el siguiente formato:
+
+```sh
+Necesito sumar la cantidad de manzanas y naranjas para obtener la cantidad total de piezas de fruta.
+5
+```
+
+Como usuarios, podemos extraer el pensamiento y la respuesta de la salida del modelo y utilizarlos para resolver el problema.
+
+## Por qué esto es importante para los estudiantes
+
+Como estudiante, comprender Open R1 y el papel del aprendizaje por refuerzo en los LLMs es valioso porque:
+- Te muestra cómo se desarrolla la IA de vanguardia
+- Te brinda oportunidades prácticas para aprender y contribuir
+- Te ayuda a comprender hacia dónde se dirige la tecnología de IA
+- Abre puertas a futuras oportunidades profesionales en IA
+
+## Resumen del capítulo
+
+Este capítulo se divide en cuatro secciones, cada una centrada en un aspecto diferente de Open R1:
+
+### 1️⃣ Introducción al aprendizaje por refuerzo y su papel en los LLMs
+Exploraremos los conceptos básicos del Aprendizaje por Refuerzo (RL) y su función en el entrenamiento de LLMs:
+- ¿Qué es el RL?
+- ¿Cómo se utiliza el RL en los LLMs?
+- ¿Qué es DeepSeek R1?
+- ¿Cuáles son las innovaciones clave de DeepSeek R1?
+
+### 2️⃣ Comprender el artículo de DeepSeek R1
+Desglosaremos el artículo de investigación que inspiró [Open R1](https://huggingface.co/open-r1):
+- Innovaciones y avances clave
+- El proceso de entrenamiento y la arquitectura
+- Resultados y su significado
+
+### 3️⃣ Implementación de GRPO en TRL
+Pasaremos a la práctica con ejemplos de código:
+- Cómo utilizar la librería Transformer Reinforcement Learning (TRL)
+- Configuración del entrenamiento con GRPO
+
+### 4️⃣ Caso de uso práctico para alinear un modelo
+Veremos un caso de uso práctico para alinear un modelo usando Open R1:
+- Cómo entrenar un modelo usando GRPO en TRL
+- Comparte tu modelo en el [Hugging Face Hub](https://huggingface.co/models)
+
+## Requisitos previos
+
+Para aprovechar al máximo este capítulo, es útil contar con:
+- Conocimientos sólidos de programación en Python
+- Familiaridad con los conceptos de aprendizaje automático
+- Interés en la IA y los modelos de lenguaje
+
+No te preocupes si te falta alguno de estos: ¡iremos explicando los conceptos clave a medida que avancemos! 🚀
+
+> [!TIP]
+> Si no cuentas con todos los requisitos previos, consulta este [curso](/course/chapter1/1) desde las unidades 1 a 11.
+
+## Cómo utilizar este capítulo
+
+1. **Lee secuencialmente**: Las secciones se complementan entre sí, por lo que es mejor leerlas en orden
+2. **Comparte notas**: Anota los conceptos clave y las preguntas, y debátelos con la comunidad en [Discord](https://discord.gg/UrrTSsSyjb)
+3. **Prueba el código**: Cuando lleguemos a los ejemplos prácticos, pruébalos tú mismo
+4. **Únete a la comunidad**: Utiliza los recursos que proporcionamos para conectarte con otros estudiantes
+
+¡Comencemos nuestra exploración de Open R1 y descubramos cómo puedes formar parte del objetivo de hacer que la IA sea más accesible para todos! 🚀
diff --git a/chapters/es/chapter12/2.mdx b/chapters/es/chapter12/2.mdx
new file mode 100644
index 000000000..b89dc2d1a
--- /dev/null
+++ b/chapters/es/chapter12/2.mdx
@@ -0,0 +1,239 @@
+# Introducción al aprendizaje por refuerzo y su papel en los LLMs[[introduccion-al-aprendizaje-por-refuerzo-y-su-papel-en-los-llms]]
+
+¡Te damos la bienvenida a la primera página!
+
+Vamos a comenzar nuestro viaje por el apasionante mundo del Aprendizaje por Refuerzo (RL, por sus siglas en inglés: *Reinforcement Learning*) y descubriremos cómo está revolucionando la forma en que entrenamos modelos de lenguaje como los que utilizas todos los días.
+
+> [!TIP]
+> En este capítulo, nos centramos en el aprendizaje por refuerzo para modelos de lenguaje. Sin embargo, el aprendizaje por refuerzo es un campo amplio con muchas aplicaciones más allá de los modelos de lenguaje. Si estás interesado en aprender más sobre el aprendizaje por refuerzo, deberías consultar el [curso de Deep Reinforcement Learning](https://huggingface.co/courses/deep-rl-course/en/unit1/introduction).
+
+Esta página te brindará una introducción amigable y clara al RL, incluso si nunca lo has visto antes. Desglosaremos las ideas centrales y veremos por qué el RL se está volviendo tan importante en el campo de los Modelos Grandes de Lenguaje (LLMs).
+
+## ¿Qué es el aprendizaje por refuerzo (RL)?
+
+Imagina que estás entrenando a un perro. Quieres enseñarle a sentarse. Puedes decir "¡Siéntate!" y luego, si el perro se sienta, le das un premio y lo felicitas. Si no se sienta, puedes guiarlo suavemente o simplemente intentarlo de nuevo. Con el tiempo, el perro aprende a asociar sentarse con la recompensa positiva (premio y elogio) y es más probable que se siente cuando vuelvas a decir "¡Siéntate!". En el aprendizaje por refuerzo, nos referimos a esta retroalimentación como una **recompensa** (*reward*).
+
+¡Esa es, en pocas palabras, la idea básica detrás del aprendizaje por refuerzo! En lugar de un perro, tenemos un **modelo de lenguaje** (en el aprendizaje por refuerzo, lo llamamos **agente**), y en lugar de ti, tenemos el **entorno** (*environment*) que da la retroalimentación.
+
+
+
+Desglosemos las piezas clave del RL:
+
+### Agente (*Agent*)
+
+Este es nuestro aprendiz. En el ejemplo del perro, el perro es el agente. En el contexto de los LLMs, el propio LLM se convierte en el agente que queremos entrenar. El agente es quien toma decisiones y aprende del entorno y sus recompensas.
+
+### Entorno (*Environment*)
+
+Este es el mundo en el que vive e interactúa el agente. Para el perro, el entorno es tu casa y tú. Para un LLM, el entorno es un poco más abstracto: podrían ser los usuarios con los que interactúa o un escenario simulado que configuramos para él. El entorno proporciona retroalimentación al agente.
+
+### Acción (*Action*)
+
+Estas son las elecciones que el agente puede hacer en el entorno. Las acciones del perro son cosas como "sentarse", "pararse", "ladrar", etc. Para un LLM, las acciones podrían ser generar palabras en una oración, elegir qué respuesta dar a una pregunta o decidir cómo responder en una conversación.
+
+### Recompensa (*Reward*)
+
+Esta es la retroalimentación que el entorno le da al agente después de que realiza una acción. Las recompensas suelen ser números.
+
+Las **recompensas positivas** son como premios y elogios: le dicen al agente "¡buen trabajo, hiciste algo bien!".
+
+Las **recompensas negativas** (o penalizaciones) son como un "no" suave: le dicen al agente "eso no estuvo del todo bien, intenta otra cosa". Para el perro, el premio es la recompensa.
+
+Para un LLM, las recompensas están diseñadas para reflejar qué tan bien lo está haciendo el LLM en una tarea específica: tal vez qué tan útil, veraz o inocua es su respuesta.
+
+### Política (*Policy*)
+
+Esta es la estrategia del agente para elegir acciones. Es como la comprensión del perro de lo que debe hacer cuando dices "¡Siéntate!". En RL, la política es lo que realmente intentamos aprender y mejorar. Es un conjunto de reglas o una función que le dice al agente qué acción tomar en diferentes situaciones. Inicialmente, la política puede ser aleatoria, pero a medida que el agente aprende, la política mejora a la hora de elegir acciones que conducen a mayores recompensas.
+
+## El proceso de RL: Ensayo y error
+
+
+
+El aprendizaje por refuerzo ocurre a través de un proceso de ensayo y error:
+
+| Paso | Proceso | Descripción |
+|------|---------|-------------|
+| 1. Observación | El agente observa el entorno | El agente recopila información sobre su estado actual y su entorno |
+| 2. Acción | El agente toma una acción basada en su política actual | Usando su estrategia aprendida (política), el agente decide qué hacer a continuación |
+| 3. Retroalimentación | El entorno le da una recompensa al agente | El agente recibe retroalimentación sobre qué tan buena o mala fue su acción |
+| 4. Aprendizaje | El agente actualiza su política en función de la recompensa | El agente ajusta su estrategia: refuerza las acciones que condujeron a altas recompensas y evita las que llevaron a bajas recompensas |
+| 5. Iteración | Repetir el proceso | Este ciclo continúa, permitiendo que el agente mejore continuamente su toma de decisiones |
+
+Piensa en aprender a andar en bicicleta. Al principio puedes tambalearte y caerte (¡recompensa negativa!). Pero cuando logras mantener el equilibrio y pedalear suavemente, te sientes bien (¡recompensa positiva!). Ajustas tus acciones en función de esta retroalimentación (inclinándote ligeramente, pedaleando más rápido, etc.) hasta que aprendes a andar bien. El RL es similar: se trata de aprender a través de la interacción y la retroalimentación.
+
+## El papel del RL en los Modelos Grandes de Lenguaje (LLMs)
+
+Ahora bien, ¿por qué el RL es tan importante para los Modelos Grandes de Lenguaje?
+
+Entrenar LLMs realmente buenos es complicado. Podemos entrenarlos con cantidades masivas de texto de Internet y se vuelven muy buenos prediciendo la siguiente palabra en una oración. Así es como aprenden a generar texto fluido y gramaticalmente correcto, como aprendimos en el [capítulo 2](/course/chapter2/1).
+
+Sin embargo, limitarse a ser fluido no es suficiente. Queremos que nuestros LLMs sean más que simplemente buenos uniendo palabras. Queremos que sean:
+
+* **Útiles (*Helpful*):** Proporcionen información útil y relevante.
+* **Inocuos (*Harmless*):** Eviten generar contenido tóxico, sesgado o dañino.
+* **Alineados con las preferencias humanas (*Aligned*):** Respondan de maneras que los humanos encuentren naturales, útiles y atractivas.
+
+Los métodos de preentrenamiento de LLM, que dependen principalmente de predecir la siguiente palabra a partir de datos de texto, a veces se quedan cortos en estos aspectos.
+
+Si bien el entrenamiento supervisado es excelente para producir salidas estructuradas, puede ser menos efectivo para producir respuestas útiles, inocuas y alineadas. Exploramos el entrenamiento supervisado en el [capítulo 11](/course/chapter11/1).
+
+Los modelos ajustados finamente pueden generar texto fluido y estructurado que sigue siendo contextualmente incorrecto, sesgado o que realmente no responde a la pregunta del usuario de manera útil.
+
+**¡Aquí es donde entra el Aprendizaje por Refuerzo!** El RL nos brinda una manera de ajustar finamente estos LLMs preentrenados para lograr mejor estas cualidades deseadas. ¡Es como darle a nuestro perro LLM entrenamiento adicional para convertirse en un compañero educado y servicial, no solo en un perro que sabe ladrar fluidamente!
+
+## Aprendizaje por refuerzo a partir de retroalimentación humana (RLHF)
+
+Una técnica muy popular para alinear modelos de lenguaje es el **Aprendizaje por Refuerzo a partir de Retroalimentación Humana (RLHF)** (*Reinforcement Learning from Human Feedback*). En RLHF, utilizamos la retroalimentación humana como un indicador de la señal de "recompensa" en RL. Así es como funciona:
+
+1. **Obtener preferencias humanas:** Podemos pedir a las personas que comparen diferentes respuestas generadas por el LLM para el mismo prompt de entrada y nos digan qué respuesta prefieren. Por ejemplo, podríamos mostrarle a un evaluador humano dos respuestas diferentes a la pregunta "¿Cuál es la capital de Francia?" y preguntarle "¿Qué respuesta es mejor?".
+
+2. **Entrenar un modelo de recompensa:** Utilizamos estos datos de preferencia humana para entrenar un modelo independiente llamado **modelo de recompensa** (*reward model*). Este modelo de recompensa aprende a predecir qué tipo de respuestas preferirán los humanos. Aprende a calificar las respuestas en función de su utilidad, inocuidad y alineación con las preferencias humanas.
+
+3. **Ajustar el LLM con RL:** Ahora usamos el modelo de recompensa como entorno para nuestro agente LLM. El LLM genera respuestas (acciones) y el modelo de recompensa califica estas respuestas (proporciona recompensas). En esencia, estamos entrenando al LLM para producir texto que nuestro modelo de recompensa (que aprendió de las preferencias humanas) considera bueno.
+
+
+
+Desde una perspectiva general, veamos los beneficios de utilizar RL en los LLMs:
+
+| Beneficio | Descripción |
+|-----------|-------------|
+| Control mejorado | El RL nos permite tener más control sobre el tipo de texto que generan los LLMs. Podemos guiarlos para que produzcan texto más alineado con objetivos específicos, como ser útiles, creativos o concisos. |
+| Mayor alineación con los valores humanos | El RLHF, en particular, nos ayuda a alinear los LLMs con preferencias humanas complejas y a menudo subjetivas. Es difícil redactar reglas sobre "qué hace que una respuesta sea buena", pero los humanos pueden juzgar y comparar respuestas fácilmente. El RLHF permite que el modelo aprenda de estos juicios humanos. |
+| Mitigación de comportamientos no deseados | El RL se puede utilizar para reducir comportamientos negativos en los LLMs, como generar lenguaje tóxico, difundir desinformación o exhibir sesgos. Al diseñar recompensas que penalicen estos comportamientos, podemos orientar al modelo para que los evite. |
+
+El Aprendizaje por Refuerzo a partir de Retroalimentación Humana se ha utilizado para entrenar muchos de los LLMs más populares de la actualidad, como GPT-4 de OpenAI, Gemini de Google y R1 de DeepSeek. Existe una amplia gama de técnicas para RLHF, con distintos grados de complejidad y sofisticación. En este capítulo, nos centraremos en Group Relative Policy Optimization (GRPO), que es una técnica de RLHF que ha demostrado ser eficaz para entrenar LLMs que sean útiles, inocuos y alineados con las preferencias humanas.
+
+## ¿Por qué debería importarnos GRPO (*Group Relative Policy Optimization*)?
+
+Existen muchas técnicas para RLHF, pero este curso se centra en GRPO porque representa un avance significativo en el aprendizaje por refuerzo para modelos de lenguaje.
+
+Consideremos brevemente otras dos técnicas populares para RLHF:
+
+- Optimización de política proximal (PPO, *Proximal Policy Optimization*)
+- Optimización directa de preferencias (DPO, *Direct Preference Optimization*)
+
+La optimización de política proximal (PPO) fue una de las primeras técnicas altamente efectivas para RLHF. Utiliza un método de gradiente de política para actualizar la política en función de la recompensa de un modelo de recompensa independiente.
+
+La optimización directa de preferencias (DPO) se desarrolló posteriormente como una técnica más simple que elimina la necesidad de un modelo de recompensa independiente utilizando datos de preferencias directamente. Esencialmente, plantea el problema como una tarea de clasificación entre las respuestas elegidas y rechazadas.
+
+> [!TIP]
+> DPO y PPO son algoritmos complejos de aprendizaje por refuerzo por derecho propio, que no cubriremos en este curso. Si estás interesado en aprender más sobre ellos, puedes consultar los siguientes recursos:
+>
+> - [Proximal Policy Optimization](https://huggingface.co/docs/trl/main/en/ppo_trainer)
+> - [Direct Preference Optimization](https://huggingface.co/docs/trl/main/en/dpo_trainer)
+
+A diferencia de DPO y PPO, GRPO agrupa muestras similares y las compara en grupo. El enfoque basado en grupos proporciona gradientes más estables y mejores propiedades de convergencia en comparación con otros métodos.
+
+GRPO no utiliza datos de preferencias como DPO, sino que compara grupos de muestras similares utilizando una señal de recompensa de un modelo o función.
+
+GRPO es flexible en cuanto a cómo obtiene las señales de recompensa: puede funcionar con un modelo de recompensa (como lo hace PPO), pero no requiere estrictamente uno. Esto se debe a que GRPO puede incorporar señales de recompensa de cualquier función o modelo que pueda evaluar la calidad de las respuestas.
+
+Por ejemplo, podríamos usar una función de longitud para recompensar respuestas más cortas, un solucionador matemático para verificar la corrección de una solución o una función de precisión fáctica para recompensar respuestas que sean más precisas desde el punto de vista factual. Esta flexibilidad hace que GRPO sea particularmente versátil para diferentes tipos de tareas de alineación.
+
+---
+
+¡Felicitaciones por completar el Módulo 1! Ahora tienes una sólida introducción al Aprendizaje por Refuerzo y su papel crucial en la configuración del futuro de los Modelos Grandes de Lenguaje. Comprendes los conceptos básicos de RL, por qué se utiliza para LLMs y te has familiarizado con GRPO, un algoritmo clave en este campo.
+
+En el próximo módulo, pasaremos a la práctica y nos sumergiremos en el artículo de DeepSeek R1 para ver estos conceptos en acción.
+
+## Cuestionario
+
+### 1. ¿Cuáles son los componentes clave del Aprendizaje por Refuerzo?
+
+
+
+### 2. ¿Cuál es la principal ventaja de RLHF para el entrenamiento de modelos de lenguaje?
+
+
+
+### 3. En el contexto de RL para LLMs, ¿qué representa una "acción"?
+
+
+
+### 4. ¿Cuál es el papel de la recompensa en el entrenamiento con RL de modelos de lenguaje?
+
+
+
+### 5. ¿Qué es una recompensa en el contexto de RL para LLMs?
+
+
diff --git a/chapters/es/chapter12/3.mdx b/chapters/es/chapter12/3.mdx
new file mode 100644
index 000000000..b72b0ebb7
--- /dev/null
+++ b/chapters/es/chapter12/3.mdx
@@ -0,0 +1,328 @@
+# El momento «¡Ajá!» en el artículo de DeepSeek R1[[el-momento-aja-en-el-articulo-de-deepseek-r1]]
+
+Este capítulo es una lectura intensiva del artículo. Analizaremos el artículo en términos sencillos y luego desglosaremos los conceptos y conclusiones clave.
+
+DeepSeek R1 representa un avance significativo en el entrenamiento de modelos de lenguaje, particularmente en el desarrollo de capacidades de razonamiento a través del aprendizaje por refuerzo. El artículo presenta un nuevo algoritmo de aprendizaje por refuerzo llamado Optimización de Política Relativa de Grupo (GRPO, por sus siglas en inglés: *Group Relative Policy Optimization*).
+
+
+
+En el próximo capítulo, nos basaremos en este conocimiento e implementaremos GRPO en la práctica.
+
+El objetivo inicial del artículo era explorar si el aprendizaje por refuerzo puro podía desarrollar capacidades de razonamiento sin ajuste fino supervisado.
+
+> [!TIP]
+> Hasta ese momento, todos los LLMs populares requerían algún tipo de ajuste fino supervisado, que exploramos en el [capítulo 11](/course/chapter11/1).
+
+## El gran avance: El momento «¡Ajá!» (*Aha Moment*)
+
+
+
+Uno de los descubrimientos más notables en el entrenamiento de R1-Zero fue la aparición de un fenómeno conocido como el momento «¡Ajá!» (*Aha Moment*). Este fenómeno es similar a la forma en que los humanos experimentan revelaciones repentinas al resolver problemas. Así es como funciona:
+
+1. Intento inicial: El modelo realiza un intento inicial para resolver un problema
+2. Reconocimiento: Reconoce posibles errores o inconsistencias
+3. Autocorrección: Ajusta su enfoque en función de este reconocimiento
+4. Explicación: Puede explicar por qué el nuevo enfoque es mejor
+
+Este avance resuena en los aprendices y se siente como un momento "Eureka". Demuestra aprendizaje en lugar de mera memorización, así que tomémonos un momento para imaginar cómo se siente tener un momento «¡Ajá!».
+
+Por ejemplo, imagina que estás intentando resolver un rompecabezas:
+- Primer intento: "Esta pieza debería ir aquí según el color"
+- Reconocimiento: "Pero espera, la forma no encaja del todo"
+- Corrección: "Ah, en realidad pertenece allá"
+- Explicación: "Porque tanto el patrón de color como el de forma coinciden en esta posición"
+
+Esta capacidad surgió naturalmente del entrenamiento con RL, sin haber sido programada explícitamente, demostrando aprendizaje en lugar de la mera memorización de un proceso a partir de los datos de entrenamiento.
+
+La forma más sencilla de comprender el momento «¡Ajá!» es verlo en acción. Veamos un ejemplo. En el chat a continuación, le pedimos al modelo que resuelva un problema y la interfaz muestra el proceso de pensamiento del modelo a medida que lo resuelve.
+
+
+
+Si quieres probar R1 de DeepSeek, también puedes consultar [Hugging Chat](https://huggingface.co/chat/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B).
+
+## El proceso de entrenamiento
+
+Entrenar a R1 fue un proceso de varias fases. Desglosemos las fases y las innovaciones clave en cada una de ellas.
+
+El proceso final da como resultado dos modelos:
+- DeepSeek-R1-Zero: Un modelo entrenado exclusivamente mediante aprendizaje por refuerzo.
+- DeepSeek-R1: Un modelo que se basa en los cimientos de DeepSeek-R1-Zero y añade ajuste fino supervisado.
+
+| Característica | DeepSeek-R1-Zero | DeepSeek-R1 |
+|----------------|------------------|-------------|
+| Enfoque de entrenamiento | RL puro | Multifase (SFT + RL) |
+| Ajuste fino | Ninguno | Ajuste fino supervisado |
+| Capacidad de razonamiento | Emergente | Mejorada |
+| Rendimiento en AIME | 71.0% | 79.8% |
+| Características clave | Fuerte razonamiento pero problemas de legibilidad | Mejor consistencia lingüística y legibilidad |
+
+Si bien DeepSeek-R1-Zero demuestra el potencial del aprendizaje por refuerzo puro para desarrollar capacidades de razonamiento, DeepSeek-R1 se basa en esta base con un enfoque más equilibrado que prioriza tanto el rendimiento del razonamiento como la usabilidad.
+
+El proceso de entrenamiento involucra cuatro fases:
+
+1. Fase de inicio en frío (*Cold Start Phase*)
+2. Fase de RL de razonamiento (*Reasoning RL Phase*)
+3. Fase de muestreo por rechazo (*Rejection Sampling Phase*)
+4. Fase de RL diverso (*Diverse RL Phase*)
+
+Desglosemos cada fase:
+
+### Fase de inicio en frío (Base de calidad)
+
+
+
+Esta fase está diseñada para establecer una base sólida para la legibilidad y la calidad de respuesta del modelo. Utiliza un pequeño conjunto de datos de muestras de alta calidad de R1-Zero para ajustar el modelo V3-Base. Comenzando con el modelo DeepSeek-V3-Base, el equipo utilizó miles de muestras validadas y de alta calidad de R1-Zero para el ajuste fino supervisado. Este enfoque innovador utiliza un conjunto de datos pequeño pero de alta calidad para establecer una sólida línea de base de legibilidad y calidad de respuesta.
+
+### Fase de RL de razonamiento (Desarrollo de capacidades)
+
+
+
+La fase de RL de razonamiento se centra en desarrollar capacidades centrales de razonamiento en dominios que incluyen matemáticas, programación, ciencias y lógica. Esta fase emplea aprendizaje por refuerzo basado en reglas, con recompensas directamente vinculadas a la corrección de la solución.
+
+Crucialmente, todas las tareas en esta fase son «verificables», por lo que podemos comprobar si la respuesta del modelo es correcta o no. Por ejemplo, en el caso de las matemáticas, podemos comprobar si la respuesta del modelo es correcta utilizando un solucionador matemático.
+
+Lo que hace que esta fase sea particularmente innovadora es su enfoque de optimización directa que elimina la necesidad de un modelo de recompensa independiente, agilizando el proceso de entrenamiento.
+
+### Fase de muestreo por rechazo (Control de calidad)
+
+
+
+Durante la fase de muestreo por rechazo, el modelo genera muestras que luego se filtran mediante un proceso de control de calidad. DeepSeek-V3 sirve como juez de calidad, evaluando las respuestas en un amplio espectro que se extiende más allá de las tareas de razonamiento puro. Los datos filtrados se utilizan luego para el ajuste fino supervisado. La innovación de esta fase radica en su capacidad para combinar múltiples señales de calidad para garantizar salidas de alto nivel.
+
+### Fase de RL diverso (Alineación amplia)
+
+
+
+La fase final de RL diverso aborda múltiples tipos de tareas mediante un enfoque híbrido sofisticado. Para tareas deterministas, emplea recompensas basadas en reglas, mientras que las tareas subjetivas se evalúan mediante retroalimentación de LLMs. Esta fase tiene como objetivo lograr la alineación con las preferencias humanas a través de su enfoque de recompensa híbrido innovador, combinando la precisión de los sistemas basados en reglas con la flexibilidad de la evaluación de modelos de lenguaje.
+
+## El algoritmo: Group Relative Policy Optimization (GRPO)
+
+Ahora que tenemos una buena comprensión del proceso de entrenamiento, veamos el algoritmo que se utilizó para entrenar el modelo.
+
+Los autores describen GRPO como un gran avance en el ajuste fino de modelos:
+
+
+
+La novedad de GRPO radica en su capacidad para "optimizar directamente para la rectificación de preferencias". Esto significa una vía más directa y eficiente para alinear el modelo con las salidas deseadas, en contraste con los algoritmos tradicionales de aprendizaje por refuerzo como PPO. Desglosemos cómo funciona GRPO a través de sus tres componentes principales.
+
+### Formación de grupos: Creación de múltiples soluciones
+
+El primer paso en GRPO es notablemente intuitivo: es similar a cómo un estudiante podría resolver un problema difícil probando múltiples enfoques. Ante un prompt, el modelo no solo genera una respuesta; en su lugar, crea múltiples intentos para resolver el mismo problema (generalmente 4, 8 o 16 intentos diferentes).
+
+Imagina que le estás enseñando a un modelo a resolver problemas matemáticos. Para una pregunta sobre el conteo de pollos en una granja, el modelo podría generar varias soluciones diferentes:
+- Una solución podría desglosar el problema paso a paso: primero contando el total de pollos, luego restando los gallos y finalmente contabilizando las gallinas que no ponen huevos
+- Otra podría utilizar un enfoque diferente pero igualmente válido
+- Algunos intentos pueden contener errores o soluciones menos eficientes
+
+Todos estos intentos se mantienen juntos como un grupo, de manera similar a tener las soluciones de varios estudiantes para comparar y aprender de ellas.
+
+
+
+### Aprendizaje de preferencias: Comprender qué hace que una solución sea buena
+
+Aquí es donde GRPO realmente destaca por su simplicidad. A diferencia de otros métodos para RLHF que siempre requieren un modelo de recompensa independiente para predecir qué tan buena puede ser una solución, GRPO puede utilizar cualquier función o modelo para evaluar la calidad de una solución. Por ejemplo, podríamos usar una función de longitud para recompensar respuestas más cortas o un solucionador matemático para recompensar soluciones matemáticas precisas.
+
+El proceso de evaluación analiza varios aspectos de cada solución:
+- ¿Es correcta la respuesta final?
+- ¿Siguió la solución el formato adecuado (como usar las etiquetas XML correctas)?
+- ¿Coincide el razonamiento con la respuesta proporcionada?
+
+Lo que hace que este enfoque sea particularmente ingenioso es cómo maneja la puntuación. En lugar de dar únicamente puntuaciones absolutas, GRPO normaliza las recompensas dentro de cada grupo. Utiliza una fórmula simple pero eficaz para la estimación de la ventaja relativa del grupo:
+
+```
+Ventaja = (recompensa - media(recompensas_del_grupo)) / desv_est(recompensas_del_grupo)
+```
+
+
+
+Esta normalización es como calificar según una curva estadística, pero para IA. Ayuda al modelo a comprender qué soluciones dentro del grupo fueron mejores o peores en comparación con sus pares, en lugar de limitarse a observar puntuaciones absolutas.
+
+### Optimización: Aprender de la experiencia
+
+El paso final es donde GRPO le enseña al modelo a mejorar en función de lo que aprendió al evaluar el grupo de soluciones. Este proceso es tanto potente como estable, y utiliza dos principios principales:
+
+1. Anima al modelo a producir más soluciones similares a las exitosas mientras se aleja de los enfoques menos efectivos
+2. Incluye un mecanismo de seguridad (denominado penalización por divergencia KL) que evita que el modelo cambie de manera demasiado drástica de una sola vez
+
+Este enfoque resulta más estable que los métodos tradicionales porque:
+- Analiza múltiples soluciones juntas en lugar de comparar solo dos a la vez
+- La normalización basada en grupos ayuda a prevenir problemas con el escalado de recompensas
+- La penalización KL actúa como una red de seguridad, asegurando que el modelo no olvide lo que ya sabe mientras aprende cosas nuevas
+
+> [!TIP]
+> Las innovaciones clave de GRPO son:
+> - Aprender directamente de cualquier función o modelo, eliminando la dependencia de un modelo de recompensa independiente.
+> - Aprendizaje basado en grupos, que es más estable y eficiente que los métodos tradicionales como las comparaciones por pares.
+
+Este desglose es complejo, pero la conclusión clave es que GRPO es una forma más eficiente y estable de entrenar un modelo para que razone.
+
+### Algoritmo GRPO en pseudocódigo
+
+Ahora que comprendemos los componentes clave de GRPO, veamos el algoritmo en pseudocódigo. Esta es una versión simplificada del algoritmo, pero captura las ideas clave:
+
+```
+Entrada:
+- initial_policy: Modelo inicial a entrenar
+- reward_function: Función que evalúa las salidas
+- training_prompts: Conjunto de ejemplos de entrenamiento
+- group_size: Número de salidas por prompt (típicamente 4-16)
+
+Algoritmo GRPO:
+1. Para cada iteración de entrenamiento:
+ a. Establecer reference_policy = initial_policy (instantánea de la política actual)
+ b. Para cada prompt en el lote:
+ i. Generar group_size salidas diferentes utilizando initial_policy
+ ii. Calcular las recompensas para cada salida utilizando reward_function
+ iii. Normalizar las recompensas dentro del grupo:
+ normalized_advantage = (reward - mean(rewards)) / std(rewards)
+ iv. Actualizar la política maximizando la razón recortada (clipped ratio):
+ min(prob_ratio * normalized_advantage,
+ clip(prob_ratio, 1-epsilon, 1+epsilon) * normalized_advantage)
+ - kl_weight * KL(initial_policy || reference_policy)
+
+ donde prob_ratio es current_prob / reference_prob
+
+Salida: Modelo de política optimizado
+```
+
+Este algoritmo muestra cómo GRPO combina la estimación de ventajas basada en grupos con la optimización de políticas manteniendo la estabilidad mediante recorte y restricciones de divergencia KL.
+
+## Resultados e impacto
+
+Ahora que hemos explorado el algoritmo, veamos los resultados. DeepSeek R1 logra un rendimiento de vanguardia en múltiples dominios:
+
+| Dominio | Resultados clave |
+|---------|------------------|
+| Matemáticas | • 79.8% en AIME 2024
• 97.3% en MATH-500 |
+| Programación | • Clasificación Codeforces: 2029
• LiveCodeBench: 65.9% |
+| Conocimiento general | • MMLU: 90.8%
• GPQA Diamond: 71.5% |
+| Tareas del lenguaje | • AlpacaEval 2.0: 87.6% de tasa de victoria
• FRAMES: 82.5% |
+
+El impacto práctico del modelo se extiende más allá de los puntos de referencia gracias a los precios rentables de su API ($0,14 por millón de tokens de entrada) y la destilación exitosa del modelo en varios tamaños (desde 1.5B hasta 70B de parámetros). En particular, incluso el modelo de 7B alcanza el 55.5% en AIME 2024, mientras que la versión destilada de 70B se acerca al rendimiento de o1-mini en MATH-500 (94.5%), demostrando una preservación efectiva de la capacidad a diferentes escalas.
+
+## Limitaciones y desafíos de GRPO
+
+Si bien GRPO representa un avance significativo en el aprendizaje por refuerzo para modelos de lenguaje, es importante comprender sus limitaciones y desafíos:
+
+- **Costo de generación**: Generar múltiples terminaciones (4-16) para cada prompt aumenta los requisitos computacionales en comparación con los métodos que generan solo una o dos terminaciones.
+- **Restricciones del tamaño de lote**: La necesidad de procesar grupos de terminaciones juntos puede limitar los tamaños de lote efectivos, agregando complejidad al proceso de entrenamiento y potencialmente ralentizándolo.
+- **Diseño de la función de recompensa**: La calidad del entrenamiento depende en gran medida de funciones de recompensa bien diseñadas. Recompensas mal diseñadas pueden provocar comportamientos no deseados u optimización para objetivos incorrectos.
+- **Compromisos del tamaño de grupo**: Elegir el tamaño de grupo óptimo implica equilibrar la diversidad de soluciones frente al costo computacional. Muy pocas muestras pueden no proporcionar suficiente diversidad, mientras que demasiadas aumentan el tiempo de entrenamiento y los requisitos de recursos.
+- **Ajuste de la divergencia KL**: Encontrar el equilibrio adecuado para la penalización por divergencia KL requiere un ajuste cuidadoso: si es demasiado alta, el modelo no aprenderá eficazmente; si es demasiado baja, puede divergir demasiado de sus capacidades iniciales.
+
+## Conclusión
+
+El artículo de DeepSeek R1 representa un hito importante en el desarrollo de modelos de lenguaje. El algoritmo Group Relative Policy Optimization (GRPO) ha demostrado que el aprendizaje por refuerzo puro puede efectivamente desarrollar sólidas capacidades de razonamiento, desafiando suposiciones previas sobre la necesidad del ajuste fino supervisado.
+
+Quizás lo más importante es que DeepSeek R1 ha demostrado que es posible equilibrar el alto rendimiento con consideraciones prácticas como la rentabilidad y la accesibilidad. La exitosa destilación de las capacidades del modelo en diferentes tamaños, de 1.5B a 70B de parámetros, muestra un camino a seguir para que las capacidades avanzadas de IA estén más ampliamente disponibles.
+
+---
+
+En la siguiente sección, exploraremos implementaciones prácticas de estos conceptos, centrándonos en cómo aprovechar GRPO en tus propios proyectos de desarrollo de modelos de lenguaje.
+
+## Cuestionario
+
+### 1. ¿Cuál es la principal innovación del artículo de DeepSeek R1?
+
+
+
+### 2. ¿Cuáles son las cuatro fases del proceso de entrenamiento de DeepSeek R1?
+
+
+
+### 3. ¿Qué es el fenómeno del «momento ¡Ajá!» en el entrenamiento de R1-Zero?
+
+
+
+### 4. ¿Cómo funciona la formación de grupos de GRPO?
+
+
+
+### 5. ¿Cuál es la diferencia clave entre DeepSeek-R1-Zero y DeepSeek-R1?
+
+
diff --git a/chapters/es/chapter12/3b.mdx b/chapters/es/chapter12/3b.mdx
new file mode 100644
index 000000000..928c36261
--- /dev/null
+++ b/chapters/es/chapter12/3b.mdx
@@ -0,0 +1,415 @@
+# Comprensión avanzada de Group Relative Policy Optimization (GRPO) en DeepSeekMath[[comprension-avanzada-de-grpo-en-deepseekmath]]
+
+> [!TIP]
+> Esta sección profundiza en los detalles técnicos y matemáticos de GRPO. Fue redactada por Shirin Yamani.
+
+Profundicemos en nuestra comprensión de GRPO para que podamos mejorar el proceso de entrenamiento de nuestro modelo.
+
+GRPO evalúa directamente las respuestas generadas por el modelo comparándolas dentro de grupos de generación para optimizar el modelo de política, en lugar de entrenar un modelo de valor independiente (Crítico / *Critic*). ¡Este enfoque conduce a una reducción significativa en el costo computacional!
+
+GRPO se puede aplicar a cualquier tarea verificable donde se pueda determinar la corrección de la respuesta. Por ejemplo, en el razonamiento matemático, la corrección de la respuesta se puede verificar fácilmente comparándola con el valor real (*ground truth*).
+
+Antes de sumergirnos en los detalles técnicos, visualicemos cómo funciona GRPO a alto nivel:
+
+
+
+Ahora que tenemos una descripción visual, desglosemos cómo funciona GRPO paso a paso.
+
+## El algoritmo GRPO
+
+La innovación central de GRPO es su enfoque para evaluar y aprender de múltiples respuestas generadas simultáneamente. En lugar de depender de un modelo de recompensa independiente, compara las respuestas dentro del mismo grupo para determinar cuáles deben reforzarse.
+
+Repasemos cada paso del algoritmo en detalle:
+
+### Paso 1: Muestreo de grupos (*Group Sampling*)
+
+El primer paso es generar múltiples respuestas posibles para cada pregunta. Esto crea un conjunto diverso de salidas que se pueden comparar entre sí.
+
+Para cada pregunta \\( q \\), el modelo generará \\( G \\) salidas (tamaño del grupo) a partir de la política entrenada: { \\( {o_1, o_2, o_3, \dots, o_G}\sim\pi_{\theta_{\text{old}}} \\) }, \\( G=8 \\) donde cada \\( o_i \\) representa una terminación del modelo.
+
+#### Ejemplo
+
+Para concretar esto, veamos un problema aritmético simple:
+
+**Pregunta**
+
+\\( q \\) : \\( \text{Calcular}\space2 + 2 \times 6 \\)
+
+**Salidas**
+
+\\( (G = 8) \\): \\( \{o_1:14 \text{ (correcta)}, o_2:16 \text{ (incorrecta)}, o_3:10 \text{ (incorrecta)}, \ldots, o_8:14 \text{ (correcta)}\} \\)
+
+Observa cómo algunas de las respuestas generadas son correctas (14) mientras que otras son incorrectas (16 o 10). Esta diversidad es crucial para el siguiente paso.
+
+### Paso 2: Cálculo de la ventaja (*Advantage Calculation*)
+
+Una vez que tenemos múltiples respuestas, necesitamos una forma de determinar cuáles son mejores que otras. Aquí es donde entra el cálculo de la ventaja (*advantage*).
+
+#### Distribución de recompensas
+
+Primero, asignamos una puntuación de recompensa a cada respuesta generada. En este ejemplo, usaremos un modelo de recompensa, pero como aprendimos en la sección anterior, podemos usar cualquier función que devuelva recompensas.
+
+Asignamos una puntuación RM a cada una de las respuestas generadas en función de la corrección \\( r_i \\) *(por ejemplo, 1 para respuesta correcta, 0 para respuesta incorrecta)* y luego, para cada \\( r_i \\), calculamos el siguiente valor de ventaja (*Advantage*).
+
+#### Fórmula del valor de ventaja
+
+La idea clave de GRPO es que no necesitamos medidas absolutas de calidad: podemos comparar las salidas dentro del mismo grupo. Esto se hace mediante estandarización:
+
+$$A_i = \frac{r_i - \text{media}(\{r_1, r_2, \ldots, r_G\})}{\text{desv\_est}(\{r_1, r_2, \ldots, r_G\})}$$
+
+#### Ejemplo
+
+Continuando con nuestro ejemplo aritmético anterior, imagina que tenemos 8 respuestas, 4 de las cuales son correctas y el resto incorrectas, por lo tanto:
+
+| Métrica | Valor |
+|---------|-------|
+| Promedio del grupo | \\( mean(r_i) = 0.5 \\) |
+| Desviación estándar | \\( std(r_i) = 0.53 \\) |
+| Valor de ventaja (Respuesta correcta) | \\( A_i = \frac{1 - 0.5}{0.53}= 0.94 \\) |
+| Valor de ventaja (Respuesta incorrecta) | \\( A_i = \frac{0 - 0.5}{0.53}= -0.94 \\) |
+
+#### Interpretación
+
+Ahora que hemos calculado los valores de ventaja, comprendamos qué significan:
+
+Esta estandarización (es decir, la ponderación \\( A_i \\)) permite al modelo evaluar el rendimiento relativo de cada respuesta, guiando el proceso de optimización hacia respuestas favorables que son mejores que el promedio (alta recompensa) y desalentando aquellas que son peores. Por ejemplo, si \\( A_i > 0 \\), entonces \\( o_i \\) es una respuesta mejor que el nivel promedio dentro de su grupo; y si \\( A_i < 0 \\), entonces la calidad de la respuesta es inferior al promedio (es decir, calidad/rendimiento deficiente).
+
+Para el ejemplo anterior, si \\( A_i = 0.94 \text{ (salida correcta)} \\), entonces durante los pasos de optimización se incrementará su probabilidad de generación.
+
+Con nuestros valores de ventaja calculados, ya estamos listos para actualizar la política.
+
+### Paso 3: Actualización de la política (*Policy Update*)
+
+El paso final es usar estos valores de ventaja para actualizar nuestro modelo de modo que sea más probable que genere buenas respuestas en el futuro.
+
+La función objetivo para la actualización de la política es:
+
+$$J_{GRPO}(\theta) = \left[\frac{1}{G} \sum_{i=1}^{G} \min \left( \frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{old}}(o_i|q)} A_i, \text{clip}\left( \frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{old}}(o_i|q)}, 1 - \epsilon, 1 + \epsilon \right) A_i \right)\right]- \beta D_{KL}(\pi_{\theta} \| \pi_{ref})$$
+
+Esta fórmula puede parecer intimidante al principio, pero está construida a partir de varios componentes que cumplen un propósito importante. Desglosémoslos uno por uno.
+
+## Componentes clave de la función objetivo
+
+La función de actualización de GRPO combina varias técnicas para garantizar un aprendizaje estable y eficaz. Examinemos cada componente:
+
+### 1. Razón de probabilidad (*Probability Ratio*)
+
+La razón de probabilidad se define como:
+
+\\( \left(\frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{old}}(o_i|q)}\right) \\)
+
+Intuitivamente, la fórmula compara cuánto difiere la probabilidad de respuesta del nuevo modelo de la probabilidad de respuesta del modelo anterior, incorporando al mismo tiempo una preferencia por las respuestas que mejoran el resultado esperado.
+
+#### Interpretación
+
+- Si \\( \text{razón} > 1 \\), el nuevo modelo asigna una mayor probabilidad a la respuesta \\( o_i \\) que el modelo anterior.
+- Si \\( \text{razón} < 1 \\), el nuevo modelo asigna una menor probabilidad a \\( o_i \\)
+
+Esta razón nos permite controlar cuánto cambia el modelo en cada paso, lo que nos lleva al siguiente componente.
+
+### 2. Función de recorte (*Clip Function*)
+
+La función de recorte se define como:
+
+\\( \text{clip}\left( \frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{old}}(o_i|q)}, 1 - \epsilon, 1 + \epsilon\right) \\)
+
+Limita la razón discutida anteriormente para que esté dentro de \\( [1 - \epsilon, 1 + \epsilon] \\) con el fin de evitar o controlar cambios drásticos o actualizaciones excesivas y alejarse demasiado de la política anterior. En otras palabras, limita cuánto puede aumentar la razón de probabilidad para ayudar a mantener la estabilidad al evitar actualizaciones que empujen al nuevo modelo demasiado lejos del anterior.
+
+#### Ejemplo (ε = 0.2)
+
+Veamos dos escenarios diferentes para comprender mejor esta función de recorte:
+
+- **Caso 1**: si la nueva política tiene una probabilidad de 0.9 para una respuesta específica y la política anterior tiene una probabilidad de 0.5, significa que esta respuesta está siendo reforzada por la nueva política para tener una mayor probabilidad, pero dentro de un límite controlado que es el recorte para moderar su magnitud.
+ - \\( \text{Razón}: \frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{old}}(o_i|q)} = \frac{0.9}{0.5} = 1.8 → \text{Recorte a}\space1.2 \\) (límite superior 1.2)
+- **Caso 2**: Si la nueva política no está a favor de una respuesta (menor probabilidad, por ejemplo, 0.2), lo que significa que si la respuesta no es beneficiosa el aumento podría ser incorrecto, y el modelo sería penalizado.
+ - \\( \text{Razón}: \frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{old}}(o_i|q)} = \frac{0.2}{0.5} = 0.4 → \text{Recorte a}\space0.8 \\) (límite inferior 0.8)
+
+#### Interpretación
+
+- La fórmula anima al nuevo modelo a favorecer respuestas que el modelo anterior subestimaba **si mejoran el resultado**.
+- Si el modelo anterior ya favorecía una respuesta con alta probabilidad, el nuevo modelo aún puede reforzarla **pero solo dentro de un límite controlado \\( [1 - \epsilon, 1 + \epsilon] \\), \\( \text{(por ejemplo, }\epsilon = 0.2, \space \text{es decir, } \space [0.8-1.2]) \\)**.
+- Si el modelo anterior sobrestimó una respuesta que rinde mal, se **desalienta** al nuevo modelo de mantener esa alta probabilidad.
+- Por lo tanto, intuitivamente, al incorporar la razón de probabilidad, la función objetivo asegura que las actualizaciones a la política sean proporcionales a la ventaja \\( A_i \\) al tiempo que se moderan para evitar cambios drásticos.
+
+Si bien la función de recorte ayuda a prevenir cambios drásticos, necesitamos una salvaguarda más para garantizar que nuestro modelo no se desvíe demasiado de su comportamiento original.
+
+### 3. Divergencia KL (*KL Divergence*)
+
+El término de divergencia KL es:
+
+\\( \beta D_{KL}(\pi_{\theta} \| \pi_{ref}) \\)
+
+En el término de divergencia KL, \\( \pi_{ref} \\) es básicamente la salida del modelo previa a la actualización, `per_token_logps`, y \\( \pi_{\theta} \\) es la salida del nuevo modelo, `new_per_token_logps`. Teóricamente, la divergencia KL se minimiza para evitar que el modelo se desvíe demasiado de su comportamiento original durante la optimización. Esto ayuda a lograr un equilibrio entre mejorar el rendimiento en función de la señal de recompensa y mantener la coherencia. En este contexto, minimizar la divergencia KL reduce el riesgo de que el modelo genere texto sin sentido o, en el caso del razonamiento matemático, produzca respuestas extremadamente incorrectas.
+
+#### Interpretación
+
+- Una penalización por divergencia KL mantiene las salidas del modelo cerca de su distribución original, evitando cambios extremos.
+- En lugar de derivar hacia salidas completamente irracionales, el modelo refina su comprensión permitiendo cierta exploración.
+
+#### Definición matemática
+
+Para aquellos interesados en los detalles matemáticos, veamos la definición formal:
+
+Recordemos que la distancia KL se define de la siguiente manera:
+$$D_{KL}(P \| Q) = \sum_{x \in X} P(x) \log \frac{P(x)}{Q(x)}$$
+En RLHF, las dos distribuciones de interés son a menudo la distribución de la nueva versión del modelo, P(x), y la distribución de la política de referencia, Q(x).
+
+#### El papel del parámetro β
+
+El coeficiente \\( \beta \\) controla con qué fuerza aplicamos la restricción de divergencia KL:
+
+- **Mayor β (Penalización KL más fuerte)**
+ - Mayor restricción en las actualizaciones de la política. El modelo se mantiene cercano a su distribución de referencia.
+ - Puede ralentizar la adaptación: El modelo puede tener dificultades para explorar mejores respuestas.
+- **Menor β (Penalización KL más débil)**
+ - Mayor libertad para actualizar la política: El modelo puede desviarse más de la referencia.
+ - Adaptación más rápida pero riesgo de inestabilidad: El modelo podría aprender comportamientos de piratería de recompensas (*reward-hacking*).
+ - Riesgo de sobreoptimización: Si el modelo de recompensa es defectuoso, la política podría generar salidas sin sentido.
+- El artículo original de [DeepSeekMath](https://arxiv.org/abs/2402.03300) estableció \\( \beta = 0.04 \\).
+
+Ahora que comprendemos los componentes de GRPO, veamos cómo funcionan juntos en un ejemplo completo.
+
+## Ejemplo resuelto con GRPO
+
+Para consolidar nuestra comprensión de GRPO, repasemos un ejemplo completo de principio a fin.
+
+### Problema de ejemplo
+
+$$\text{P: Calcular}\space2 + 2 \times 6$$
+
+### Paso 1: Muestreo de grupos
+
+Primero, generamos múltiples respuestas a partir de nuestro modelo.
+
+Generamos \\( (G = 8) \\) respuestas, \\( 4 \\) de las cuales son la respuesta correcta (\\( 14, \text{recompensa=} 1 \\)) y \\( 4 \\) incorrectas \\( \text{(recompensa= 0)} \\). Por lo tanto:
+
+$${o_1:14 \text{ (correcta)}, o_2:10 \text{ (incorrecta)}, o_3:16 \text{ (incorrecta)}, \dots, o_G:14 \text{ (correcta)}}$$
+
+### Paso 2: Cálculo de la ventaja
+
+A continuación, calculamos los valores de ventaja para determinar qué respuestas son mejores que el promedio:
+
+| Estadística | Valor |
+|-------------|-------|
+| Promedio del grupo | \\( mean(r_i) = 0.5 \\) |
+| Desviación estándar | \\( std(r_i) = 0.53 \\) |
+| Valor de ventaja (Respuesta correcta) | \\( A_i = \frac{1 - 0.5}{0.53}= 0.94 \\) |
+| Valor de ventaja (Respuesta incorrecta) | \\( A_i = \frac{0 - 0.5}{0.53}= -0.94 \\) |
+
+### Paso 3: Actualización de la política
+
+Finalmente, actualizamos nuestro modelo para reforzar las respuestas correctas:
+
+- Suponiendo que la probabilidad de la política anterior (\\( \pi_{\theta_{old}} \\)) para una salida correcta \\( o_1 \\) sea \\( 0.5 \\) y la nueva política la aumente a \\( 0.7 \\), entonces:
+$$\text{Razón}: \frac{0.7}{0.5} = 1.4 → \text{tras Recorte}\space1.2 \space (\epsilon = 0.2)$$
+- Luego, cuando se repondera la función objetivo, el modelo tiende a reforzar la generación de la salida correcta, y la \\( \text{Divergencia KL} \\) limita la desviación de la política de referencia.
+
+Con la comprensión teórica consolidada, veamos cómo se puede implementar GRPO en código.
+
+## Ejemplo de implementación
+
+Unamos todo en un ejemplo práctico. El siguiente código demuestra cómo implementar GRPO en PyTorch:
+
+### 1. Cargar el modelo y generar respuestas
+
+Primero, debemos cargar un modelo y generar múltiples respuestas para una pregunta determinada:
+
+```python
+import torch
+import torch.nn.functional as F
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Cargar el modelo y tokenizador
+model_name = "Qwen/Qwen2-Math-1.5B"
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model.eval()
+
+# Mover el modelo a GPU si está disponible
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model.to(device)
+
+# Prompt de entrada
+prompt = "Solve y = 2x + 1 for x = 2, y = " # Respuesta correcta: 5
+inputs = tokenizer(prompt, return_tensors="pt", padding=True)
+input_ids = inputs["input_ids"].to(device) # Forma: (1, prompt_len)
+attention_mask = inputs["attention_mask"].to(device)
+
+# Paso 1: Generar 8 respuestas (B = 2 grupos, G = 4 respuestas por grupo)
+batch_size, num_generations = 2, 4
+outputs = model.generate(
+ input_ids=input_ids, # Forma: (1, prompt_len)
+ attention_mask=attention_mask,
+ max_new_tokens=1, # seq_len = 1 (un solo token por respuesta)
+ num_return_sequences=batch_size * num_generations, # 8 respuestas en total
+ do_sample=True,
+ top_k=10,
+ temperature=0.7,
+ pad_token_id=tokenizer.eos_token_id,
+ return_dict_in_generate=True,
+ output_scores=True,
+)
+```
+
+Esta generación inicial (antes de cualquier paso) producirá algo como esto:
+
+```text
+Output 1: 5.0
+Output 2: 6.0
+Output 3: 7.0
+Output 4: 5.0
+Output 5: 10.0
+Output 6: 2.0
+Output 7: 5.0
+Output 8: 5.0
+```
+
+### 2. Calcular recompensas
+
+Ahora debemos determinar qué respuestas son correctas y asignar recompensas en consecuencia:
+
+Con GRPO, a partir del mismo prompt de muestra generamos múltiples terminaciones. Así, por ejemplo, para nuestros prompts `"Solve y = 2x + 1 for x = 2, y = "` y `"Solve y = 2x + 1 for x = 4, y = "` tenemos dos grupos de salidas generadas para el prompt dado: uno es, por ejemplo:
+- `[5, 6, 7, 5]` y el otro es
+- `[10, 2, 9, 9]`, mientras que las respuestas correctas son 5 y 9.
+
+Ten en cuenta que, en la práctica, estas puntuaciones de recompensa se obtienen mediante una función de recompensa basada en reglas que asigna recompensas según la corrección de la respuesta, o un modelo más complejo basado en redes neuronales entrenado para asignar recompensas según la corrección de la respuesta, o una combinación de ambos. Pero por simplicidad digamos que nuestra recompensa por respuesta es 1 si la respuesta es correcta y 0 si es incorrecta; por lo tanto:
+
+```python
+reward_1 = [1, 0, 0, 1]
+reward_2 = [0, 0, 1, 1]
+```
+
+A continuación obtenemos la media y desviación estándar de las recompensas por grupo:
+
+```python
+# Forma: (B * G,) = (8,) porque tenemos 2 grupos de 4 generaciones que aplanamos
+rewards = torch.tensor([1, 0, 0, 1, 0, 0, 1, 1], dtype=torch.float32)
+num_generations = 4
+
+# Recompensas agrupadas: Forma (B, G) = (2, 4)
+rewards_grouped = rewards.view(-1, num_generations)
+
+# Media por grupo: Forma (B,) = (2,)
+mean_grouped_rewards = rewards_grouped.mean(dim=1)
+
+# Desv. est. por grupo: Forma (B,) = (2,)
+std_grouped_rewards = rewards_grouped.std(dim=1)
+
+# Difundir (broadcast) para coincidir con rewards y normalizar: Forma (B * G,) = (8,)
+# ¿Por qué necesitamos difundir? Porque necesitamos calcular los valores de ventaja para cada respuesta dentro del grupo
+mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(num_generations, dim=0)
+std_grouped_rewards = std_grouped_rewards.repeat_interleave(num_generations, dim=0)
+```
+
+Esto generará:
+
+```text
+Grouped Rewards: tensor([[1., 0., 0., 1.],
+ [0., 0., 1., 1.]])
+Mean per group: tensor([0.5000, 0.5000])
+Std per group: tensor([0.5774, 0.5774])
+Broadcasted Mean: tensor([0.5000, 0.5000, 0.5000, 0.5000, 0.5000, 0.5000, 0.5000, 0.5000])
+Broadcasted Std: tensor([0.5774, 0.5774, 0.5774, 0.5774, 0.5774, 0.5774, 0.5774, 0.5774])
+```
+
+Ahora podemos calcular los valores de ventaja para cada respuesta:
+
+```python
+# Ventajas: Forma (B * G,) = (8,)
+advantages = (rewards - mean_grouped_rewards) / (std_grouped_rewards + 1e-8)
+```
+
+Esto generará:
+
+```text
+Advantages: tensor([ 0.8659, -0.8660, -0.8660, 0.8659, -0.8660, -0.8660, 0.8659, 0.8659])
+```
+
+Lo cual proviene de la fórmula de ventaja anterior:
+
+```text
+Para reward_1 = [1, 0, 0, 1]:
+1 - 0.5 / 0.5774 ≈ 0.8659
+0 - 0.5 / 0.5774 ≈ -0.8660
+Para reward_2 = [0, 0, 1, 1]: Mismo patrón.
+```
+
+Sin embargo, la forma aquí es `(B*G,) = (8,)`, pero en la práctica necesitamos tener la forma `(B, G) = (2, 4)` para coincidir con la forma de los logits, ¿verdad? Por lo tanto, necesitamos expandir dimensiones (`unsqueeze`) en el tensor de ventajas para tener la forma `(B*G, 1) = (8, 1)` y coincidir con la forma de los logits.
+
+```python
+# Forma (B * G, 1) = (8, 1) para coincidir con la forma de logits
+advantages = advantages.unsqueeze(1)
+```
+
+Lo que producirá:
+
+```text
+Advantages: tensor([[ 0.8659],
+ [-0.8660],
+ [-0.8660],
+ [ 0.8659],
+ [-0.8660],
+ [-0.8660],
+ [ 0.8659],
+ [ 0.8659]])
+```
+
+Ahora que todo está listo, pasemos al siguiente paso: actualizar el modelo de política en función de los valores de ventaja.
+
+### 3. Actualizar la política
+Por último, usamos los valores de ventaja para actualizar nuestro modelo:
+
+```python
+# Calcular razón de probabilidad entre la política nueva y la antigua
+ratio = torch.exp(
+ new_per_token_logps - per_token_logps
+) # Forma: (B*G, seq_len) donde seq_len es la longitud de la salida, es decir, el número de tokens generados, por lo que aquí por simplicidad supongamos que es 1 # (8, 1)
+```
+
+Ten en cuenta que `per_token_logps` se puede obtener pasando las salidas generadas al modelo para obtener los logits y luego aplicando la función softmax para obtener las probabilidades `F.softmax(logits, dim=-1)`.
+
+```python
+# Función de recorte
+eps = self.cliprange # ej. 0.2
+pg_losses1 = -advantages * ratio # Forma: (B*G, seq_len) #(8, 1)
+pg_losses2 = -advantages * torch.clamp(
+ ratio, 1.0 - eps, 1.0 + eps
+) # Forma: (B*G, seq_len) #(8, 1)
+pg_loss_max = torch.max(pg_losses1, pg_losses2) # Forma: (B*G, seq_len) #(8, 1)
+
+
+# Ahora combinar con penalización KL # Forma: (B*G, seq_len) #(8, 1)
+per_token_loss = pg_loss_max + self.beta * per_token_kl
+```
+
+`per_token_kl` también se puede calcular de la siguiente manera:
+
+```python
+# Forma: (B*G, seq_len) #(8, 1)
+per_token_kl = F.kl_div(
+ F.log_softmax(new_per_token_logps, dim=-1),
+ F.softmax(per_token_logps, dim=-1),
+ reduction="none",
+).sum(dim=-1, keepdim=True)
+```
+
+Se puede encontrar un ejemplo completo [aquí](./basic_example.py). GRPO también está implementado por el excelente equipo de TRL; puedes consultar la implementación [TRL/GRPO_trainer](https://github.com/huggingface/trl/blob/main/trl/trainer/grpo_trainer.py) para obtener más detalles.
+
+## Resumen y próximos pasos
+
+¡Felicitaciones! Has aprendido sobre Group Relative Policy Optimization (GRPO). Para recapitular lo que hemos cubierto:
+
+1. GRPO compara múltiples salidas dentro de un grupo para determinar cuáles son mejores que otras, sin requerir un modelo de valor independiente.
+2. El cálculo de la ventaja estandariza las recompensas para identificar qué respuestas están por encima o por debajo del promedio.
+3. La actualización de la política utiliza una función objetivo recortada con una penalización por divergencia KL para garantizar un aprendizaje estable.
+
+Este enfoque es particularmente poderoso para tareas de razonamiento matemático, donde la corrección se puede verificar objetivamente. El método GRPO permite un entrenamiento más eficiente en comparación con los enfoques tradicionales de RLHF que requieren un modelo de crítico independiente.
+
+A medida que continúes explorando GRPO, considera experimentar con diferentes tamaños de grupo, funciones de recompensa y coeficientes de penalización KL para ver cómo afectan el rendimiento de tu modelo.
+
+¡Feliz entrenamiento! 🚀
+
+## Referencias
+1. [Libro de RLHF por Nathan Lambert](https://github.com/natolambert/rlhf-book)
+2. [Informe técnico de DeepSeek-V3](https://huggingface.co/papers/2412.19437)
+3. [DeepSeekMath](https://huggingface.co/papers/2402.03300)
diff --git a/chapters/es/chapter12/img/1.png b/chapters/es/chapter12/img/1.png
new file mode 100644
index 000000000..a53e8a186
Binary files /dev/null and b/chapters/es/chapter12/img/1.png differ
diff --git a/chapters/es/chapter12/img/2.jpg b/chapters/es/chapter12/img/2.jpg
new file mode 100644
index 000000000..d1fd22662
Binary files /dev/null and b/chapters/es/chapter12/img/2.jpg differ