Anwenden von SageMaker Smart Sifting auf Ihr PyTorch-Skript

Konfigurieren Sie die Schnittstelle von SageMaker Smart Sifting.

Die Smart-Sifting-Bibliothek von SageMaker implementiert eine Verlust-basierte Sampling-Methode mit relativem Schwellenwert, mit der Proben herausgefiltert werden, die sich weniger auf die Reduzierung des Verlustwerts auswirken. Der Smart-Sifting-Algorithmus von SageMaker berechnet den Verlustwert jeder Eingabedatenprobe mithilfe eines Vorwärtsdurchlaufs und berechnet das relative Perzentil anhand der Verlustwerte früherer Daten.

Die folgenden beiden Parameter müssen Sie für die RelativeProbabilisticSiftConfig-Klasse angeben, um ein Konfigurationsobjekt für die Sichtung zu erstellen.

Das folgende Codebeispiel zeigt die Einrichtung eines Objekts der RelativeProbabilisticSiftConfig-Klasse.

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

Weitere Informationen zum loss_based_sift_config-Parameter und den zugehörigen Klassen finden Sie unter Konfigurationsmodule für SageMaker Smart Sifting im Abschnitt „SageMaker Smart Sifting“ der Python-SDK-Referenz.

Das sift_config-Objekt im vorherigen Codebeispiel wird in Schritt 4 zum Einrichten der SiftingDataloader-Klasse verwendet.

(Optional) Konfigurieren Sie eine Batch-Transformationsklasse für SageMaker Smart Sifting.

Verschiedene Trainingsanwendungsfälle erfordern unterschiedliche Trainingsdatenformate. Angesichts der Vielzahl von Datenformaten muss der Smart-Sifting-Algorithmus von SageMaker ermitteln, wie die Sichtung für ein bestimmtes Batch durchgeführt werden soll. Um dieses Problem zu lösen, bietet SageMaker Smart Sifting ein Batch-Transformationsmodul, um Batches in standardisierte Formate zu konvertieren, die effizient gesichtet werden können.

1. SageMaker Smart Sifting verarbeitet die Batch-Transformation von Trainingsdaten in den folgenden Formaten: Python-Listen, Wörterbücher, Tupel und Tensoren. Für diese Datenformate übernimmt SageMaker Smart Sifting automatisch die Batch-Datenformatkonvertierung und Sie können den Rest dieses Schritts überspringen. Wenn Sie diesen Schritt überspringen, behalten Sie in Schritt 4 für die Konfiguration von SiftingDataloader den Standardwert des batch_transforms-Parameters von SiftingDataloader, d. h. None.

2. Wenn Ihr Datensatz in keinem dieser Formate vorliegt, sollten Sie den Rest dieses Schritts ausführen, um eine benutzerdefinierte Batch-Transformation mit SiftingBatchTransform zu erstellen.

   In Fällen, in denen Ihr Datensatz nicht in einem der von SageMaker Smart Sifting unterstützten Formate vorliegt, können Fehler auftreten. Solche Datenformatfehler können behoben werden, indem Sie der SiftingDataloader-Klasse, die Sie in Schritt 4 eingerichtet haben, den Parameter batch_transforms oder batch_format_index hinzufügen. Im Folgenden finden Sie Beispiele für Fehler, die auf ein inkompatibles Datenformat zurückzuführen sind, sowie deren Auflösung.

   Fehlermeldung	Auflösung
   Stapel des Typs {type(batch)} werden standardmäßig nicht unterstützt.	Dieser Fehler weist darauf hin, dass das Batch-Format standardmäßig nicht unterstützt wird. Sie sollten eine benutzerdefinierte Batch-Transformationsklasse implementieren und diese verwenden, indem Sie sie für den batch_transforms-Parameter der SiftingDataloader-Klasse angeben.
   Der Stapel vom Typ {type(batch)} konnte nicht indexiert werden.	Dieser Fehler weist darauf hin, dass das Batch-Objekt nicht normal indexiert werden kann. Der Benutzer muss eine benutzerdefinierte Batch-Transformation implementieren und diese mithilfe des batch_transforms-Parameters übergeben.
   Die Batchgröße {batch_size} entspricht nicht den Größen für Dimension 0 oder Dimension 1.	Dieser Fehler tritt auf, wenn die angegebene Batchgröße nicht der nullten oder ersten Dimension des Batches entspricht. Der Benutzer muss eine benutzerdefinierte Batch-Transformation implementieren und diese mithilfe des batch_transforms-Parameters übergeben.
   Sowohl Dimension 0 als auch Dimension 1 entsprechen der Batchgröße.	Dieser Fehler weist darauf hin, dass für die Sichtung des Batches mehr Informationen erforderlich sind, da mehrere Dimensionen der angegebenen Batchgröße entsprechen. Der Benutzer kann den batch_format_index-Parameter festlegen, um anzugeben, ob das Batch nach Probe oder Merkmal indexierbar ist. Benutzer können auch eine benutzerdefinierte Batch-Transformation implementieren, dies ist jedoch mit unnötigem Arbeitsaufwand verbunden.

   Sie müssen mithilfe des SiftingBatchTransform-Moduls eine benutzerdefinierte Batch-Transformationsklasse erstellen, um die oben genannten Probleme zu beheben. Eine Batch-Transformationsklasse sollte aus einem Paar von Transformations- und Rücktransformationsfunktionen bestehen. Das Funktionspaar konvertiert Ihr Datenformat in ein Format, das der Smart-Sifting-Algorithmus von SageMaker verarbeiten kann. Nachdem Sie eine Batch-Transformationsklasse erstellt haben, gibt die Klasse ein SiftingBatch-Objekt zurück, das Sie in Schritt 4 an die SiftingDataloader-Klasse übergeben.

   Im Folgenden finden Sie Beispiele für benutzerdefinierte Batch-Transformationsklassen des SiftingBatchTransform-Moduls.

   • Beispiel für eine benutzerdefinierte ListBatchTransform-Implementierung mit SageMaker Smart Sifting für Fälle, in denen der Dataloader-Block Eingaben, Masken und Kennzeichnungen enthält

     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

   • Beispiel für eine benutzerdefinierte ListBatchTransform-Implementierung mit SageMaker Smart Sifting für Fälle, in denen keine Kennzeichnungen für die Rücktransformation benötigt werden

     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

   • Beispiel für eine benutzerdefinierte Tensor-Batch-Implementierung mit SageMaker Smart Sifting für Fälle, in denen der Datenladeblock Eingaben, Masken und Kennzeichnungen enthält.

     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

   Nachdem Sie eine mit SiftingBatchTransform implementierte Batch-Transformationsklasse erstellt haben, verwenden Sie diese Klasse in Schritt 4 zum Einrichten der SiftingDataloader-Klasse. Im Rest dieses Handbuchs wird davon ausgegangen, dass eine ListBatchTransform-Klasse erstellt wurde. In Schritt 4 wird diese Klasse an batch_transforms übergeben.

