Wenden Sie SageMaker Smart Sifting auf Ihr Skript an PyTorch

Konfigurieren Sie die SageMaker Smart-Sifting-Schnittstelle.

Die SageMaker Smart-Sifting-Bibliothek implementiert eine auf Verlusten basierende Probenahmetechnik mit relativem Schwellenwert, mit deren Hilfe Proben herausgefiltert werden können, die sich weniger negativ auf die Reduzierung des Verlustwerts auswirken. Der Algorithmus für SageMaker intelligentes Sieben berechnet den Verlustwert jeder Eingabedatenprobe mithilfe eines Vorwärtsdurchlaufs und berechnet dessen relativen Perzentil im Vergleich zu den Verlustwerten 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 zu dem loss_based_sift_config Parameter und verwandten Klassen finden Sie SageMaker Konfigurationsmodule für intelligentes Sieben im Referenzabschnitt zum SageMaker Smart Sifting Python SDK.

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

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

Verschiedene Trainingsanwendungsfälle erfordern unterschiedliche Trainingsdatenformate. Angesichts der Vielzahl von Datenformaten muss der SageMaker Smart-Sifting-Algorithmus herausfinden, wie das Sieben für eine bestimmte Charge durchgeführt werden soll. Um dieses Problem zu lösen, bietet SageMaker Smart Sifting ein Batch-Transformationsmodul, das dabei hilft, Chargen in standardisierte Formate umzuwandeln, die effizient gesiebt 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. Bei diesen Datenformaten übernimmt SageMaker Smart Sifting automatisch die Konvertierung des Batch-Datenformats, 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
   Batches vom Typ {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 des Typs konnte nicht indexiert werden {type(batch)}	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 Chargengröße entspricht {batch_size} nicht den Größen 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 SageMaker Smart-Sifting-Algorithmus 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.

   • Ein Beispiel für eine Implementierung einer Batch-Transformation für benutzerdefinierte Listen mit SageMaker intelligentem Sifting für Fälle, in denen der Dataloader-Chunk Eingaben, Masken und Beschriftungen 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

   • Ein Beispiel für eine Implementierung einer Batch-Transformation für benutzerdefinierte Listen mit SageMaker intelligentem Sifting für Fälle, in denen keine Beschriftungen für die umgekehrte Transformation erforderlich sind.

     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

   • Ein Beispiel für eine benutzerdefinierte Tensor-Batch-Implementierung mit SageMaker intelligentem Sifting für Fälle, in denen der Dataloader-Chunk Eingaben, Masken und Beschriftungen 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 SageMaker Smart-Sifting-Schnittstelle. Loss 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 SageMaker Smart Loss Sifting-Klasse zu erstellen.

1. SageMaker Smart Sifting berechnet einen Verlustwert für jede Trainingsdatenprobe, im Gegensatz zur Berechnung eines einzelnen Verlustwerts für eine Charge. Um sicherzustellen, dass beim SageMaker intelligenten Sieben dieselbe Logik zur Berechnung des Verlusts verwendet wird, erstellen Sie eine smart-sifting-implemented Verlustfunktion mithilfe des SageMaker Loss Smart-Sifting-Moduls, das Ihre Verlustfunktion verwendet und den Verlust pro Trainingsprobe berechnet.

   Tipp

   SageMaker Der Smart-Sifting-Algorithmus wird für jede Datenprobe ausgeführt, nicht für den gesamten Stapel. 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 das original_batch Modell (oder transformed_batch falls Sie in Schritt 2 eine Batch-Transformation eingerichtet haben) und das PyTorch Modell akzeptiert. Unter Verwendung der angegebenen Verlustfunktion ohne Reduzierung führt das SageMaker intelligente Sieben für jede Datenprobe einen Vorwärtsdurchlauf durch, um deren Verlustwert zu ermitteln.

Der folgende Code ist ein Beispiel für eine smart-sifting-implemented Loss Schnittstelle mit dem NamenSiftingImplementedLoss.

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.

Binden Sie den PyTroch Datenlader in die SageMaker SiftingDataloader AI-Klasse ein.

Verwenden Sie abschließend alle von SageMaker Smart Sifting implementierten Klassen, die Sie in den vorherigen Schritten konfiguriert haben, für die SageMaker SiftingDataloder AI-Konfigurationsklasse. Diese Klasse ist ein Wrapper für. PyTorch DataLoader Durch das Wrapping wird SageMaker Smart Sifting so registriert PyTorchDataLoader, dass es als Teil des Ladens von Daten in jeder Iteration eines PyTorch Trainingsjobs ausgeführt wird. Das folgende Codebeispiel demonstriert die Implementierung von SageMaker KI-Datensifting zu a. 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
)