Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Appliquez un SageMaker filtrage intelligent à votre script Hugging Face Transformers
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script"></a>

Il existe deux manières d'implémenter le tamisage SageMaker intelligent dans la classe Transformers. `Trainer`

**Note**  
Si vous utilisez l'un des DLCs for PyTorch avec le package de tamisage SageMaker intelligent installé, notez que vous devez installer la `transformers` bibliothèque. Vous pouvez installer des packages supplémentaires en [étendant DLCs](prebuilt-containers-extend.md) ou en passant `requirements.txt` à la classe de lancement de tâches d'entraînement for PyTorch ([https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)) dans le SDK SageMaker AI Python.

## Configuration simple
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script-simple"></a>

Le moyen le plus simple d'implémenter le criblage SageMaker intelligent dans la `Trainer` classe Transformers consiste à utiliser la `enable_sifting` fonction. Cette fonction accepte un objet `Trainer` existant et enveloppe l’objet `DataLoader` avec `SiftingDataloader`. Vous pouvez continuer à utiliser le même objet d’entraînement. Consultez l’exemple d’utilisation suivant.

```
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 classe `SiftingDataloader` est un chargeur de données itérable. La taille exacte du jeu de données obtenu n’est pas connue à l’avance en raison de l’échantillonnage aléatoire lors de l’analyse. Par conséquent, le `Trainer` Hugging Face s’attend à un [argument d’entraînement `max_steps`](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.max_steps). Notez que cet argument remplace le paramètre de configuration d’époque `num_train_epochs`. Si votre chargeur de données d’origine était également itérable, ou si votre entraînement utilise `max_steps` une seule époque, le `SiftingDataloader` fonctionne de la même manière que le chargeur de données existant. Si le chargeur de données d’origine n’était pas itérable ou si `max_steps` n’était pas fourni, Hugging Face Trainer peut générer un message d’erreur similaire au suivant. 

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

Pour résoudre ce problème, la fonction `enable_sifting` fournit un paramètre `set_epochs` facultatif. Cela permet l’entraînement avec des époques, en utilisant le nombre d’époques fourni par [l’argument num\_train\_epochs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.num_train_epochs(float,) de la classe `Trainer` et définit `max_steps` sur l’entier système maximal, permettant ainsi à l’entraînement de progresser jusqu’à ce que les époques spécifiées soient terminées.

## Configuration personnalisée
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script-custom-trainer"></a>

Pour une intégration personnalisée du chargeur de données de tamisage SageMaker intelligent, vous pouvez utiliser une classe Hugging Face personnalisée. `Trainer` Dans n’importe quelle sous-classe de `Trainer`, la fonction `get_train_dataloader()` peut être remplacée pour renvoyer un objet de la classe `SiftingDataloader` à la place. Dans les cas où des entraîneurs personnalisés existent déjà, cette approche peut être moins intrusive mais nécessite des modifications de code par rapport à l’option de configuration simple. Voici un exemple d'implémentation du tamisage SageMaker intelligent dans une classe Hugging Face personnalisée. `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
        )
```

À l’aide de la classe `Trainer` enveloppée, créez-en un objet comme suit.

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

trainer.train()
```