# Subclasear los métodos de Trainer

Subclase los métodos de [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) para cambiar el comportamiento del entrenamiento sin reescribir todo el bucle. Subclasear modifica el *bucle de entrenamiento*, por ejemplo, la pasada hacia adelante o el cálculo de la pérdida.

Antes de crear una subclase, considere si necesita cambiar *qué* calcula [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) o *cuándo* y *si* actúa. Para la lógica de temporización y condicional, use un [Callback](./trainer_callbacks) en su lugar. Los Callbacks controlan cuándo ocurren las cosas (registro, evaluación, detención temprana) y la creación de subclases cambia qué ocurre (cálculo de la pérdida, carga de datos, optimización).

> [!NOTE]
> Consulte la documentación de la API de [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) para obtener una lista completa de los métodos que puede subclasear. Los métodos privados (con el prefijo `_`), como `_save_checkpoint` o `_evaluate`, también se pueden sobrescribir, pero es posible que cambien sin previo aviso.

## get_train_dataloader

El método estándar [get_train_dataloader()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.get_train_dataloader) carga un lote, entrena con él, lo descarta y carga el siguiente lote.

```py
def get_train_dataloader(self):
    return self._get_dataloader(
        batch_size=self._train_batch_size,
        ...
)
```

[GRPO](https://huggingface.co/docs/trl/en/grpo_trainer) es un algoritmo de aprendizaje por refuerzo en línea que genera completados antes de entrenar con ellos. Generar completados en cada paso es costoso porque es autoregresivo. Un completado de 512 tokens requiere ~512 pases hacia adelante secuenciales, en comparación con un solo pase hacia adelante para un paso de entrenamiento. [GRPOTrainer](https://huggingface.co/docs/trl/v1.17.1/en/grpo_trainer#trl.GRPOTrainer) subclasea [get_train_dataloader()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.get_train_dataloader) para agrupar la generación en varios pasos.

`trl.GRPOTrainer.get_train_dataloader` carga *batches* de prompts de generación para varios pasos de entrenamiento a la vez, multiplicando el tamaño del batch por el argumento `steps_per_generation`. Si `train_batch_size=4` y `steps_per_generation=8`, el dataloader produce batches de 32, reduciendo el costo de generación en un factor de 8.

```py
def get_train_dataloader(self):
    dataloader_params = {
        "batch_size": self._train_batch_size * self.args.steps_per_generation, # this is the only change
        ...
    }
```

## Calcular la pérdida

[compute_loss()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.compute_loss) devuelve la pérdida de entropía cruzada calculada por el modelo.

```py
def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
    ...
    outputs = model(**inputs)
    ...
    loss = outputs["loss"] # get loss from model

    return (loss, outputs) if return_outputs else loss
```

[DPO](https://huggingface.co/docs/trl/en/dpo_trainer) mide en qué medida el modelo de política prefiere una respuesta elegida frente a una rechazada, en relación con un modelo de referencia. [DPOTrainer](https://huggingface.co/docs/trl/v1.17.1/en/dpo_trainer#trl.DPOTrainer) subclasea [compute_loss()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.compute_loss) porque el cálculo de la pérdida difiere de la entropía cruzada estándar en varios aspectos:

- el modelo nunca ve las etiquetas; solo devuelve logits para que DPO calcule las log-probabilidades a partir de ellos
- las respuestas elegidas y rechazadas se concatenan
- un modelo de referencia calcula sus propias log-probs
- la pérdida es una función de `π_chosen`, `π_rejected`, `π_ref_chosen`, `π_ref_rejected`

Ninguna de las anteriores se ajusta al método estándar [Trainer.compute_loss()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.compute_loss).

```py
def compute_loss(
    self,
    model: PreTrainedModel | nn.Module,
    inputs: dict[str, torch.Tensor | Any],
    return_outputs=False,
    num_items_in_batch=None,
) -> torch.Tensor | tuple[torch.Tensor, dict[str, float]]:
    ...
    outputs = model(**inputs)
    logits = outputs.logits
    logps = get_logps(logits, inputs)
    chosen_logps, rejected_logps = logps.chunk(2, dim=0)  # batch is [chosen, rejected]
    ref_logits = self.ref_model(**inputs).logits
    ref_logps = get_logps(ref_logits, inputs)
    ref_chosen_logps, ref_rejected_logps = ref_logps.chunk(2, dim=0)  # batch is [chosen, rejected]
    chosen_scores = chosen_logps - ref_chosen_logps
    rejected_scores = rejected_logps - ref_rejected_logps
    per_sequence_loss = -F.logsigmoid(self.beta * chosen_scores - rejected_scores)
    loss = per_sequence_loss.mean()
    return (loss, outputs) if return_outputs else loss
```

## Próximos pasos

- Para más ejemplos del mundo real, consulte cómo [GRPOTrainer](https://huggingface.co/docs/trl/v1.17.1/en/grpo_trainer#trl.GRPOTrainer) y [DPOTrainer](https://huggingface.co/docs/trl/v1.17.1/en/dpo_trainer#trl.DPOTrainer) extienden [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) en TRL, o cómo [Axolotl](https://github.com/axolotl-ai-cloud/axolotl/tree/main/src/axolotl/core/trainers) crea entrenadores personalizados sobre él.
- Consulte la guía de [Callbacks](./trainer_callbacks) si solo necesita personalizar lo que ocurre durante un evento de entrenamiento, como registrar métricas al final de un paso de entrenamiento.

