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 der RelativeProbabilisticSiftConfig Klasse angeben, um ein Sifting-Konfigurationsobjekt 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 Batch-Transformationsklasse für SageMaker intelligentes Sieben.

Verschiedene Trainingsanwendungsfälle erfordern unterschiedliche Trainingsdatenformate. Angesichts der Vielzahl von Datenformaten muss der Algorithmus für SageMaker intelligentes Sieben ermitteln, 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 zur Konfiguration SiftingDataloader den Standardwert für den batch_transforms Parameter von SiftingDataloader bei, d. h. None

2. Wenn Ihr Datensatz nicht in diesem Format vorliegt, sollten Sie mit dem Rest dieses Schritts fortfahren, um eine benutzerdefinierte Batch-Transformation mit zu erstellenSiftingBatchTransform.

   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 batch_transforms Parameter batch_format_index oder 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 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 Chargengröße nicht der 0ten oder ersten Dimension der Charge 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 mehr Informationen erforderlich sind, um die Charge zu sichten, da mehrere Dimensionen der angegebenen Chargengröße entsprechen. Der Benutzer kann den batch_format_index Parameter angeben, um anzugeben, ob die Charge nach Probe oder Merkmal indexierbar ist. Benutzer können auch eine benutzerdefinierte Batch-Transformation implementieren, aber das ist mehr Arbeit als erforderlich.

   Um die oben genannten Probleme zu lösen, müssen Sie mithilfe des SiftingBatchTransform Moduls eine benutzerdefinierte Batch-Transformationsklasse erstellen. 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 Klasse. SiftingDataloader Im Rest dieses Handbuchs wird davon ausgegangen, dass eine ListBatchTransform Klasse erstellt wurde. In Schritt 4 wird diese Klasse an die übergebenbatch_transforms.

Erstellen Sie eine Klasse für die Implementierung der SageMaker Loss Smart-Sifting-Schnittstelle. In diesem Tutorial wird davon ausgegangen, dass die Klasse benannt SiftingImplementedLoss ist. Wir empfehlen, bei der Einrichtung dieses Kurses dieselbe Verlustfunktion in der Modelltrainingsschleife zu verwenden. Gehen Sie die folgenden Teilschritte durch, um eine Loss implementierte Klasse für SageMaker intelligentes Sieben 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 (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 einen Vorwärtsdurchlauf für jede Datenprobe 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, erfolgt diese Berechnung des Siebverlusts während der Datenladephase, in der in jeder Iteration ein Batch abgerufen wird. Der individuelle Verlustwert wird dann mit früheren Verlustwerten verglichen, und sein relativer Perzentil wird für das Objekt geschätzt, das RelativeProbabilisticSiftConfig Sie in Schritt 1 festgelegt haben.

Ordnen Sie den PyTroch Datenlader der AI-Klasse zu SageMaker . SiftingDataloader

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 Umschließen wird SageMaker Smart Sifting so registriert PyTorchDataLoader, dass es als Teil des Datenladens 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
)