Erstellen Sie eine Klasse für die Implementierung der Loss-Schnittstelle von SageMaker Smart Sifting. In diesem Tutorial wird davon ausgegangen, dass die Klasse SiftingImplementedLoss benannt ist. Wir empfehlen, bei der Einrichtung dieser Klasse dieselbe Verlustfunktion in der Modelltrainingsschleife zu verwenden. Gehen Sie die folgenden Teilschritte durch, um eine implementierte Loss-Klasse für SageMaker Smart Sifting zu erstellen.

1. SageMaker Smart Sifting berechnet einen Verlustwert für jede Trainingsdatenprobe, statt einen einzigen Verlustwert für ein Batch zu berechnen. Um sicherzustellen, dass SageMaker Smart Sifting dieselbe Verlustberechnungslogik verwendet, erstellen Sie mithilfe des Loss-Moduls von SageMaker Smart Sifting eine in Smart Sifting implementierte Verlustfunktion. Dieses Modul verwendet Ihre Verlustfunktion und berechnet den Verlust pro Trainingsprobe.

   Tipp

   Der Smart-Sifting-Algorithmus von SageMaker wird für jede Datenprobe ausgeführt, nicht für den gesamten Batch. Sie sollten daher eine Initialisierungsfunktion hinzufügen, um die PyTorch-Verlustfunktion ohne jegliche Reduktionsstrategie festzulegen.

   class SiftingImplementedLoss(Loss):  
       def __init__(self):
           self.loss = torch.nn.CrossEntropyLoss(reduction='none')

   Dies wird auch im folgenden Codebeispiel veranschaulicht.

2. Definieren Sie eine Verlustfunktion, die den original_batch (oder transformed_batch, wenn Sie in Schritt 2 eine Batch-Transformation eingerichtet haben) und das PyTorch-Modell akzeptiert. Unter Verwendung der angegebenen Verlustfunktion ohne Reduzierung führt SageMaker Smart Sifting für jede Datenprobe einen Vorwärtsdurchlauf durch, um deren Verlustwert zu ermitteln.

Der folgende Code ist ein Beispiel für eine in Smart Sifting implementierte Loss-Schnittstelle mit dem Namen 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])

Bevor die Trainingsschleife den eigentlichen Vorwärtsdurchlauf erreicht, wird die Verlustberechnung bei der Sichtung während der Datenladephase durchgeführt, in der in jeder Iteration ein Batch abgerufen wird. Der individuelle Verlustwert wird dann mit früheren Verlustwerten verglichen und sein relatives Perzentil wird für das Objekt von RelativeProbabilisticSiftConfig geschätzt, das Sie in Schritt 1 eingerichtet haben.

Umschließen Sie den PyTroch-Datenlader mit der SiftingDataloader-Klasse von SageMaker AI.

Verwenden Sie abschließend alle in SageMaker Smart Sifting implementierten Klassen, die Sie in den vorherigen Schritten für die SiftingDataloder-Konfigurationsklasse von SageMaker AI konfiguriert haben. Diese Klasse ist ein Wrapper für PyTorch DataLoader. Durch das Umschließen von PyTorch DataLoader wird SageMaker Smart Sifting registriert, um beim Laden von Daten in jeder Iteration eines PyTorch-Trainingsjobs ausgeführt zu werden. Das folgende Codebeispiel demonstriert die Implementierung der Datensichtung von SageMaker AI in einem 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
)