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.

# SageMaker sélection intelligente dans votre script d'entraînement
<a name="train-smart-sifting-apply-to-script"></a>

La bibliothèque de tamisage SageMaker intelligent est intégrée au [framework SageMaker AI](train-smart-sifting-what-is-supported.md#train-smart-sifting-supported-frameworks) en DLCs tant que bibliothèque complémentaire. Il fournit une logique de filtrage par rapport aux exemples d’entraînement qui ont un impact relativement faible sur l’entraînement des modèles et votre modèle peut atteindre la précision de modèle souhaitée avec moins d’exemples d’entraînement par rapport à l’entraînement des modèles avec des exemples de données complets.

Pour savoir comment implémenter l’outil d’analyse intelligente dans votre script d’entraînement, choisissez l’une des options suivantes en fonction du cadre que vous utilisez.

**Topics**
+ [Appliquez un tri SageMaker intelligent à votre script PyTorch](train-smart-sifting-apply-to-pytorch-script.md)
+ [Appliquez un SageMaker filtrage intelligent à votre script Hugging Face Transformers](train-smart-sifting-apply-to-hugging-face-transformers-script.md)

# Appliquez un tri SageMaker intelligent à votre script PyTorch
<a name="train-smart-sifting-apply-to-pytorch-script"></a>

Ces instructions montrent comment activer le tri SageMaker intelligent avec votre script d'entraînement.

1. Configurez l'interface de tamisage SageMaker intelligent.

   La bibliothèque de tamisage SageMaker intelligente met en œuvre une technique d'échantillonnage basée sur des seuils relatifs qui permet de filtrer les échantillons avec un impact moindre sur la réduction de la valeur des pertes. L'algorithme de tamisage SageMaker intelligent calcule la valeur de perte de chaque échantillon de données d'entrée à l'aide d'un transfert direct, et calcule son percentile relatif par rapport aux valeurs de perte des données précédentes. 

   Les deux paramètres suivants sont ceux que vous devez spécifier à la classe `RelativeProbabilisticSiftConfig` pour créer un objet de configuration d’analyse. 
   + Spécifiez la proportion de données à utiliser pour l’entraînement par rapport au paramètre `beta_value`.
   + Spécifiez le nombre d’échantillons utilisés dans la comparaison avec le paramètre `loss_history_length`.

   L’exemple de code suivant montre comment configurer un objet de la classe `RelativeProbabilisticSiftConfig`.

   ```
   from smart_sifting.sift_config.sift_configs import (
       RelativeProbabilisticSiftConfig
       LossConfig
       SiftingBaseConfig
   )
   
   sift_config=RelativeProbabilisticSiftConfig(
       beta_value=0.5,
       loss_history_length=500,
       loss_based_sift_config=LossConfig(
            sift_config=SiftingBaseConfig(sift_delay=0)
       )
   )
   ```

   Pour plus d'informations sur le `loss_based_sift_config` paramètre et les classes associées, consultez [SageMaker modules de configuration de tamisage intelligent](train-smart-sifting-pysdk-reference.md#train-smart-sifting-pysdk-base-config-modules) la section de référence du SDK Python SageMaker Smart Sifting.

   L’objet `sift_config` de l’exemple de code précédent est utilisé à l’étape 4 pour configurer la classe `SiftingDataloader`.

1. (Facultatif) Configurez une classe de transformation par lots à tamisage SageMaker intelligent.

   Les différents cas d’utilisation de l’entraînement nécessitent des formats de données d’entraînement différents. Compte tenu de la variété des formats de données, l'algorithme de tamisage SageMaker intelligent doit identifier comment effectuer le tamisage sur un lot particulier. Pour résoudre ce problème, le tamisage SageMaker intelligent fournit un module de transformation par lots qui permet de convertir les lots en formats standardisés qu'il peut tamiser efficacement. 

   1. SageMaker le criblage intelligent gère la transformation par lots des données d'entraînement dans les formats suivants : listes Python, dictionnaires, tuples et tenseurs. Pour ces formats de données, le tamisage SageMaker intelligent gère automatiquement la conversion des formats de données par lots, et vous pouvez ignorer le reste de cette étape. Si vous ignorez cette étape, à l’étape 4 de configuration de `SiftingDataloader`, laissez le paramètre `batch_transforms` de `SiftingDataloader` à sa valeur par défaut, qui est `None`.

   1. Si votre jeu de données n’est pas dans ce format, vous devez passer à la suite de cette étape pour créer une transformation par lots personnalisée à l’aide de `SiftingBatchTransform`. 

      Si votre jeu de données n'est pas dans l'un des formats pris en charge par le SageMaker tri intelligent, vous risquez de rencontrer des erreurs. Ces erreurs de format de données peuvent être résolues en ajoutant le paramètre `batch_format_index` ou `batch_transforms` à la classe `SiftingDataloader`, que vous avez configuré à l’étape 4. Vous trouverez ci-dessous des exemples d’erreurs dues à un format de données incompatible et leur résolution.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/train-smart-sifting-apply-to-pytorch-script.html)

      Pour résoudre les problèmes susmentionnés, vous devez créer une classe de transformation par lots personnalisée à l’aide du module `SiftingBatchTransform`. Une classe de transformation par lots doit être composée d’une paire de fonctions de transformation et de transformation inverse. La paire de fonctions convertit le format de vos données en un format pouvant être traité par un algorithme de criblage SageMaker intelligent. Après avoir créé une classe de transformation par lots, celle-ci renvoie un objet `SiftingBatch` que vous transmettrez à la classe `SiftingDataloader` à l’étape 4.

      Vous trouverez ci-dessous des exemples de classes de transformation par lots personnalisée du module `SiftingBatchTransform`.
      + Exemple d'implémentation d'une transformation par lots de listes personnalisée avec sélection SageMaker intelligente pour les cas où le segment du chargeur de données contient des entrées, des masques et des étiquettes.

        ```
        from typing import Any
        
        import torch
        
        from smart_sifting.data_model.data_model_interface import SiftingBatchTransform
        from smart_sifting.data_model.list_batch import ListBatch
        
        class ListBatchTransform(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
        ```
      + Exemple d'implémentation d'une transformation par lots de listes personnalisée avec SageMaker tri intelligent pour les cas où aucune étiquette n'est nécessaire pour la transformation inverse.

        ```
        class ListBatchTransformNoLabels(SiftingBatchTransform):
            def transform(self, batch: Any):
                return ListBatch(batch[0].tolist())
        
            def reverse_transform(self, list_batch: ListBatch):
                a_batch = [torch.tensor(list_batch.inputs)]
                return a_batch
        ```
      + Exemple d'implémentation personnalisée par lots tensoriels avec criblage SageMaker intelligent pour les cas où le bloc du chargeur de données contient des entrées, des masques et des étiquettes.

        ```
        from typing import Any
        
        from smart_sifting.data_model.data_model_interface import SiftingBatchTransform
        from smart_sifting.data_model.tensor_batch import TensorBatch
        
        class TensorBatchTransform(SiftingBatchTransform):
            def transform(self, batch: Any):
                a_tensor_batch = TensorBatch(
                    batch[0], batch[-1]
                )  # assume the last one is the list of labels
                return a_tensor_batch
        
            def reverse_transform(self, tensor_batch: TensorBatch):
                a_batch = [tensor_batch.inputs, tensor_batch.labels]
                return a_batch
        ```

      Après avoir créé une classe de transformation par lots implémentée `SiftingBatchTransform`, vous utilisez cette classe à l’étape 4 pour configurer la classe `SiftingDataloader`. Le reste de ce guide part du principe qu’une classe `ListBatchTransform` est créée. À l’étape 4, cette classe est transmise à `batch_transforms`.

