Appliquez un tri SageMaker intelligent à votre script PyTorch

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.

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 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.

(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.

2. 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.

   Message d’erreur	Résolution
   Les lots de type ne {type(batch)} sont pas pris en charge par défaut.	Cette erreur indique que le format de lot n’est pas pris en charge par défaut. Vous devez implémenter une classe de transformation par lots personnalisée et l’utiliser en la spécifiant dans le paramètre batch_transforms de la classe SiftingDataloader.
   Impossible d'indexer le lot de type {type(batch)}	Cette erreur indique que l’objet du lot ne peut pas être indexé normalement. L’utilisateur doit implémenter une transformation par lots personnalisée et la transmettre à l’aide du paramètre batch_transforms.
   La taille du lot {batch_size} ne correspond pas aux tailles de dimension 0 ou de dimension 1	Cette erreur se produit lorsque la taille de lot fournie ne correspond pas aux dimensions 0 ou 1 du lot. L’utilisateur doit implémenter une transformation par lots personnalisée et la transmettre à l’aide du paramètre batch_transforms.
   La dimension 0 et la dimension 1 correspondent à la taille du lot	Cette erreur indique que, dans la mesure où plusieurs dimensions correspondent à la taille de lot fournie, des informations supplémentaires sont nécessaires pour analyser le lot. L’utilisateur peut fournir le paramètre batch_format_index pour indiquer si le lot est indexable par exemple ou par caractéristique. Les utilisateurs peuvent également implémenter une transformation par lots personnalisée, mais cela demande plus de travail que nécessaire.

   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.

Créez une classe pour implémenter l'Lossinterface 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 :

2. 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-implementedLossinterface nomméeSiftingImplementedLoss.

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.

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 DataLoader. En encapsulant PyTorchDataLoader, 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 PyTorchDataLoader.

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
)