# Smol-Course

## Docs

- [Un Pequeño (Smol) Curso](https://huggingface.co/learn/smol-course/es/README.md)
- [Bienvenido al 🤗 smol-course](https://huggingface.co/learn/smol-course/es/unit0/1.md)
- [Benchmarks Automáticos](https://huggingface.co/learn/smol-course/es/unit4/1.md)
- [Evaluación](https://huggingface.co/learn/smol-course/es/unit4/0.md)
- [Evaluación Personalizada en un Dominio](https://huggingface.co/learn/smol-course/es/unit4/2.md)
- [Entendiendo DPO](https://huggingface.co/learn/smol-course/es/unit2/1.md)
- [Alineación de Preferencias](https://huggingface.co/learn/smol-course/es/unit2/0.md)
- [Entendiendo ORPO](https://huggingface.co/learn/smol-course/es/unit2/2.md)
- [Plantillas de Chat](https://huggingface.co/learn/smol-course/es/unit1/1.md)
- [Ajuste por Instrucciones (Instruction Tuning)](https://huggingface.co/learn/smol-course/es/unit1/0.md)
- [Fine-Tuning Supervisado](https://huggingface.co/learn/smol-course/es/unit1/2.md)
- [LoRA (Adaptación de Bajo Rango)](https://huggingface.co/learn/smol-course/es/unit3/1.md)
- [Fine-Tuning Eficiente en Parámetros (PEFT)](https://huggingface.co/learn/smol-course/es/unit3/0.md)
- [Ajuste de Prompts](https://huggingface.co/learn/smol-course/es/unit3/2.md)

### Un Pequeño (Smol) Curso
https://huggingface.co/learn/smol-course/es/README.md

# Un Pequeño (Smol) Curso

Este curso práctico está enfocado en alinear modelos de lenguaje para casos de uso específicos. Es una forma accesible de empezar a trabajar con modelos de lenguaje, ya que puede ejecutarse en la mayoría de las máquinas locales con requisitos mínimos de GPU y sin necesidad de servicios pagos. El curso se basa en la serie de modelos [SmolLM2](https://github.com/huggingface/smollm/tree/main), pero las habilidades que adquieras aquí son transferibles a modelos más grandes o otros modelos pequeños de lenguaje.

<a href="http://hf.co/join/discord">
<img src="https://img.shields.io/badge/Discord-7289DA?&logo=discord&logoColor=white"/>
</a>

<div style="background: linear-gradient(to right, #e0f7fa, #e1bee7, orange); padding: 20px; border-radius: 5px; margin-bottom: 20px; color: purple;">
    <h2>¡La participación es abierta, gratuita y ahora!</h2>
    <p>Este curso es abierto y revisado por la comunidad. Para participar, simplemente <strong>abre un pull request</strong> y envía tu trabajo para su revisión. Sigue estos pasos:</p>
    <ol>
        <li>Haz un fork del repositorio <a href="https://github.com/huggingface/smol-course/fork">aquí</a></li>
        <li>Lee el material, haz cambios, completa los ejercicios y agrega tus ejemplos.</li>
        <li>Abre un PR en la rama december_2024</li>
        <li>Haz que se revise y se fusione</li>
    </ol>
    <p>Este proceso te ayudará a aprender y a construir un curso dirigido por la comunidad que mejora constantemente.</p>
</div>

Podemos discutir el proceso en este [hilo de discusión](https://github.com/huggingface/smol-course/discussions/2#discussion-7602932).

## Estructura del Curso

Este curso ofrece un enfoque práctico para trabajar con modelos pequeños de lenguaje, desde el entrenamiento inicial hasta el despliegue en producción.

| Módulo | Descripción | Estado | Fecha de lanzamiento |
|--------|-------------|--------|----------------------|
| [Ajuste de Instrucciones](./1_instruction_tuning) | Aprende ajuste fino (fine-tuning) supervisado, plantillas de chat y seguimiento básico de instrucciones | ✅ Completo | 3 de diciembre de 2024 |
| [Alineación de Preferencias](./2_preference_alignment) | Explora las técnicas DPO y ORPO para alinear modelos con las preferencias humanas | ✅ Completo | 6 de diciembre de 2024 |
| [Ajuste Fino (Fine-tuning) Eficiente en Parámetros](./3_parameter_efficient_finetuning) | Aprende LoRA, ajuste de prompt y métodos de adaptación eficientes | [🚧 En Progreso](https://github.com/huggingface/smol-course/pull/41) | 9 de diciembre de 2024 |
| [Evaluación](./4_evaluation) | Usa benchmarks automáticos y crea evaluaciones personalizadas para dominios | [🚧 En Progreso](https://github.com/huggingface/smol-course/issues/42) | 13 de diciembre de 2024 |
| [Modelos Visión-Lenguaje](./5_vision_language_models) | Adapta modelos multimodales para tareas visión-lenguaje | [🚧 En Progreso](https://github.com/huggingface/smol-course/issues/49) | 16 de diciembre de 2024 |
| [Conjuntos de Datos Sintéticos](./6_synthetic_datasets) | Crea y valida conjuntos de datos sintéticos para el entrenamiento | 📝 Planificado | 20 de diciembre de 2024 |
| [Inferencia](./7_inference) | Inferencia eficiente con modelos | 📝 Planificado | 23 de diciembre de 2024 |

## ¿Por qué Modelos Pequeños de Lenguaje?

Si bien los modelos grandes de lenguaje han mostrado capacidades impresionantes, requieren recursos computacionales significativos y pueden ser excesivos para aplicaciones específicas. Los modelos pequeños de lenguaje ofrecen varias ventajas para aplicaciones de dominio:

- **Eficiencia**: Requieren menos recursos computacionales para entrenar y desplegar
- **Personalización**: Más fáciles de ajustar para dominios específicos
- **Control**: Mayor control sobre el comportamiento del modelo
- **Costo**: Menores costos operativos para el entrenamiento y la inferencia
- **Privacidad**: Pueden ejecutarse localmente, manteniendo la privacidad de los datos
- **Sostenibilidad**: Uso eficiente de recursos con una huella de carbono más pequeña
- **Investigación Académica**: Facilita la investigación académica con menos restricciones logísticas

## Requisitos Previos

Antes de comenzar, asegúrate de tener:

- Conocimientos básicos en aprendizaje automático y procesamiento de lenguaje natural
- Familiaridad con Python, PyTorch y la librería `transformers`
- Acceso a un modelo de lenguaje preentrenado y un conjunto de datos etiquetado

## Instalación

Mantenemos el curso como un paquete para facilitar la instalación de dependencias. Recomendamos usar [uv](https://github.com/astral-sh/uv), pero también puedes utilizar alternativas como `pip` o `pdm`.

### Usando `uv`

Con `uv` instalado, puedes configurar el entorno del curso de esta manera:

```bash
uv venv --python 3.11.0
uv sync
```

### Usando `pip`

Para un entorno **python 3.11**, utiliza los siguientes comandos para instalar las dependencias:

```bash
# python -m venv .venv
# source .venv/bin/activate
pip install -r requirements.txt
```

### Google Colab

Para **Google Colab**, instala las dependencias de la siguiente manera:

```bash
pip install -r transformers trl datasets huggingface_hub
```

## Participación

Compartamos este curso para que muchas personas puedan aprender a ajustar LLMs sin necesidad de hardware costoso.

[![Star History Chart](https://api.star-history.com/svg?repos=huggingface/smol-course&type=Date)](https://star-history.com/#huggingface/smol-course&Date)

<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/README.md" />

### Bienvenido al 🤗 smol-course
https://huggingface.co/learn/smol-course/es/unit0/1.md

# Bienvenido al 🤗 smol-course

![Fine-Tuning Course thumbnail](https://github.com/huggingface/smol-course/blob/main/banner.png?raw=true)

¡Bienvenido al curso completo (y el más pequeño) sobre **el Fine-tuning de Modelos de Lenguaje**!

Este curso gratuito te llevará por una aventura, desde principiante hasta experto, en la comprensión, implementación y optimización de técnicas de fine-tuning para modelos extensos de lenguaje

Esta primera unidad te ayudará a incorporarte:

- Descubre el **programa del curso**.
- **Obtén más información sobre el proceso de certificación y el calendario**.
- Conoce al equipo que está detrás del curso.
- Crea tu **cuenta**.
- **Regístrate en nuestro servidor de Discord** y conoce a tus compañeros de clase y a nosotros.

¡Empecemos!

> [!TIP]
> ¡Este curso es pequeño pero intenso! Está dirigido a desarrolladores de software e ingenieros que desean acelerar el perfeccionamiento de sus habilidades en fine-tuning de modelos de lenguaje grande (LLM). Si no es tu caso, echa un vistazo al [Curso LLM](https://huggingface.co/learn/llm-course/).

## ¿Qué puedes esperar de este curso?

En este curso, podrás:

- 📖 Estudiar el ajuste por instrucciones, fine-tuning supervisado, y la alineación de preferencias en la teoría y en la práctica.
- 🧑‍💻 Aprender a usar frameworks y herramientas como TRL y Transformers.
- 💾 Compartir tus proyectos y explorar aplicaciones de fine-tuning creadas por la comunidad.
- 🏆 Participar en retos en los que evaluarás tus modelos ajustados frente a los de otros estudiantes.
- 🎓 Conseguir un certificado de finalización al completar las tareas.

Al terminar este curso, comprenderás **cómo ajustar los modelos de lenguaje de manera eficaz y crear aplicaciones de IA especializadas utilizando las últimas técnicas de fine-tuning**.

¡No olvides [**inscribirte al curso!**](https://huggingface.co/smol-course)

## ¿Cómo es el curso?

El curso se compone de:

- _Unidades fundamentales_: donde aprenderás **conceptos teóricos** sobre el fine-tuning.

* _Prácticas_: donde aprenderás **a utilizar frameworks de fine-tuning establecidos** para adaptar tus modelos. Estas secciones prácticas contarán con entornos preconfigurados.
* _Tareas de casos prácticos_: donde aplicarás los conceptos que has aprendido para resolver un problema del mundo real que tú mismo elegirás.
* _Colaboraciones_: colaboramos con los socios de Hugging Face para ofrecerte las últimas implementaciones y herramientas de fine-tuning.

Este **curso es un proyecto vivo, que evoluciona con tus comentarios y contribuciones.** No dudes en abrir issues y Pull Requests en GitHub, y participa en los debates en nuestro servidor de Discord.

## Cual es el plan de estudio?

Aquí está el **plan de estudio general del curso**. Se publicará una lista más detallada de temas con cada unidad.

| #   | Tema                       | Descripción                                                                      | Fecha de publicación |
| --- | -------------------------- | -------------------------------------------------------------------------------- | -------------------- |
| 1   | Ajuste por Instrucciones   | Fine-tuning supervisado, plantillas de chat, seguimiento de instrucciones        | ✅                   |
| 2   | Evaluación                 | Puntos de referencia y evaluación de dominios personalizados                     | Septiembre           |
| 3   | Alineación de Preferencias | Alineación de modelos con las preferencias humanas mediante algoritmos como DPO. | Octubre              |
| 4   | Aprendizaje por Refuerzo   | Optimización de modelos basados en políticas de refuerzo.                        | Octubre              |
| 5   | Modelos de Lenguaje Visual | Adaptación y uso de modelos multimodales                                         | Noviembre            |
| 6   | Datos Sintéticos           | Generación de conjuntos de datos sintéticos para dominios personalizados         | Noviembre            |
| 7   | Ceremonia de Premiación    | Presentación de proyectos y celebración                                          | Diciembre            |

## ¿Cuáles son los requisitos previos?

Para poder seguir este curso, debes tener:

- Conocimientos básicos sobre los conceptos de IA y LLM.
- Familiaridad con la programación en Python y los fundamentos del machine learning.
- Experiencia con PyTorch o frameworks de aprendizaje profundo similares.
- Conocimientos básicos sobre la arquitectura de los transformadores.

Si no cumples ninguno de estos requisitos, no te preocupes. Echa un vistazo al [Curso LLM](https://huggingface.co/learn/llm-course/) para empezar.

> [!TIP]
> Los cursos anteriores no son requisitos previos en sí mismos, por lo que si comprendes los conceptos de modelos extensos de lenguaje y transformadores, ¡puedes comenzar el curso ahora mismo!

## ¿Qué herramientas necesito?

Solo necesitas dos cosas:

- _Un ordenador_ con conexión a Internet y, preferiblemente, acceso a un GPU ([Hugging Face Pro](https://huggingface.co/pro) funciona muy bien).
- Una _cuenta_: para acceder a los recursos del curso y crear proyectos. Si aún no tienes una cuenta, puedes crear una [aquí](https://huggingface.co/join) (es gratis).

## El proceso de certificación

Puedes elegir entre seguir este curso _de oyente_ o realizar las actividades y _obtener uno de los dos certificados que emitimos_. Si eliges completar de oyente el curso, puedes participar en todos los retos y realizar las tareas si lo deseas, y **no es necesario que nos lo notifiques**.

El proceso de certificación es **totalmente gratuito**:

- _Para obtener una certificación de fundamentos_: debes completar la Unidad 1 del curso. Está dirigida a estudiantes que desean comprender los conceptos básicos del ajuste de instrucciones sin crear aplicaciones avanzadas.
- _Para obtener un certificado de completación_: debes completar todas las unidades del curso y enviar un proyecto final. Está dirigida a estudiantes que desean demostrar su dominio de las técnicas de fine-tuning.

## ¿Cuál es el ritmo recomendado?

Cada capítulo de este curso está diseñado **para completarse en una semana, con aproximadamente 3-4 horas de trabajo semanales**.

Dado que hay una fecha límite, te proporcionamos un ritmo recomendado:

![Miniatura del curso de ajuste fino](https://github.com/huggingface/smol-course/blob/rerelease-chapter-1/schedule.png?raw=true)

## ¿Cómo aprovechar al máximo al curso?

Para aprovechar al máximo al curso, te ofrecemos algunos consejos:

1. [Únete a grupos de estudio en Discord](https://discord.gg/UrrTSsSyjb): Estudiar en grupo siempre es más fácil. Para ello, debes unirte a nuestro servidor de Discord y verificar tu cuenta.
2. **Realiza los cuestionarios y las tareas**: La mejor manera de aprender es mediante la práctica y la autoevaluación.
3. **Establece un horario para mantenerte al día**: Puedes utilizar nuestro calendario recomendado a continuación o crear el tuyo propio.

![Consejos para el curso](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit0/3.png)

## Quiénes somos

Acerca de los autores:

### Ben Burtenshaw

Ben es ingeniero de Machine Learning en Hugging Face y se dedica a crear aplicaciones de modelos extensos de lenguaje, con enfoques de post-entrenamiento y agenciales. [Sigue a Ben en el Hub](https://huggingface.co/burtenshaw) para ver sus últimos proyectos.

## Agradecimientos

Nos gustaría expresar nuestro agradecimiento a las siguientes personas y socios por sus valiosas contribuciones y su apoyo:

- [Hugging Face Transformers](https://huggingface.co/docs/transformers)
- [TRL (Transformer Reinforcement Learning)](https://huggingface.co/docs/trl)
- [PEFT (Parameter-Efficient Fine-Tuning)](https://huggingface.co/docs/peft)

## He encontrado un error o quiero mejorar el curso

Las contribuciones son **bienvenidas** 🤗

- Si _has encontrado un error 🐛 en un notebook_, por favor [abre un issue](https://github.com/huggingface/smol-course/issues/new) y **describe el issue**.
- Si _quieres mejorar el curso_, puedes [abrir un Pull Request](https://github.com/huggingface/smol-course/pulls) .
- Si _quieres añadir una sección completa o una nueva unidad_, lo mejor es [abrir un ticket](https://github.com/huggingface/smol-course/issues/new) y **describir qué contenido quieres añadir antes de empezar a escribirlo para que podamos orientarte**.

## Todavía tengo preguntas

Por favor, haz tu pregunta en nuestro servidor de Discord #fine-tuning-course-questions.

Ahora que tienes toda la información, ¡vamos a ponernos en marcha! ⛵


<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit0/1.md" />

### Benchmarks Automáticos
https://huggingface.co/learn/smol-course/es/unit4/1.md

# Benchmarks Automáticos

<CourseFloatingBanner chapter={10}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/smol-course/blob/main/notebooks/es/4_evaluation/lighteval_evaluate_and_analyse_your_LLM.ipynb"},
]} />
    
Los "benchmarks" automáticos sirven como herramientas estandarizadas para evaluar modelos de lenguaje en diferentes tareas y capacidades. Aunque proporcionan un punto de partida útil para entender el rendimiento de un modelo, es importante reconocer que representan solo una parte de una estrategia de evaluación integral.

## Entendiendo los Benchmarks Automáticos

Los "benchmarks" automáticos generalmente consisten en conjuntos de datos curados con tareas y métricas de evaluación predefinidas. Estos "benchmarks" buscan evaluar diversos aspectos de la capacidad del modelo, desde la comprensión básica del lenguaje hasta el razonamiento complejo. La principal ventaja de usar "benchmarks" automáticos es su estandarización: permiten comparaciones consistentes entre diferentes modelos y proporcionan resultados reproducibles.

Sin embargo, es crucial entender que el rendimiento en un "benchmark" no siempre se traduce directamente en efectividad en el mundo real. Un modelo que sobresale en "benchmarks" académicos puede tener dificultades en aplicaciones específicas de dominio o casos de uso prácticos.

## Benchmarks y Sus Limitaciones

### Benchmarks de Conocimientos Generales

MMLU (Massive Multitask Language Understanding) evalúa conocimientos en 57 materias, desde ciencias hasta humanidades. Aunque es extenso, puede no reflejar la profundidad de experiencia necesaria para dominios específicos. TruthfulQA evalúa la tendencia de un modelo a reproducir conceptos erróneos comunes, aunque no puede capturar todas las formas de desinformación.

### Benchmarks de Razonamiento

BBH (Big Bench Hard) y GSM8K se enfocan en tareas de razonamiento complejo. BBH evalúa el pensamiento lógico y la planificación, mientras que GSM8K se centra específicamente en la resolución de problemas matemáticos. Estos "benchmarks" ayudan a evaluar capacidades analíticas pero pueden no capturar el razonamiento matizado requerido en escenarios del mundo real.

### Comprensión del Lenguaje

HELM proporciona un marco de evaluación holístico, mientras que WinoGrande prueba el sentido común mediante la desambiguación de pronombres. Estos "benchmarks" ofrecen información sobre las capacidades de procesamiento del lenguaje, pero pueden no representar completamente la complejidad de las conversaciones naturales o la terminología específica de un dominio.

## Enfoques Alternativos de Evaluación

Muchas organizaciones han desarrollado métodos de evaluación alternativos para abordar las limitaciones de los "benchmarks" estándar:

### Model de lenguaje como Juez (LLM-as-Judge)

Usar un modelo de lenguaje para evaluar los "outputs" de otro modelo se ha vuelto cada vez más popular. Este enfoque puede proporcionar retroalimentación más matizada que las métricas tradicionales, aunque viene con sus propios sesgos y limitaciones.

### Arenas de Evaluación (Evaluation Arenas)

Plataformas como Chatbot Arena permiten que los modelos interactúen y se evalúen entre sí en entornos controlados. Esto puede revelar fortalezas y debilidades que podrían no ser evidentes en "benchmarks" tradicionales.

### Grupos de Benchmarks Personalizados

Las organizaciones a menudo desarrollan conjuntos de "benchmarks" internos adaptados a sus necesidades específicas y casos de uso. Estos pueden incluir pruebas de conocimientos específicos de dominio o escenarios de evaluación que reflejen las condiciones reales de despliegue.

## Creando Tu Propia Estrategia de Evaluación

Recuerda que aunque LightEval facilita ejecutar "benchmarks" estándar, también deberías invertir tiempo en desarrollar métodos de evaluación específicos para tu caso de uso.

Aunque los "benchmarks" estándares proporcionan una línea base útil, no deberían ser tu único método de evaluación. Así es como puedes desarrollar un enfoque más integral:

1. Comienza con "benchmarks" estándares relevantes para establecer una línea base y permitir comparaciones con otros modelos.

2. Identifica los requisitos y desafíos específicos de tu caso de uso. ¿Qué tareas realizará tu modelo realmente? ¿Qué tipos de errores serían más problemáticos?

3. Desarrolla conjuntos de datos de evaluación personalizados que reflejen tu caso de uso real. Esto podría incluir:
   - Consultas reales de usuarios en tu dominio
   - Casos límite comunes que hayas encontrado
   - Ejemplos de escenarios particularmente desafiantes

4. Considera implementar una estrategia de evaluación por capas:
   - Métricas automatizadas para retroalimentación rápida
   - Evaluación humana para una comprensión más matizada
   - Revisión por expertos en el dominio para aplicaciones especializadas
   - Pruebas A/B en entornos controlados

## Usando LightEval para "Benchmarking"

Las tareas de LightEval se definen usando un formato específico:
``` 
{suite}|{task}|{num_few_shot}|{auto_reduce} 
```

- **suite**: El conjunto de "benchmarks" (por ejemplo, 'mmlu', 'truthfulqa')
- **task**: Tarea específica dentro del conjunto (por ejemplo, 'abstract_algebra')
- **num_few_shot**: Número de ejemplos a incluir en el "prompt" (0 para zero-shot)
- **auto_reduce**: Si se debe reducir automáticamente los ejemplos "few-shot" si el "prompt" es demasiado largo (0 o 1)

Ejemplo: `"mmlu|abstract_algebra|0|0"` evalúa la tarea de álgebra abstracta de MMLU sin ejempls en el "prompt" (i.e. "zero-shot").

### Ejemplo de Pipeline de Evaluación

Aquí tienes un ejemplo completo de configuración y ejecución de una evaluación utilizando "benchmarks" automáticos relevantes para un dominio específico:

```python
from lighteval.tasks import Task, Pipeline
from transformers import AutoModelForCausalLM

# Definir tareas para evaluar
domain_tasks = [
    "mmlu|anatomy|0|0",
    "mmlu|high_school_biology|0|0", 
    "mmlu|high_school_chemistry|0|0",
    "mmlu|professional_medicine|0|0"
]

# Configurar parámetros del pipeline
pipeline_params = {
    "max_samples": 40,  # Número de muestras para evaluar
    "batch_size": 1,    # Tamaño del "batch" para la inferencia
    "num_workers": 4    # Número de procesos paralelos
}

# Crear tracker de evaluación
evaluation_tracker = EvaluationTracker(
    output_path="./results",
    save_generations=True
)

# Cargar modelo y crear pipeline
model = AutoModelForCausalLM.from_pretrained("your-model-name")
pipeline = Pipeline(
    tasks=domain_tasks,
    pipeline_parameters=pipeline_params,
    evaluation_tracker=evaluation_tracker,
    model=model
)

# Ejecutar evaluación
pipeline.evaluate()

# Obtener y mostrar resultados
results = pipeline.get_results()
pipeline.show_results()
```

Los resultados se muestran en formato tabular:
``` 
|                  Task                  |Version|Metric|Value |   |Stderr|
|----------------------------------------|------:|------|-----:|---|-----:|
|all                                     |       |acc   |0.3333|±  |0.1169|
|leaderboard:mmlu:_average:5             |       |acc   |0.3400|±  |0.1121|
|leaderboard:mmlu:anatomy:5              |      0|acc   |0.4500|±  |0.1141|
|leaderboard:mmlu:high_school_biology:5  |      0|acc   |0.1500|±  |0.0819|
```

También puedes manejar los resultados en un DataFrame de pandas y visualizarlos o representarlos como prefieras.

# Próximos Pasos

⏩ Explora [Evaluación Personalizada en un Dominio](./custom_evaluation.md) para aprender a crear flujos de evaluación adaptados a tus necesidades específicas.


<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit4/1.md" />

### Evaluación
https://huggingface.co/learn/smol-course/es/unit4/0.md

# Evaluación

La evaluación es un paso crítico en el desarrollo y despliegue de modelos de lenguaje. Nos permite entender qué tan bien funcionan nuestros modelos en diferentes capacidades e identificar áreas de mejora. Este módulo cubre tanto los "becnhmarks" estándares como los enfoques de evaluación específicos para evaluar de manera integral tu modelo **smol**.

Usaremos [`lighteval`](https://github.com/huggingface/lighteval), una poderosa biblioteca de evaluación desarrollada por Hugging Face que se integra perfectamente con el ecosistema de Hugging Face. Para una explicación más detallada sobre los conceptos y mejores prácticas de evaluación, consulta la [guía de evaluación](https://github.com/huggingface/evaluation-guidebook).

## Descripción del Módulo

Una estrategia de evaluación completa examina múltiples aspectos del rendimiento del modelo. Evaluamos capacidades específicas en tareas como responder preguntas y resumir textos, para entender cómo el modelo maneja diferentes tipos de problemas. Medimos la calidad del "output" mediante factores como coherencia y precisión. A su vez, la evaluación de seguridad ayuda a identificar posibles "outputs" dañinas o sesgos. Finalmente, las pruebas de experticia en áreas especfícios verifican el conocimiento especializado del modelo en tu campo objetivo.

## Contenidos

### 1️⃣ [Evaluaciones Automáticas](./automatic_benchmarks.md)
Aprende a evaluar tu modelo utilizando "benchmarks" y métricas estandarizadas. Exploraremos "benchmarks" comunes como MMLU y TruthfulQA, entenderemos las métricas clave de evaluación y configuraciones, y cubriremos mejores prácticas para una evaluación reproducible.

### 2️⃣ [Evaluación Personalizada en un Dominio](./custom_evaluation.md)
Descubre cómo crear flujos de evaluación adaptados a tus casos de uso específicos. Te guiaremos en el diseño de tareas de evaluación personalizadas, la implementación de métricas especializadas y la construcción de conjuntos de datos de evaluación que se ajusten a tus necesidades.

### 3️⃣ [Proyecto de Evaluación en un Dominio](./project/README.md)
Sigue un ejemplo completo de cómo construir un flujo de evaluación específico para un dominio. Aprenderás a generar conjuntos de datos de evaluación, usar Argilla para la anotación de datos, crear conjuntos de datos estandarizados y evaluar modelos utilizando LightEval.

## Recursos

- [Guía de Evaluación](https://github.com/huggingface/evaluation-guidebook) - Guía completa para la evaluación de modelos de lenguaje
- [Documentación de LightEval](https://github.com/huggingface/lighteval) - Documentación oficial de la biblioteca LightEval
- [Documentación de Argilla](https://docs.argilla.io) - Aprende sobre la plataforma de anotación Argilla
- [Paper de MMLU](https://arxiv.org/abs/2009.03300) - Artículo sobre el benchmark MMLU
- [Crear una Tarea Personalizada](https://github.com/huggingface/lighteval/wiki/Adding-a-Custom-Task)
- [Crear una Métrica Personalizada](https://github.com/huggingface/lighteval/wiki/Adding-a-New-Metric)
- [Usar métricas existentes](https://github.com/huggingface/lighteval/wiki/Metric-List)


<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit4/0.md" />

### Evaluación Personalizada en un Dominio
https://huggingface.co/learn/smol-course/es/unit4/2.md

# Evaluación Personalizada en un Dominio

<CourseFloatingBanner chapter={10}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/smol-course/blob/main/notebooks/es/4_evaluation/lighteval_evaluate_and_analyse_your_LLM.ipynb"},
]} />
    
Aunque los "benchmarks" estándares proporcionan conocimiento relevante, muchas aplicaciones requieren enfoques de evaluación especializados que se adapten a dominios específicos o a casos de uso particulares. Esta guía te ayudará a crear flujos de evaluación personalizados que evalúen con precisión el rendimiento de tu modelo en tu dominio objetivo.

## Diseñando Tu Estrategia de Evaluación

Una estrategia de evaluación personalizada exitosa comienza con objetivos claros. Es fundamental considerar qué capacidades específicas necesita demostrar tu modelo en tu dominio. Esto podría incluir conocimientos técnicos, patrones de razonamiento o formatos específicos del dominio. Documenta estos requisitos cuidadosamente; ellos guiarán tanto el diseño de tus tareas como la selección de métricas.

Tu evaluación debe probar tanto casos de uso estándar como casos límite. Por ejemplo, en un dominio médico, podrías evaluar tanto escenarios comunes de diagnóstico como condiciones raras. En aplicaciones financieras, podrías probar tanto transacciones rutinarias como casos complejos que involucren múltiples monedas o condiciones especiales.

## Implementación con LightEval

LightEval proporciona un marco flexible para implementar evaluaciones personalizadas. Así es como puedes crear una tarea personalizada:

```python
from lighteval.tasks import Task, Doc
from lighteval.metrics import SampleLevelMetric, MetricCategory, MetricUseCase

class CustomEvalTask(Task):
    def __init__(self):
        super().__init__(
            name="custom_task",
            version="0.0.1",
            metrics=["accuracy", "f1"],  # Tus métricas elegidas
            description="Descripción de tu tarea de evaluación personalizada"
        )
    
    def get_prompt(self, sample):
        # Formatea tu entrada en un "prompt"
        return f"Question: {sample['question'
  ]}\nAnswer:"
    
    def process_response(self, response, ref):
        # Procesa el "output" del modelo y compáralo con la referencia
        return response.strip() == ref.strip()
```

## Métricas Personalizadas

Las tareas específicas de dominio a menudo requieren métricas especializadas. LightEval proporciona un marco flexible para crear métricas personalizadas que capturen aspectos relevantes del rendimiento del dominio:

```python
from aenum import extend_enum
from lighteval.metrics import Metrics, SampleLevelMetric, SampleLevelMetricGrouping
import numpy as np

# Definir una función de métrica a nivel de muestra
def custom_metric(predictions: list[str], formatted_doc: Doc, **kwargs) -> dict:
    """Ejemplo de métrica que genera múltiples puntuaciones por muestra"""
    response = predictions[0]
    return {
        "accuracy": response == formatted_doc.choices[formatted_doc.gold_index],
        "length_match": len(response) == len(formatted_doc.reference)
    }

# Crear una métrica que genere múltiples valores por muestra
custom_metric_group = SampleLevelMetricGrouping(
    metric_name=["accuracy", "length_match"],  # Nombres de submétricas
    higher_is_better={  # define si valores más altos son mejores para cada métrica
        "accuracy": True,
        "length_match": True
    },
    category=MetricCategory.CUSTOM,
    use_case=MetricUseCase.SCORING,
    sample_level_fn=custom_metric,
    corpus_level_fn={  # define cómo agregar cada métrica
        "accuracy": np.mean,
        "length_match": np.mean
    }
)

# Registrar la métrica en LightEval
extend_enum(Metrics, "custom_metric_name", custom_metric_group)
```

Para casos más simples donde solo necesitas un valor por muestra:

```python
def simple_metric(predictions: list[str], formatted_doc: Doc, **kwargs) -> bool:
    """Ejemplo de métrica que genera una única puntuación por muestra"""
    response = predictions[0]
    return response == formatted_doc.choices[formatted_doc.gold_index]

simple_metric_obj = SampleLevelMetric(
    metric_name="simple_accuracy",
    higher_is_better=True,
    category=MetricCategory.CUSTOM,
    use_case=MetricUseCase.SCORING,
    sample_level_fn=simple_metric,
    corpus_level_fn=np.mean  # define cómo agregar resultados entre muestras
)

extend_enum(Metrics, "simple_metric", simple_metric_obj)
```

Una vez definas tus métricas personalizadas, puedes usarlas luego en tus tareas de evaluación haciendo referencia a ellas en la configuración de la tarea. Las métricas se calcularán automáticamente en todas las muestras y se agregarán según las funciones que especifiques.

Para métricas más complejas, considera:
- Usar metadatos en tus documentos formateados para ponderar o ajustar puntuaciones
- Implementar funciones de agregación personalizadas para estadísticas a nivel de corpus
- Agregar verificaciones de validación para las entradas de tus métricas
- Documentar casos límite y comportamientos esperados

Para un ejemplo completo de métricas personalizadas en acción, consulta nuestro [proyecto de evaluación de dominio](./project/README.md).

## Creación de Conjuntos de Datos

La evaluación de alta calidad requiere conjuntos de datos cuidadosamente curados. Considera estos enfoques para la creación de conjuntos de datos:

1. **Anotación por Expertos**: Trabaja con expertos del dominio para crear y validar ejemplos de evaluación. Herramientas como [Argilla](https://github.com/argilla-io/argilla) hacen este proceso más eficiente.

2. **Datos del Mundo Real**: Recopila y anonimiza datos de uso real, asegurándote de que representen escenarios reales de despliegue del modelo.

3. **Generación Sintética**: Usa LLMs para generar ejemplos iniciales y luego permite que expertos los validen y refinen.

## Mejores Prácticas

- Documenta tu metodología de evaluación a fondo, incluidas los supuestos o limitaciones
- Incluye casos de prueba diversos que cubran diferentes aspectos de tu dominio
- Considera tanto métricas automatizadas como evaluaciones humanas donde sea apropiado
- Controla las versiones de tus conjuntos de datos y código de evaluación
- Actualiza regularmente tu conjunto de evaluaciones a medida que descubras nuevos casos límite o requisitos

## Referencias

- [Guía de Tareas Personalizadas en LightEval](https://github.com/huggingface/lighteval/wiki/Adding-a-Custom-Task)
- [Métricas Personalizadas en LightEval](https://github.com/huggingface/lighteval/wiki/Adding-a-New-Metric)
- [Documentación de Argilla](https://docs.argilla.io) para anotación de conjuntos de datos
- [Guía de Evaluación](https://github.com/huggingface/evaluation-guidebook) para principios generales de evaluación

# Próximos Pasos

⏩ Para un ejemplo completo de cómo implementar estos conceptos, consulta nuestro [proyecto de evaluación de dominio](./project/README.md).


<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit4/2.md" />

### Entendiendo DPO
https://huggingface.co/learn/smol-course/es/unit2/1.md

## Entendiendo DPO

DPO redefine la alineación de preferencias como un problema de clasificación basado en datos de preferencias humanas. Los enfoques tradicionales de RLHF requieren entrenar un modelo de recompensa separado y usar algoritmos complejos como PPO (Proximal Policy Optimization) para alinear las salidas del modelo. DPO simplifica este proceso al definir una función de pérdida que optimiza directamente la política del modelo en función de las salidas preferidas versus las no preferidas.

Este enfoque ha demostrado ser altamente efectivo en la práctica, utilizándose para entrenar modelos como Llama. Al eliminar la necesidad de un modelo de recompensa separado y una etapa de aprendizaje por refuerzo, DPO hace que la alineación de preferencias sea más accesible y estable.

## Cómo Funciona DPO

El proceso de DPO requiere un fine-tuning supervisado (SFT) para adaptar el modelo al dominio objetivo. Esto crea una base para el aprendizaje de preferencias mediante el entrenamiento en conjuntos de datos estándar de seguimiento de instrucciones. El modelo aprende a completar tareas básicas mientras mantiene sus capacidades generales.

Luego viene el aprendizaje de preferencias, donde el modelo se entrena con pares de salidas: una preferida y una no preferida. Los pares de preferencias ayudan al modelo a entender qué respuestas se alinean mejor con los valores y expectativas humanas.

La innovación central de DPO radica en su enfoque de optimización directa. En lugar de entrenar un modelo de recompensa separado, DPO utiliza una pérdida de entropía cruzada binaria para actualizar directamente los pesos del modelo en función de los datos de preferencia. Este proceso simplificado hace que el entrenamiento sea más estable y eficiente, logrando resultados comparables o mejores que los métodos tradicionales de RLHF.

## Conjuntos de Datos para DPO

Los conjuntos de datos para DPO se crean típicamente anotando pares de respuestas como preferidas o no preferidas. Esto se puede hacer manualmente o mediante técnicas de filtrado automatizado. A continuación, se muestra un ejemplo de la estructura de un conjunto de datos de preferencias para DPO en un turno único:

| Prompt | Elegido | Rechazado |
|--------|---------|-----------|
| ...    | ...     | ...       |
| ...    | ...     | ...       |
| ...    | ...     | ...       |

La columna `Prompt` contiene el prompt utilizado para generar las respuestas `Elegido` y `Rechazado`. Las columnas `Elegido` y `Rechazado` contienen las respuestas preferidas y no preferidas, respectivamente. Existen variaciones en esta estructura, por ejemplo, incluyendo una columna de `system_prompt` o `Input` con material de referencia. Los valores de `elegido` y `rechazado` pueden representarse como cadenas para conversaciones de un solo turno o como listas de conversación.

Puedes encontrar una colección de conjuntos de datos DPO en Hugging Face [aquí](https://huggingface.co/collections/argilla/preference-datasets-for-dpo-656f0ce6a00ad2dc33069478).

## Implementación con TRL

La biblioteca Transformers Reinforcement Learning (TRL) facilita la implementación de DPO. Las clases `DPOConfig` y `DPOTrainer` siguen la misma API de estilo `transformers`.

Aquí tienes un ejemplo básico de cómo configurar el entrenamiento de DPO:

```python
from trl import DPOConfig, DPOTrainer

# Definir los argumentos
training_args = DPOConfig(
    ...
)

# Inicializar el entrenador
trainer = DPOTrainer(
    model,
    train_dataset=dataset,
    tokenizer=tokenizer,
    ...
)

# Entrenar el modelo
trainer.train()
```

En el [tutorial de DPO](../../../notebooks/es/2_preference_alignment/../notebooks/es/2_preference_alignment/dpo_finetuning_example.ipynb). Esta guía práctica te guiará a través de la implementación de la alineación de preferencias con tu propio modelo, desde la preparación de datos hasta el entrenamiento y la evaluación.

⏭️ Después de completar el tutorial, puedes explorar la página de [ORPO](./orpo.md) para aprender sobre otra técnica de alineación de preferencias.

<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit2/1.md" />

### Alineación de Preferencias
https://huggingface.co/learn/smol-course/es/unit2/0.md

# Alineación de Preferencias

Este módulo cubre técnicas para alinear modelos de lenguaje con las preferencias humanas. Mientras que la afinación supervisada (SFT) ayuda a los modelos a aprender tareas, la alineación de preferencias fomenta que las salidas coincidan con las expectativas y valores humanos.

## Descripción General

Los métodos típicos de alineación incluyen múltiples etapas:
1. Afinación Supervisada (SFT) para adaptar los modelos a dominios específicos.
2. Alineación de preferencias (como RLHF o DPO) para mejorar la calidad de las respuestas.

Enfoques alternativos como ORPO combinan la afinación por instrucciones y la alineación de preferencias en un solo proceso. Aquí, nos enfocaremos en los algoritmos DPO y ORPO.

Si deseas aprender más sobre las diferentes técnicas de alineación, puedes leer más sobre ellas en el [Blog de Argilla](https://argilla.io/blog/mantisnlp-rlhf-part-8).

### 1️⃣ Optimización Directa de Preferencias (DPO)

La Optimización Directa de Preferencias (DPO) simplifica la alineación de preferencias optimizando directamente los modelos utilizando datos de preferencias. Este enfoque elimina la necesidad de modelos de recompensa separados y de un aprendizaje por refuerzo complejo, lo que lo hace más estable y eficiente que el Aprendizaje por Refuerzo de Retroalimentación Humana (RLHF) tradicional. Para más detalles, puedes consultar la [documentación de Optimización Directa de Preferencias (DPO)](./dpo.md).

### 2️⃣ Optimización de Preferencias por Ratio de Probabilidades (ORPO)

ORPO introduce un enfoque combinado para la afinación por instrucciones y la alineación de preferencias en un solo proceso. Modifica el objetivo estándar del modelado de lenguaje combinando la pérdida de verosimilitud logarítmica negativa con un término de ratio de probabilidades a nivel de token. El enfoque presenta un proceso de entrenamiento de una sola etapa, una arquitectura libre de modelo de referencia y una mayor eficiencia computacional. ORPO ha mostrado resultados impresionantes en varios puntos de referencia, demostrando un mejor rendimiento en AlpacaEval en comparación con los métodos tradicionales. Para más detalles, puedes consultar la [documentación de Optimización de Preferencias por Ratio de Probabilidades (ORPO)](./orpo.md).


## Recursos

- [Documentación de TRL](https://huggingface.co/docs/trl/index) - Documentación para la librería Transformers Reinforcement Learning (TRL), que implementa diversas técnicas de alineación, incluyendo DPO.
- [Papel de DPO](https://arxiv.org/abs/2305.18290) - Artículo original de investigación que introduce la Optimización Directa de Preferencias como una alternativa más simple al RLHF que optimiza directamente los modelos de lenguaje utilizando datos de preferencias.
- [Papel de ORPO](https://arxiv.org/abs/2403.07691) - Introduce la Optimización de Preferencias por Ratio de Probabilidades, un enfoque novedoso que combina la afinación por instrucciones y la alineación de preferencias en una sola etapa de entrenamiento.
- [Guía de RLHF de Argilla](https://argilla.io/blog/mantisnlp-rlhf-part-8/) - Una guía que explica diferentes técnicas de alineación, incluyendo RLHF, DPO y sus implementaciones prácticas.
- [Entrada en el Blog sobre DPO](https://huggingface.co/blog/dpo-trl) - Guía práctica sobre cómo implementar DPO utilizando la librería TRL con ejemplos de código y mejores prácticas.
- [Script de ejemplo de TRL sobre DPO](https://github.com/huggingface/trl/blob/main/examples/scripts/dpo.py) - Script completo de ejemplo que demuestra cómo implementar el entrenamiento DPO utilizando la librería TRL.
- [Script de ejemplo de TRL sobre ORPO](https://github.com/huggingface/trl/blob/main/examples/scripts/orpo.py) - Implementación de referencia del entrenamiento ORPO utilizando la librería TRL con opciones detalladas de configuración.
- [Manual de Alineación de Hugging Face](https://github.com/huggingface/alignment-handbook) - Guías y código para alinear modelos de lenguaje utilizando diversas técnicas, incluyendo SFT, DPO y RLHF.


<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit2/0.md" />

### Entendiendo ORPO
https://huggingface.co/learn/smol-course/es/unit2/2.md

## Entendiendo ORPO

Los métodos de alineación como DPO suelen involucrar dos pasos separados: fine-tuning supervisado para adaptar el modelo a un dominio y formato, seguido de la alineación de preferencias para alinearse con las preferencias humanas. Mientras que el fine-tuning fino supervisado (SFT) adapta eficazmente los modelos a los dominios objetivo, puede aumentar inadvertidamente la probabilidad de generar tanto respuestas deseables como indeseables. ORPO aborda esta limitación integrando ambos pasos en un solo proceso, como se ilustra en la siguiente comparación:

![Comparación de Técnicas de Alineación](https://argilla.io/images/blog/mantisnlp-rlhf/part-8-alignments.png)
*Comparación de diferentes técnicas de alineación de modelos*

## Cómo Funciona ORPO

El proceso de entrenamiento de ORPO utiliza un conjunto de datos de preferencias similar al que usamos para DPO, donde cada ejemplo de entrenamiento contiene un prompt de entrada junto con dos respuestas: una preferida y otra rechazada. A diferencia de otros métodos de alineación que requieren etapas separadas y modelos de referencia, ORPO integra la alineación de preferencias directamente en el proceso de fine-tuning supervisado. Este enfoque monolítico lo hace libre de modelos de referencia, computacionalmente más eficiente y eficiente en memoria, con menos FLOPs.

ORPO crea un nuevo objetivo combinando dos componentes principales:

1. **Pérdida de SFT**: La pérdida estándar de log-verosimilitud negativa utilizada en la modelización de lenguaje, que maximiza la probabilidad de generar tokens de referencia. Esto ayuda a mantener las capacidades generales del modelo en lenguaje.

2. **Pérdida de Odds Ratio**: Un componente novedoso que penaliza respuestas no deseadas mientras recompensa las preferidas. Esta función de pérdida utiliza odds ratios para contrastar eficazmente entre respuestas favorecidas y desfavorecidas a nivel de token.

Juntos, estos componentes guían al modelo para adaptarse a las generaciones deseadas para el dominio específico mientras desalienta activamente las generaciones del conjunto de respuestas rechazadas. El mecanismo de odds ratio proporciona una manera natural de medir y optimizar las preferencias del modelo entre respuestas elegidas y rechazadas. Si deseas profundizar en las matemáticas, puedes leer el [artículo de ORPO](https://arxiv.org/abs/2403.07691). Si deseas aprender sobre ORPO desde la perspectiva de implementación, puedes revisar cómo se calcula la pérdida de ORPO en la [biblioteca TRL](https://github.com/huggingface/trl/blob/b02189aaa538f3a95f6abb0ab46c0a971bfde57e/trl/trainer/orpo_trainer.py#L660).

## Rendimiento y Resultados

ORPO ha demostrado resultados impresionantes en varios puntos de referencia. En MT-Bench, alcanza puntuaciones competitivas en diferentes categorías:

![Resultados MT-Bench](https://argilla.io/images/blog/mantisnlp-rlhf/part-8-mtbench.png)
*Resultados de MT-Bench por categoría para modelos Mistral-ORPO*

Cuando se compara con otros métodos de alineación, ORPO muestra un rendimiento superior en AlpacaEval 2.0:

![Resultados AlpacaEval](https://argilla.io/images/blog/mantisnlp-rlhf/part-8-winrate.png)
*Puntuaciones de AlpacaEval 2.0 en diferentes métodos de alineación*

En comparación con SFT+DPO, ORPO reduce los requisitos computacionales al eliminar la necesidad de un modelo de referencia y reducir a la mitad el número de pasadas hacia adelante por lote. Además, el proceso de entrenamiento es más estable en diferentes tamaños de modelos y conjuntos de datos, lo que requiere menos hiperparámetros para ajustar. En cuanto al rendimiento, ORPO iguala a modelos más grandes mientras muestra una mejor alineación con las preferencias humanas.

## Implementación

La implementación exitosa de ORPO depende en gran medida de datos de preferencias de alta calidad. Los datos de entrenamiento deben seguir pautas claras de anotación y proporcionar una representación equilibrada de respuestas preferidas y rechazadas en diversos escenarios.

### Implementación con TRL

ORPO se puede implementar utilizando la biblioteca Transformers Reinforcement Learning (TRL). Aquí tienes un ejemplo básico:

```python
from trl import ORPOConfig, ORPOTrainer

# Configurar el entrenamiento de ORPO
orpo_config = ORPOConfig(
    learning_rate=1e-5,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    max_steps=1000,
    orpo_alpha=1.0,  # Controla la fuerza de la optimización de preferencias
    orpo_beta=0.1,   # Parámetro de temperatura para el cálculo de odds ratio
)

# Inicializar el entrenador
trainer = ORPOTrainer(
    model=model,
    args=orpo_config,
    train_dataset=dataset,
    tokenizer=tokenizer,
)

# Iniciar el entrenamiento
trainer.train()
```

Parámetros clave a considerar:
- `orpo_alpha`: Controla la fuerza de la optimización de preferencias
- `orpo_beta`: Parámetro de temperatura para el cálculo de odds ratio
- `learning_rate`: Debe ser relativamente pequeño para evitar el olvido catastrófico
- `gradient_accumulation_steps`: Ayuda con la estabilidad del entrenamiento

## Próximos Pasos

⏩ Prueba el [Tutorial de ORPO](../../../notebooks/es/2_preference_alignment/orpo_tutorial.ipynb) para implementar este enfoque unificado de alineación de preferencias.

## Recursos
- [Artículo de ORPO](https://arxiv.org/abs/2403.07691)
- [Documentación de TRL](https://huggingface.co/docs/trl/index)
- [Guía de RLHF de Argilla](https://argilla.io/blog/mantisnlp-rlhf-part-8/)

<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit2/2.md" />

### Plantillas de Chat
https://huggingface.co/learn/smol-course/es/unit1/1.md

# Plantillas de Chat

<CourseFloatingBanner chapter={10}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/smol-course/blob/main/notebooks/es/1_instruction_tuning/chat_templates_example.ipynb"}
  ]} />

Las plantillas de chat son esenciales para estructurar las interacciones entre modelos de lenguaje y usuarios. Proporcionan un formato consistente para las conversaciones, asegurando que los modelos comprendan el contexto y el rol de cada mensaje, manteniendo patrones de respuesta apropiados.

## Modelos Base vs Modelos Instructivos

Un modelo base se entrena con datos de texto crudo para predecir el siguiente token, mientras que un modelo instructivo se ajusta específicamente para seguir instrucciones y participar en conversaciones. Por ejemplo, `SmolLM2-135M` es un modelo base, mientras que `SmolLM2-135M-Instruct` es su variante ajustada a instrucciones.

Para hacer que un modelo base se comporte como un modelo instructivo, necesitamos formatear nuestros prompts de manera consistente para que el modelo los entienda. Aquí es donde entran las plantillas de chat. ChatML es un formato de plantilla que estructura las conversaciones con indicadores de rol claros (sistema, usuario, asistente).

Es importante notar que un modelo base podría ser ajustado con diferentes plantillas de chat, por lo que, al usar un modelo instructivo, debemos asegurarnos de estar utilizando la plantilla de chat correcta.

## Comprendiendo las Plantillas de Chat

En su núcleo, las plantillas de chat definen cómo se deben formatear las conversaciones al comunicarse con un modelo de lenguaje. Incluyen instrucciones a nivel de sistema, mensajes del usuario y respuestas del asistente en un formato estructurado que el modelo puede entender. Esta estructura ayuda a mantener la coherencia en las interacciones y asegura que el modelo responda adecuadamente a diferentes tipos de entradas. A continuación, se muestra un ejemplo de una plantilla de chat:

```sh
<|im_start|>user
¡Hola!<|im_end|>
<|im_start|>assistant
¡Mucho gusto!<|im_end|>
<|im_start|>user
¿Puedo hacer una pregunta?<|im_end|>
<|im_start|>assistant
``` 

La librería `transformers` se encarga de las plantillas de chat por ti en relación con el tokenizador del modelo. Lee más sobre cómo `transformers` construye las plantillas de chat [aquí](https://huggingface.co/docs/transformers/en/chat_templating#how-do-i-use-chat-templates). Todo lo que tenemos que hacer es estructurar nuestros mensajes de la forma correcta y el tokenizador se encargará del resto. Aquí tienes un ejemplo básico de una conversación:

```python
messages = [
    {"role": "system", "content": "Eres un asistente útil centrado en temas técnicos."},
    {"role": "user", "content": "¿Puedes explicar qué es una plantilla de chat?"},
    {"role": "assistant", "content": "Una plantilla de chat estructura las conversaciones entre los usuarios y los modelos de IA..."}
]
```

Vamos a desglosar el ejemplo anterior y ver cómo se mapea al formato de plantilla de chat.

## Mensajes del Sistema

Los mensajes del sistema establecen la base para el comportamiento del modelo. Actúan como instrucciones persistentes que influyen en todas las interacciones posteriores. Por ejemplo:

```python
system_message = {
    "role": "system",
    "content": "Eres un agente de atención al cliente profesional. Siempre sé educado, claro y útil."
}
```

## Conversaciones

Las plantillas de chat mantienen el contexto a través del historial de la conversación, almacenando intercambios previos entre el usuario y el asistente. Esto permite conversaciones más coherentes en múltiples turnos:

```python
conversation = [
    {"role": "user", "content": "Necesito ayuda con mi pedido"},
    {"role": "assistant", "content": "Estaré encantado de ayudarte. ¿Podrías proporcionarme tu número de pedido?"},
    {"role": "user", "content": "Es el PEDIDO-123"},
]
```

## Implementación con Transformers

La librería `transformers` proporciona soporte integrado para plantillas de chat. Aquí te mostramos cómo usarlas:

```python
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("HuggingFaceTB/SmolLM2-135M-Instruct")

messages = [
    {"role": "system", "content": "Eres un asistente útil para programación."},
    {"role": "user", "content": "Escribe una función en Python para ordenar una lista"},
]

# Aplica la plantilla de chat
formatted_chat = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
```

## Formato Personalizado

Puedes personalizar cómo se formatean los diferentes tipos de mensajes. Por ejemplo, añadiendo tokens especiales o formato para diferentes roles:

```python
template = """
<|system|>{system_message}
<|user|>{user_message}
<|assistant|>{assistant_message}
""".lstrip()
```

## Soporte para Conversaciones de Varios Turnos

Las plantillas pueden manejar conversaciones complejas de varios turnos mientras mantienen el contexto:

```python
messages = [
    {"role": "system", "content": "Eres un tutor de matemáticas."},
    {"role": "user", "content": "¿Qué es el cálculo?"},
    {"role": "assistant", "content": "El cálculo es una rama de las matemáticas..."},
    {"role": "user", "content": "¿Puedes darme un ejemplo?"},
]
```

⏭️ [Siguiente: Fine-tuning Supervisado](./supervised_fine_tuning.md)

## Recursos

- [Guía de Plantillas de Chat de Hugging Face](https://huggingface.co/docs/transformers/main/en/chat_templating)
- [Documentación de Transformers](https://huggingface.co/docs/transformers)
- [Repositorio de Ejemplos de Plantillas de Chat](https://github.com/chujiezheng/chat_templates)


<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit1/1.md" />

### Ajuste por Instrucciones (Instruction Tuning)
https://huggingface.co/learn/smol-course/es/unit1/0.md

# Ajuste por Instrucciones (Instruction Tuning)

Este módulo te guiará en el proceso de ajuste por instrucciones de modelos de lenguaje. El ajuste por instrucciones implica adaptar modelos preentrenados a tareas específicas mediante un entrenamiento adicional sobre conjuntos de datos específicos para esas tareas. Este proceso ayuda a los modelos a mejorar su rendimiento en tareas específicas.

En este módulo, exploraremos dos temas: 1) Plantillas de Chat y 2) Fine-tuning Supervisado

## 1️⃣ Plantillas de Chat

Las plantillas de chat estructuran las interacciones entre los usuarios y los modelos de IA, asegurando respuestas coherentes y contextualmente apropiadas. Estas plantillas incluyen componentes como los mensajes de sistema y mensajes basados en roles. Para más información detallada, consulta la sección de [Plantillas de Chat](./chat_templates.md).

## 2️⃣ Fine-tuning Supervisado

El Fine-tuning supervisado (SFT) es un proceso crítico para adaptar modelos de lenguaje preentrenados a tareas específicas. Implica entrenar el modelo en un conjunto de datos específico para la tarea con ejemplos etiquetados. Para una guía detallada sobre el SFT, incluyendo pasos clave y mejores prácticas, consulta la página de [Fine-tuning Supervisado](./supervised_fine_tuning.md).

## Referencias

- [Documentación de Transformers sobre plantillas de chat](https://huggingface.co/docs/transformers/main/en/chat_templating)
- [Script para Fine-Tuning Supervisado en TRL](https://github.com/huggingface/trl/blob/main/examples/scripts/sft.py)
- [`SFTTrainer` en TRL](https://huggingface.co/docs/trl/main/en/sft_trainer)
- [Papel de Optimización Directa de Preferencias](https://arxiv.org/abs/2305.18290)
- [Fine-Tuning Supervisado con TRL](https://huggingface.co/docs/trl/main/en/tutorials/supervised_finetuning)
- [Cómo afinar Google Gemma con ChatML y Hugging Face TRL](https://www.philschmid.de/fine-tune-google-gemma)
- [Fine-Tuning de LLM para generar catálogos de productos persas en formato JSON](https://huggingface.co/learn/cookbook/en/fine_tuning_llm_to_generate_persian_product_catalogs_in_json_format)


<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit1/0.md" />

### Fine-Tuning Supervisado
https://huggingface.co/learn/smol-course/es/unit1/2.md

# Fine-Tuning Supervisado

<CourseFloatingBanner chapter={10}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/smol-course/blob/main/notebooks/es/1_instruction_tuning/sft_finetuning_example.ipynb"},
]} />
    
El Fine-Tuning Supervisado (SFT) es un proceso crítico para adaptar modelos de lenguaje preentrenados a tareas o dominios específicos. Aunque los modelos preentrenados tienen capacidades generales impresionantes, a menudo necesitan ser personalizados para sobresalir en casos de uso particulares. El SFT cubre esta brecha entrenando el modelo con conjuntos de datos cuidadosamente seleccionados que contienen ejemplos validados por humanos.

## Comprendiendo el Fine-Tuning Supervisado

En su núcleo, el Fine-Tuning supervisado se trata de enseñar a un modelo preentrenado a realizar tareas específicas mediante ejemplos de tokens etiquetados. El proceso consiste en mostrarle al modelo muchos ejemplos del comportamiento deseado de entrada-salida, permitiéndole aprender los patrones específicos de tu caso de uso.

El SFT es eficaz porque utiliza el conocimiento fundamental adquirido durante el preentrenamiento, mientras adapta el comportamiento del modelo para que se ajuste a tus necesidades específicas.

## Cuándo Utilizar Fine-Tuning Supervisado

La decisión de usar SFT generalmente depende de la brecha entre las capacidades actuales de tu modelo y tus requisitos específicos. El SFT se vuelve particularmente valioso cuando necesitas un control preciso sobre las salidas del modelo o cuando trabajas en dominios especializados.

Por ejemplo, si estás desarrollando una aplicación de atención al cliente, es posible que desees que tu modelo siga consistentemente las pautas de la empresa y maneje consultas técnicas de una manera estandarizada. De manera similar, en aplicaciones médicas o legales, la precisión y la adherencia a la terminología específica del dominio se vuelven cruciales. En estos casos, el SFT puede ayudar a alinear las respuestas del modelo con los estándares profesionales y la experiencia del dominio.

## El Proceso de Fine-Tuning Supervisado (SFT)

El proceso de Fine-Tuning Supervisado consiste en entrenar los pesos del modelo en un conjunto de datos específico para una tarea.

Primero, necesitarás preparar o seleccionar un conjunto de datos que represente tu tarea objetivo. Este conjunto de datos debe incluir ejemplos diversos que cubran una amplia gama de escenarios que tu modelo encontrará. La calidad de estos datos es importante: cada ejemplo debe demostrar el tipo de salida que deseas que el modelo produzca. Luego, viene la fase de fine-tuning, donde usarás marcos como `transformers` y `trl` de Hugging Face para entrenar el modelo con tu conjunto de datos.

Durante todo el proceso, la evaluación continua es esencial. Querrás monitorear el rendimiento del modelo en un conjunto de validación para asegurarte de que está aprendiendo los comportamientos deseados sin perder sus capacidades generales. En el [módulo 4](../4_evaluation), cubriremos cómo evaluar tu modelo.

## El Rol del SFT en la Alineación con las Preferencias

El SFT juega un papel fundamental en la alineación de los modelos de lenguaje con las preferencias humanas. Técnicas como el Aprendizaje por Refuerzo a partir de Retroalimentación Humana (RLHF) y la Optimización Directa de Preferencias (DPO) dependen del SFT para formar un nivel base de comprensión de la tarea antes de alinear aún más las respuestas del modelo con los resultados deseados. Los modelos preentrenados, a pesar de su competencia general en el lenguaje, no siempre generan salidas que coinciden con las preferencias humanas. El SFT cubre esta brecha al introducir datos específicos de dominio y orientación, lo que mejora la capacidad del modelo para generar respuestas que se alineen más estrechamente con las expectativas humanas.

## Fine-Tuning Supervisado con Aprendizaje por Refuerzo de Transformers (TRL)

Un paquete de software clave para el fine-tuning supervisado es el Aprendizaje por Refuerzo de Transformers (TRL). TRL es un conjunto de herramientas utilizado para entrenar modelos de lenguaje transformadores utilizando aprendizaje por refuerzo (RL).

Basado en la librería Transformers de Hugging Face, TRL permite a los usuarios cargar directamente modelos de lenguaje preentrenados y es compatible con la mayoría de las arquitecturas de decodificadores y codificadores-decodificadores. La librería facilita los principales procesos del RL utilizado en la modelización del lenguaje, incluyendo el fine-tuning supervisado (SFT), la modelización de recompensas (RM), la optimización de políticas proximales (PPO) y la optimización directa de preferencias (DPO). Usaremos TRL en varios módulos a lo largo de este repositorio.

# Próximos Pasos

Prueba los siguientes tutoriales para obtener experiencia práctica con el SFT utilizando TRL:

⏭️ [Tutorial de Plantillas de Chat](../../../notebooks/es/1_instruction_tuning/../notebooks/es/1_instruction_tuning/supervised_fine_tuning_tutorial.ipynb)


<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit1/2.md" />

### LoRA (Adaptación de Bajo Rango)
https://huggingface.co/learn/smol-course/es/unit3/1.md

# LoRA (Adaptación de Bajo Rango) 

<CourseFloatingBanner chapter={10}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/smol-course/blob/main/notebooks/es/3_parameter_efficient_finetuning/finetune_sft_peft.ipynb"},
]} />

LoRA (Low-Rank Adaptation) se ha convertido en el método PEFT más utilizado. Su funcionamiento se basa en añadir matrices de descomposición de rango reducido a los pesos de atención, lo que suele reducir los parámetros entrenables en un 90%.

## Entendiendo LoRA

LoRA es una técnica de fine-tuning eficiente en parámetros que congela los pesos del modelo preentrenado e inyecta matrices entrenables de descomposición de rango reducido en las capas del modelo. En lugar de entrenar todos los parámetros del modelo durante el fine-tuning, LoRA descompone las actualizaciones de los pesos en matrices más pequeñas mediante descomposición de rango, reduciendo significativamente la cantidad de parámetros entrenables mientras mantiene el rendimiento del modelo. Por ejemplo, se ha aplicado a GPT-3 175B. LoRA redujo los parámetros entrenables 10 000 veces y los requerimientos de memoria de GPU 3 veces en comparación con el fine-tuning completo. Puedes leer más sobre LoRA en el [paper de LoRA](https://arxiv.org/pdf/2106.09685).

LoRA funciona añadiendo pares de matrices de descomposición de rango reducido a las capas del transformador, normalmente enfocándose en los pesos de atención. Durante la inferencia, estos pesos adaptadores pueden fusionarse con el modelo base, lo que elimina la sobrecarga de latencia adicional. LoRA es especialmente útil para adaptar modelos de lenguaje grandes a tareas o dominios específicos mientras se mantienen requisitos de recursos manejables.

## Cargando adaptadores LoRA

Se pueden cargar adaptadores en un modelo preentrenado utilizando `load_adapter()`, lo cual es útil para probar diferentes adaptadores cuyos pesos no están fusionados. Se pueden establecer los pesos de los adaptadores activos con la función `set_adapter()`. Para devolver el modelo base, se puede usar `unload()` para descargar todos los módulos de LoRA. Esto permite cambiar fácilmente entre diferentes pesos específicos de tareas.

```python
from transformers import AutoModelForCausalLM
from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained("<base_model_name>")
peft_model_id = "<peft_adapter_id>"
model = PeftModel.from_pretrained(base_model, peft_model_id)
```

![lora_load_adapter](./images/lora_adapter.png)

## Fusionando adaptadores LoRA

Después de entrenar con LoRA, podrías querer fusionar los pesos del adaptador de vuelta en el modelo base para facilitar su implementación. Esto crea un único modelo con los pesos combinados, eliminando la necesidad de cargar adaptadores por separado durante la inferencia.

El proceso de fusión requiere atención al manejo de memoria y precisión. Como necesitarás cargar tanto el modelo base como los pesos del adaptador simultáneamente, asegúrate de tener suficiente memoria GPU/CPU disponible. Usar `device_map="auto"` en `transformers` ayudará con el manejo automático de memoria. Mantén una precisión consistente (por ejemplo, `float16`) durante todo el proceso, y guarda el modelo fusionado en el mismo formato para su implementación. Antes de implementar, siempre valida el modelo fusionado comparando sus salidas y métricas de rendimiento con la versión basada en adaptadores.

Los adaptadores también son convenientes para cambiar entre diferentes tareas o dominios. Puedes cargar el modelo base y los pesos del adaptador por separado, permitiendo un cambio rápido entre diferentes pesos específicos de tareas.

## Guía de implementación

El directorio `notebooks/` contiene tutoriales prácticos y ejercicios para implementar diferentes métodos PEFT. Comienza con `load_lora_adapter_example.ipynb` para una introducción básica, y luego explora `lora_finetuning.ipynb` para un análisis más detallado de cómo realizar fine-tuning en un modelo con LoRA y SFT.

Cuando implementes métodos PEFT, comienza con valores de rango pequeños (4-8) para LoRA y monitoriza la pérdida durante el entrenamiento. Utiliza conjuntos de validación para evitar el sobreajuste y compara los resultados con los baselines del fine-tuning completo cuando sea posible. La efectividad de los diferentes métodos puede variar según la tarea, por lo que la experimentación es clave.

## OLoRA

[OLoRA](https://arxiv.org/abs/2406.01775) utiliza descomposición QR para inicializar los adaptadores LoRA. OLoRA traduce los pesos base del modelo por un factor de sus descomposiciones QR, es decir, muta los pesos antes de realizar cualquier entrenamiento sobre ellos. Este enfoque mejora significativamente la estabilidad, acelera la velocidad de convergencia y logra un rendimiento superior.

## Usando TRL con PEFT

Los métodos PEFT pueden combinarse con TRL (Transformers Reinforcement Learning) para un fine-tuning eficiente. Esta integración es particularmente útil para RLHF (Reinforcement Learning from Human Feedback), ya que reduce los requisitos de memoria.

```python
from peft import LoraConfig
from transformers import AutoModelForCausalLM

# Carga el modelo con configuración PEFT
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# Carga el modelo en un dispositivo específico
model = AutoModelForCausalLM.from_pretrained(
    "your-model-name",
    load_in_8bit=True,  # Opcional: usa la precisión de 8 bits
    device_map="auto",
    peft_config=lora_config
)
```

Aquí, usamos `device_map="auto"` para asignar automáticamente el modelo al dispositivo correcto. También puedes asignar manualmente el modelo a un dispositivo específico usando `device_map={"": device_index}`. Además, podrías escalar el entrenamiento en múltiples GPUs mientras mantienes un uso eficiente de memoria.

## Implementación básica de fusión

Después de entrenar un adaptador LoRA, puedes fusionar los pesos del adaptador de vuelta en el modelo base. Aquí tienes cómo hacerlo:

```python
import torch
from transformers import AutoModelForCausalLM
from peft import PeftModel

# 1. Carga el modelo base
base_model = AutoModelForCausalLM.from_pretrained(
    "base_model_name",
    dtype=torch.float16,
    device_map="auto"
)

# 2. Carga el modelo PEFT con adaptador
peft_model = PeftModel.from_pretrained(
    base_model,
    "path/to/adapter",
    dtype=torch.float16
)

# 3. Fusiona los pesos del adaptador con el modelo base
try:
    merged_model = peft_model.merge_and_unload()
except RuntimeError as e:
    print(f"Fusión fallida: {e}")
    # Implementa estrategia de respaldo u optimización de memoria

# 4. Guarda el modelo fusionado
merged_model.save_pretrained("path/to/save/merged_model")
```

Si encuentras discrepancias de tamaño en el modelo guardado, asegúrate de guardar también el tokenizer:

```python
# Guarda tanto el modelo como el tokenizer
tokenizer = AutoTokenizer.from_pretrained("base_model_name")
merged_model.save_pretrained("path/to/save/merged_model")
tokenizer.save_pretrained("path/to/save/merged_model")
```

## Próximos pasos

⏩ Pasa al [Prompt Tuning](prompt_tuning.md) para aprender a realizar fine-tuning en un modelo con prompt tuning.  
⏩ Revisa el [Tutorial de Carga de Adaptadores LoRA](../../../notebooks/es/3_parameter_efficient_finetuning/load_lora_adapter.ipynb) para aprender a cargar adaptadores LoRA.

# Recursos

- [LORA: ADAPTACIÓN DE BAJO RANGO PARA MODELOS DE LENGUAJE DE GRAN TAMAÑO](https://arxiv.org/pdf/2106.09685)  
- [Documentación de PEFT](https://huggingface.co/docs/peft)  
- [Publicación en el blog de Hugging Face sobre PEFT](https://huggingface.co/blog/peft)  

<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit3/1.md" />

### Fine-Tuning Eficiente en Parámetros (PEFT)
https://huggingface.co/learn/smol-course/es/unit3/0.md

# Fine-Tuning Eficiente en Parámetros (PEFT)

A medida que los modelos de lenguaje se hacen más grandes, el *fine-tuning* tradicional se vuelve cada vez más complicado. Afinar completamente un modelo con 1.7 mil millones de parámetros, por ejemplo, requiere una memoria de GPU significativa, hace costoso almacenar copias separadas del modelo y puede ocasionar un olvido catastrófico de las capacidades originales del modelo. Los métodos de *fine-tuning* eficiente en parámetros (*Parameter-Efficient Fine-Tuning* o PEFT) abordan estos problemas modificando solo un subconjunto pequeño de los parámetros del modelo, mientras que la mayor parte del modelo permanece congelada.

El *fine-tuning* tradicional actualiza todos los parámetros del modelo durante el entrenamiento, lo cual resulta poco práctico para modelos grandes. Los métodos PEFT introducen enfoques para adaptar modelos utilizando una fracción mínima de parámetros entrenables, generalmente menos del 1% del tamaño original del modelo. Esta reducción dramática permite:

- Realizar *fine-tuning* en hardware de consumo con memoria de GPU limitada.
- Almacenar eficientemente múltiples adaptaciones de tareas específicas.
- Mejorar la generalización en escenarios con pocos datos.
- Entrenamientos y ciclos de iteración más rápidos.

## Métodos Disponibles

En este módulo, se cubrirán dos métodos populares de PEFT:

### 1️⃣ LoRA (Adaptación de Bajo Rango)

LoRA se ha convertido en el método PEFT más adoptado, ofreciendo una solución sofisticada para la adaptación eficiente de modelos. En lugar de modificar el modelo completo, **LoRA inyecta matrices entrenables en las capas de atención del modelo.** Este enfoque, por lo general, reduce los parámetros entrenables en aproximadamente un 90%, manteniendo un rendimiento comparable al *fine-tuning* completo. Exploraremos LoRA en la sección [LoRA (Adaptación de Bajo Rango)](./lora_adapters.md).

### 2️⃣ *Prompt Tuning*

El *prompt tuning* ofrece un enfoque **aún más ligero** al **añadir tokens entrenables a la entrada** en lugar de modificar los pesos del modelo. Aunque es menos popular que LoRA, puede ser útil para adaptar rápidamente un modelo a nuevas tareas o dominios. Exploraremos el *prompt tuning* en la sección [Prompt Tuning](./prompt_tuning.md).

<!-- | Prompt Tuning | Aprende a implementar *prompt tuning* | 🐢 Entrenar *soft prompts*<br>🐕 Comparar diferentes estrategias de inicialización<br>🦁 Evaluar en múltiples tareas | [Notebook](../../../notebooks/es/3_parameter_efficient_finetuning/prompt_tuning_example.ipynb) | <a target="_blank" href="https://colab.research.google.com/github/huggingface/smol-course/blob/main/notebooks/es/3_parameter_efficient_finetuning/prompt_tuning_example.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Abrir en Colab"/></a> | -->

## Recursos
- [Documentación de PEFT](https://huggingface.co/docs/peft)
- [Artículo de LoRA](https://arxiv.org/abs/2106.09685)
- [Artículo de QLoRA](https://arxiv.org/abs/2305.14314)
- [Artículo de *Prompt Tuning*](https://arxiv.org/abs/2104.08691)
- [Guía de PEFT en Hugging Face](https://huggingface.co/blog/peft)
- [Cómo hacer *Fine-Tuning* de LLMs en 2024 con Hugging Face](https://www.philschmid.de/fine-tune-llms-in-2024-with-trl)
- [TRL](https://huggingface.co/docs/trl/index)

<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit3/0.md" />

### Ajuste de Prompts
https://huggingface.co/learn/smol-course/es/unit3/2.md

# Ajuste de Prompts

<CourseFloatingBanner chapter={10}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/smol-course/blob/main/notebooks/es/3_parameter_efficient_finetuning/finetune_sft_peft.ipynb"},
]} />
    
El ajuste de prompts es un enfoque eficiente en términos de parámetros que modifica las representaciones de entrada en lugar de los pesos del modelo. A diferencia del fine-tuning tradicional que actualiza todos los parámetros del modelo, el ajuste de prompts agrega y optimiza un pequeño conjunto de tokens entrenables mientras mantiene el modelo base congelado.

## Entendiendo el Ajuste de Prompts

El ajuste de prompts es una alternativa eficiente en términos de parámetros al fine-tuning del modelo que antepone vectores continuos entrenables (prompts suaves) al texto de entrada. A diferencia de los prompts discretos de texto, estos prompts suaves se aprenden mediante retropropagación mientras el modelo de lenguaje se mantiene congelado. El método fue introducido en ["El poder de la escala para el ajuste de prompts eficiente en parámetros"](https://arxiv.org/abs/2104.08691) (Lester et al., 2021), que demostró que el ajuste de prompts se vuelve más competitivo con el fine-tuning del modelo a medida que aumenta el tamaño del modelo. En el artículo, alrededor de 10 mil millones de parámetros, el ajuste de prompts iguala el rendimiento del fine-tuning del modelo mientras solo modifica unos pocos cientos de parámetros por tarea.

Estos prompts suaves son vectores continuos en el espacio de incrustación del modelo que se optimizan durante el entrenamiento. A diferencia de los prompts discretos tradicionales que usan tokens de lenguaje natural, los prompts suaves no tienen un significado inherente, pero aprenden a provocar el comportamiento deseado del modelo congelado mediante el descenso de gradiente. La técnica es particularmente efectiva para escenarios de múltiples tareas, ya que cada tarea requiere almacenar solo un pequeño vector de prompt (normalmente unos pocos cientos de parámetros) en lugar de una copia completa del modelo. Este enfoque no solo mantiene una huella de memoria mínima, sino que también permite una adaptación rápida de tareas simplemente intercambiando los vectores de prompt sin necesidad de recargar el modelo.

## Proceso de Entrenamiento

Los prompts suaves suelen ser entre 8 y 32 tokens y se pueden inicializar de forma aleatoria o a partir de texto existente. El método de inicialización juega un papel crucial en el proceso de entrenamiento, con la inicialización basada en texto a menudo obteniendo mejores resultados que la aleatoria.

Durante el entrenamiento, solo se actualizan los parámetros del prompt mientras que el modelo base permanece congelado. Este enfoque centrado utiliza objetivos de entrenamiento estándar, pero requiere una atención cuidadosa a la tasa de aprendizaje y el comportamiento de los gradientes de los tokens del prompt.

## Implementación con PEFT

La libreria PEFT facilita la implementación del ajuste de prompts. Aquí tienes un ejemplo básico:

```python
from peft import PromptTuningConfig, TaskType, get_peft_model
from transformers import AutoModelForCausalLM, AutoTokenizer

# Carga el modelo base
model = AutoModelForCausalLM.from_pretrained("your-base-model")
tokenizer = AutoTokenizer.from_pretrained("your-base-model")

# Configura el ajuste de prompt
peft_config = PromptTuningConfig(
    task_type=TaskType.CAUSAL_LM,
    num_virtual_tokens=8,  # Número de tokens entrenables
    prompt_tuning_init="TEXT",  # Inicializa a partir de texto
    prompt_tuning_init_text="Clasifique si este texto es positivo o negativo:",
    tokenizer_name_or_path="your-base-model",
)

# Crea el modelo ajustable por prompt
model = get_peft_model(model, peft_config)
```

## Comparación con Otros Métodos

Cuando se compara con otros enfoques de PEFT, el ajuste de prompts destaca por su eficiencia. Mientras que LoRA ofrece bajos recuentos de parámetros y uso de memoria pero requiere cargar adaptadores para el cambio de tareas, el ajuste de prompts logra un uso de recursos aún menor y permite un cambio de tareas inmediato. El fine-tuning completo, en contraste, exige recursos significativos y requiere copias separadas del modelo para diferentes tareas.

| Método            | Parámetros  | Memoria  | Cambio de Tarea |
|-------------------|-------------|----------|-----------------|
| Ajuste de Prompts | Muy Bajo    | Mínimo   | Fácil           |
| LoRA              | Bajo        | Bajo     | Requiere Carga  |
| Fine-tuning Completo   | Alto        | Alto     | Nueva Copia     |

Al implementar el ajuste de prompts, comienza con un pequeño número de tokens virtuales (8-16) y aumenta solo si la complejidad de la tarea lo requiere. La inicialización con texto generalmente da mejores resultados que la aleatoria, especialmente cuando se utiliza texto relevante para la tarea. La estrategia de inicialización debe reflejar la complejidad de la tarea objetivo.

El entrenamiento requiere consideraciones ligeramente diferentes al fine-tuning completo. Las tasas de aprendizaje más altas suelen funcionar bien, pero es esencial monitorear cuidadosamente los gradientes de los tokens de prompt. La validación regular con ejemplos diversos ayuda a garantizar un rendimiento robusto en diferentes escenarios.

## Aplicaciones

El ajuste de prompts sobresale en varios escenarios:

1. Despliegue de múltiples tareas
2. Entornos con limitaciones de recursos
3. Adaptación rápida de tareas
4. Aplicaciones sensibles a la privacidad

A medida que los modelos se hacen más pequeños, el ajuste de prompts se vuelve menos competitivo en comparación con el fine-tuning completo. Por ejemplo, en modelos como SmolLM2, el ajuste de prompts es menos relevante que el fine-tuning completo.

## Próximos Pasos

⏭️ Pasa al [Tutorial de Adaptadores LoRA](../../../notebooks/es/3_parameter_efficient_finetuning/finetune_sft_peft.ipynb) para aprender cómo ajustar un modelo con adaptadores LoRA.

## Recursos
- [Documentación de PEFT](https://huggingface.co/docs/peft)
- [Papel sobre Ajuste de Prompts](https://arxiv.org/abs/2104.08691)
- [Recetario de Hugging Face](https://huggingface.co/learn/cookbook/prompt_tuning_peft)

<EditOnGithub source="https://github.com/huggingface/smol-course/blob/main/units/es/unit3/2.md" />