1. Créez une classe pour implémenter l'`Loss`interface de tamisage SageMaker intelligente. Ce didacticiel suppose que la classe s’appelle `SiftingImplementedLoss`. Lors de la configuration de cette classe, nous vous recommandons d’utiliser la même fonction de perte dans la boucle d’entraînement des modèles. Suivez les sous-étapes suivantes pour créer une classe `Loss` implémentée par tamisage SageMaker intelligent.

   1. SageMaker le criblage intelligent calcule une valeur de perte pour chaque échantillon de données d'apprentissage, au lieu de calculer une valeur de perte unique pour un lot. Pour vous assurer que le tamisage SageMaker intelligent utilise la même logique de calcul des pertes, créez une fonction de smart-sifting-implemented perte à l'aide du `Loss` module de tamisage SageMaker intelligent qui utilise votre fonction de perte et calcule les pertes par échantillon d'entraînement. 
**Astuce**  
SageMaker l'algorithme de criblage intelligent s'exécute sur chaque échantillon de données, et non sur l'ensemble du lot, vous devez donc ajouter une fonction d'initialisation pour définir la fonction de PyTorch perte sans aucune stratégie de réduction.  

      ```
      class SiftingImplementedLoss(Loss):  
          def __init__(self):
              self.loss = torch.nn.CrossEntropyLoss(reduction='none')
      ```
