Application de l’analyse intelligente SageMaker sur votre script PyTorch

Configurez l’interface d’analyse intelligente SageMaker.

La bibliothèque d’analyse intelligente SageMaker met en œuvre une technique d’échantillonnage basée sur un seuil relatif de perte qui permet de filtrer les exemples avec un impact moindre sur la réduction de la valeur de perte. L’algorithme d’analyse intelligente SageMaker calcule la valeur de perte de chaque exemple de données d’entrée à l’aide d’une transmission avant 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 paramètre loss_based_sift_config et les classes associées, consultez Modules de configuration d’analyse intelligente SageMaker dans la section de référence du kit SDK Python de l’analyse intelligente SageMaker.

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 par analyse intelligente SageMaker.

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 d’analyse intelligente SageMaker doit identifier comment effectuer l’analyse sur un lot donné. Pour y remédier, l’analyse intelligente SageMaker propose un module de transformation par lots qui permet de convertir les lots en formats standardisés qu’il peut analyser efficacement.

1. L’analyse intelligente SageMaker 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, l’analyse intelligente SageMaker gère automatiquement la conversion du format des données par lots. 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 l’analyse intelligente SageMaker, 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 {type (batch)} ne 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 que l’algorithme d’analyse intelligente SageMaker peut traiter. 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 l’analyse intelligente SageMaker pour les cas où le fragment du dataloader 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 l’analyse intelligente SageMaker 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 d’une transformation par lots de tenseurs personnalisée avec l’analyse intelligente SageMaker pour les cas où le fragment du dataloader 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’interface Loss d’analyse intelligente SageMaker. 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 implémentée Loss d’analyse intelligente SageMaker.

1. L’analyse intelligente SageMaker calcule une valeur de perte pour chaque exemple de données d’entraînement, au lieu de calculer une valeur de perte unique pour un lot. Pour vous assurer que l’analyse intelligente SageMaker utilise la même logique de calcul de perte, créez une fonction de perte implémentée d’analyse intelligente à l’aide du module Loss d’analyse intelligente SageMaker qui utilise votre fonction de perte et calcule la perte par exemple d’entraînement.

   Astuce

   L’algorithme d’analyse intelligente SageMaker s’exécute sur chaque exemple de données, et non sur l’ensemble du lot. Vous devez donc ajouter une fonction d’initialisation pour définir la fonction de perte PyTorch 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 original_batch (ou transformed_batch si vous avez configuré une transformation par lots à l’étape 2) et le modèle PyTorch. En utilisant la fonction de perte spécifiée sans réduction, l’analyse intelligente SageMaker effectue une transmission avant pour chaque exemple de données afin d’évaluer sa valeur de perte.

Le code suivant est un exemple d’interface Loss implémentée d’analyse intelligente 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.

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

Enfin, utilisez toutes les classes implémentées d’analyse intelligente SageMaker que vous avez configurées dans les étapes précédentes pour la classe de configuration SiftingDataloder SageMaker AI. Cette classe est un wrapper pour DataLoader de PyTorch. En enveloppant DataLoader de PyTorch, l’analyse intelligente SageMaker est enregistrée pour être exécutée dans le cadre du chargement des données à chaque itération d’une tâche d’entraînement PyTorch. L’exemple de code suivant montre comment implémenter l’analyse des données SageMaker AI dans un DataLoader de PyTorch.

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
)