Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Wenden Sie SageMaker Smart Sifting auf Ihr Skript an PyTorch
<a name="train-smart-sifting-apply-to-pytorch-script"></a>

Diese Anleitung zeigt, wie du SageMaker Smart Sifting mit deinem Trainingsskript aktivierst.

1. 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. 
   + Geben Sie mit dem Parameter `beta_value` an, welcher Anteil der Daten für das Training verwendet werden soll.
   + Geben Sie mit dem Parameter `loss_history_length` die Anzahl der für den Vergleich verwendeten Stichproben an.

   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](train-smart-sifting-pysdk-reference.md#train-smart-sifting-pysdk-base-config-modules) 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.

1. (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`.

   1. 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.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/train-smart-sifting-apply-to-pytorch-script.html)

      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.

1. 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.

   1. 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 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.

1. 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 [https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) Durch das Wrapping wird SageMaker Smart Sifting so registriert PyTorch`DataLoader`, 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
   )
   ```