Voici un exemple de code :

   1. Définissez une fonction de perte qui accepte le `original_batch` (ou `transformed_batch` si vous avez configuré une transformation par lots à l'étape 2) et le PyTorch modèle. En utilisant la fonction de perte spécifiée sans réduction, le criblage SageMaker intelligent effectue un transfert direct pour chaque échantillon de données afin d'évaluer sa valeur de perte. 

   Le code suivant est un exemple d' smart-sifting-implemented`Loss`interface nommée`SiftingImplementedLoss`.

   ```
   from typing import Any
   
   import torch
   import torch.nn as nn
   from torch import Tensor
   
   from smart_sifting.data_model.data_model_interface import SiftingBatch
   from smart_sifting.loss.abstract_sift_loss_module import Loss
   
   model=... # a PyTorch model based on torch.nn.Module
   
   class SiftingImplementedLoss(Loss):   
       # You should add the following initializaztion function 
       # to calculate loss per sample, not per batch.
       def __init__(self):
           self.loss_no_reduction = 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] # use this if you use original batch and skipped step 2
           # batch = [t.to(device) for t in transformed_batch] # use this if you transformed batches in step 2
   
           # compute loss
           outputs = model(batch)
           return self.loss_no_reduction(outputs.logits, batch[2])
   ```

   Avant que la boucle d’entraînement n’atteigne la transmission avant réelle, ce calcul de perte par analyse est effectué pendant la phase de chargement des données qui consiste à récupérer un lot à chaque itération. La valeur de perte individuelle est ensuite comparée aux valeurs de perte précédentes et son percentile relatif est estimé en fonction de l’objet `RelativeProbabilisticSiftConfig` que vous avez configuré à l’étape 1.

1. Enveloppez le chargeur de PyTroch données par la `SiftingDataloader` classe SageMaker AI.

   Enfin, utilisez toutes les classes implémentées par le criblage SageMaker intelligent que vous avez configurées dans les étapes précédentes pour la classe de `SiftingDataloder` configuration SageMaker AI. Cette classe est un wrapper pour PyTorch [https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader). En encapsulant PyTorch`DataLoader`, le criblage SageMaker intelligent est enregistré pour être exécuté dans le cadre du chargement des données à chaque itération d'une tâche de PyTorch formation. L'exemple de code suivant illustre la mise en œuvre du SageMaker tri des données de l'IA vers un PyTorch`DataLoader`.

   ```
   from smart_sifting.dataloader.sift_dataloader import SiftingDataloader
   from torch.utils.data import DataLoader
   
   train_dataloader = DataLoader(...) # PyTorch data loader
   
   # Wrap the PyTorch data loader by SiftingDataloder
   train_dataloader = SiftingDataloader(
       sift_config=sift_config, # config object of RelativeProbabilisticSiftConfig
       orig_dataloader=train_dataloader,
       batch_transforms=ListBatchTransform(), # Optional, this is the custom class from step 2
       loss_impl=SiftingImplementedLoss(), # PyTorch loss function wrapped by the Sifting Loss interface
       model=model,
       log_batch_data=False
   )
   ```

# 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\$1train\$1epochs](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()
```