Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Aplica un tamizado SageMaker inteligente a tu guion de Hugging Face Transformers
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script"></a>

Hay dos formas de implementar la selección SageMaker inteligente en la clase Transformers. `Trainer`

**nota**  
Si usa uno de los formularios PyTorch con el DLCs paquete de SageMaker filtrado inteligente instalado, tenga en cuenta que debe instalar la biblioteca. `transformers` Puedes instalar paquetes adicionales [ampliando DLCs o pasando `requirements.txt` a la](prebuilt-containers-extend.md) clase de lanzador de tareas de formación para PyTorch ([https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)) en el SDK de Python para SageMaker IA.

## Configuración sencilla
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script-simple"></a>

La forma más sencilla de implementar el SageMaker filtrado inteligente en la `Trainer` clase Transformers es usar la función. `enable_sifting` Esta función acepta un objeto `Trainer` existente y encapsula el objeto`DataLoader` existente con `SiftingDataloader`. Puede seguir utilizando el mismo objeto de entrenamiento. Consulte el siguiente uso de ejemplo.

```
from smart_sifting.integrations.trainer import enable_sifting
from smart_sifting.loss.abstract_sift_loss_module import Loss
from smart_sifting.sift_config.sift_configs import (
    RelativeProbabilisticSiftConfig
    LossConfig
    SiftingBaseConfig
)

class {{SiftingImplementedLoss}}(Loss):
   def loss(self, model, transformed_batch, original_batch):
        loss_fct = MSELoss(reduction="none") # make sure to set reduction to "none"
        logits = model.bert(**original_batch)
        return loss_fct(logits, original_batch.get("labels"))

sift_config = RelativeProbabilisticSiftConfig(
    beta_value={{0.5}},
    loss_history_length={{500}},
    loss_based_sift_config=LossConfig(
         sift_config=SiftingBaseConfig(sift_delay=0)
    )
)

trainer = Trainer(...)
enable_sifting(trainer, {{sift_config}}, loss={{SiftingImplementedLoss}}()) # updates the trainer with Sifting Loss and config
trainer.train()
```

La clase `SiftingDataloader` es un cargador de datos iterable. El tamaño exacto del conjunto de datos resultante no se conoce de antemano debido al muestreo aleatorio que se realiza durante la selección. Como resultado, `Trainer` de Hugging Face espera el [argumento de entrenamiento de `max_steps`](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.max_steps). Tenga en cuenta que este argumento anula el parámetro de configuración epoch `num_train_epochs`. Si el cargador de datos original también era iterable, o si su entrenamiento utiliza `max_steps` y un solo epoch, `SiftingDataloader` funciona igual que el cargador de datos existente. Si el cargador de datos original no era iterable o no se proporcionó `max_steps`, el entrenador de Hugging Face podría generar un mensaje de error similar al siguiente. 

```
args.max_steps must be set to a positive value if dataloader does not have a length,
was -1
```

Para solucionar este problema, la función `enable_sifting` proporciona un parámetro `set_epochs` opcional. Esto permite el entrenamiento con epochs, utilizando el número de épocas proporcionado por el [argumento num\_train\_epochs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.num_train_epochs(float,) de la clase `Trainer`, y establece `max_steps` en el número entero máximo del sistema, lo que permite que el entrenamiento avance hasta completar los epochs especificados.

## Configuración personalizada
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script-custom-trainer"></a>

Para una integración personalizada del cargador de datos de tamizado SageMaker inteligente, puedes utilizar una clase personalizada de Hugging Face. `Trainer` Dentro de cualquier subclase de `Trainer`, la función `get_train_dataloader()` se puede anular para devolver un objeto de la clase `SiftingDataloader` en su lugar. En el caso de los entrenadores personalizados existentes, este enfoque puede ser menos intrusivo, pero requiere cambios de código, en comparación con la opción de configuración sencilla. El siguiente es un ejemplo de implementación de la SageMaker selección inteligente en una clase personalizada de Hugging Face. `Trainer`

```
from smart_sifting.sift_config.sift_configs import (
    RelativeProbabilisticSiftConfig
    LossConfig
    SiftingBaseConfig
)
from smart_sifting.dataloader.sift_dataloader import SiftingDataloader
from smart_sifting.loss.abstract_sift_loss_module import Loss
from smart_sifting.data_model.data_model_interface import SiftingBatch, SiftingBatchTransform
from smart_sifting.data_model.list_batch import ListBatch

class {{SiftingListBatchTransform}}(SiftingBatchTransform):
    def transform(self, batch: Any):
        inputs = batch[0].tolist()
        labels = batch[-1].tolist()  # assume the last one is the list of labels
        return ListBatch(inputs, labels)

    def reverse_transform(self, list_batch: ListBatch):
        a_batch = [torch.tensor(list_batch.inputs), torch.tensor(list_batch.labels)]
        return a_batch

class {{SiftingImplementedLoss}}():
    # You should add the following initializaztion function 
    # to calculate loss per sample, not per batch.
    def __init__(self):
        self.celoss = torch.nn.{{CrossEntropyLoss}}(reduction='none')

    def loss(
        self,
        model: torch.nn.Module,
        transformed_batch: SiftingBatch,
        original_batch: Any = None,
    ) -> torch.Tensor:
        device = next(model.parameters()).device
        batch = [t.to(device) for t in original_batch]

        # compute loss
        outputs = model(batch)
        return self.celoss(outputs.logits, batch[2])

class {{SiftingImplementedTrainer}}(Trainer):
    def get_train_dataloader(self):
        {{dl}} = super().get_train_dataloader()

        sift_config = RelativeProbabilisticSiftConfig(
            beta_value={{0.5}},
            loss_history_length={{500}},
            loss_based_sift_config=LossConfig(
                sift_config=SiftingBaseConfig(sift_delay=0)
            )
        )

        return SiftingDataloader(
                sift_config=sift_config,
                orig_dataloader={{dl}},
                batch_transforms={{SiftingListBatchTransform}}(),
                loss_impl={{SiftingImplementedLoss}}(),
                model=self.model
        )
```

Con la clase `Trainer` encapsulada, cree un objeto de la misma de la siguiente manera.

```
trainer = SiftingImplementedTrainer(
    model={{model}},
    args={{training_args}},
    train_dataset={{small_train_dataset}},
    eval_dataset={{small_eval_dataset}}
)

trainer.train()
```