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 RelativeProbabilisticSiftConfig classe pour créer un objet de configuration de criblage.

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

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'sift_configobjet de l'exemple de code précédent est utilisé à l'étape 4 pour configurer la SiftingDataloader classe.

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

Les différents cas d'utilisation de la formation nécessitent des formats de données de formation 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 configurationSiftingDataloader, laissez le batch_transforms paramètre de SiftingDataloader à sa valeur par défaut, qui estNone.

2. Si votre ensemble de données n'est pas dans ces formats, vous devez passer à la suite de cette étape pour créer une transformation par lots personnalisée à l'aide deSiftingBatchTransform.

   Dans les cas où votre jeu de données n'est pas dans l'un des formats pris en charge par le tri SageMaker intelligent, vous risquez de rencontrer des erreurs. Ces erreurs de format de données peuvent être résolues en ajoutant le batch_transforms paramètre batch_format_index or à la SiftingDataloader classe, que vous avez configurée à l'étape 4. Vous trouverez ci-dessous des exemples d'erreurs dues à un format de données incompatible et à leurs résolutions.

   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 batch_transforms paramètre de la SiftingDataloader classe.
   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 batch_transforms paramètre.
   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 à la 0ème ou à la 1re dimension du lot. L'utilisateur doit implémenter une transformation par lots personnalisée et la transmettre à l'aide du batch_transforms paramètre.
   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 tamiser le lot. L'utilisateur peut fournir le batch_format_index paramètre pour indiquer si le lot est indexable par échantillon ou par fonctionnalité. 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 mentionnés ci-dessus, vous devez créer une classe de transformation par lots personnalisée à l'aide du SiftingBatchTransform module. 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. Une fois que vous avez créé une classe de transformation par lots, celle-ci renvoie un SiftingBatch objet que vous lui transmettrez à l'SiftingDataloaderétape 4.

   Vous trouverez ci-dessous des exemples de classes de transformation par lots personnalisées du SiftingBatchTransform module.

   • 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 SiftingBatchTransform implémentée, vous utilisez cette classe à l'étape 4 pour la SiftingDataloader configurer. Le reste de ce guide part du principe qu'une ListBatchTransform classe est créée. À l'étape 4, cette classe est transmise aubatch_transforms.

Créez une classe pour implémenter l'Lossinterface de tamisage SageMaker intelligente. Ce didacticiel part du principe que la classe est nomméeSiftingImplementedLoss. Lors de la configuration de ce cours, nous vous recommandons d'utiliser la même fonction de perte dans le modèle de boucle d'entraînement. 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')

   Cela est également illustré dans l'exemple de code suivant.

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 passe directe réelle, ce calcul de perte par tamisage 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
)