Wenden Sie SageMaker Smart Sifting auf Ihr Skript an PyTorch

Konfiguriere die SageMaker Smart Sifting-Oberfläche.

Die SageMaker Smart Sifting Library implementiert eine auf Verlusten basierende Probenahmetechnik mit relativem Schwellenwert, mit der Proben herausgefiltert werden können, die sich weniger auf die Reduzierung des Verlustwerts auswirken. Der SageMaker Smart-Sifting-Algorithmus 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 über den loss_based_sift_config Parameter und die zugehörigen Klassen finden Sie SageMaker Konfigurationsmodule für Smart Sifting im Python-SDK-Referenzabschnitt für SageMaker Smart Sifting.

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 ermitteln, wie das Sieben bei einer bestimmten Charge durchgeführt werden soll. Um diesem Problem zu begegnen, bietet SageMaker Smart Sifting ein Batch-Transformationsmodul, das dabei hilft, Stapel in standardisierte Formate umzuwandeln, die dann effizient durchsucht 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 durch SageMaker Smart Sifting nicht in einem der 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 dieses 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 Batch des Typs kann 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 Stapelgröße entspricht {batch_size} nicht den Größen von 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 benutzerdefinierten Batch-Transformation für Listen mit SageMaker intelligenter Suche 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 benutzerdefinierten Batch-Transformation für Listen mit SageMaker intelligenter Suche für Fälle, in denen für die Rücktransformation keine Bezeichnungen 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 intelligenter Sichtung für Fälle, in denen der Datenlader-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 Unterschritte durch, um eine in SageMaker Smart Sifting Loss implementierte 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 SageMaker Smart Sifting dieselbe Logik zur Verlustberechnung verwendet, erstellen Sie eine in Smart-Sifting implementierte Verlustfunktion mithilfe des SageMaker Smart Loss 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 Verlustfunktion ohne Reduktionsstrategie einzustellen. PyTorch

   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 (oder, transformed_batch falls Sie in Schritt 2 eine Batch-Transformation eingerichtet haben) und das PyTorch Modell akzeptiert. SageMaker Smart Sifting verwendet die angegebene Verlustfunktion ohne Reduzierung und führt für jede Datenprobe einen Vorwärtsdurchlauf durch, um ihren 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 nach der SageMaker SiftingDataloader AI-Klasse.

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 Trainingsauftrags ausgeführt wird. Das folgende Codebeispiel zeigt die Implementierung von SageMaker KI-Datensifting in 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
)