Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Applica lo SageMaker smart sifting al tuo script PyTorch
<a name="train-smart-sifting-apply-to-pytorch-script"></a>

Queste istruzioni mostrano come abilitare lo SageMaker smart sifting con il tuo script di allenamento.

1. Configura l'interfaccia SageMaker smart sifting.

   La libreria SageMaker smart sifting implementa una tecnica di campionamento basata sulla perdita a soglia relativa che aiuta a filtrare i campioni con un impatto minore sulla riduzione del valore di perdita. L'algoritmo SageMaker smart sifting calcola il valore di perdita di ogni campione di dati di input utilizzando un passaggio in avanti e calcola il relativo percentile rispetto ai valori di perdita dei dati precedenti. 

   È necessario specificare i due parametri seguenti per la classe `RelativeProbabilisticSiftConfig` per creare un oggetto di configurazione di sifting. 
   + Specifica la proporzione di dati da utilizzare per l’addestramento al parametro `beta_value`.
   + Specifica il numero di campioni utilizzati nel confronto con il parametro `loss_history_length`.

   Il seguente esempio di codice mostra l’impostazione di un oggetto della classe `RelativeProbabilisticSiftConfig`.

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

   Per ulteriori informazioni sul `loss_based_sift_config` parametro e sulle classi correlate, vedere [SageMaker moduli di configurazione smart sifting](train-smart-sifting-pysdk-reference.md#train-smart-sifting-pysdk-base-config-modules) nella sezione di riferimento di SageMaker smart sifting Python SDK.

   L’oggetto `sift_config` nell’esempio di codice precedente viene utilizzato nella fase 4 per configurare la classe `SiftingDataloader`.

1. (Facoltativo) Configura una classe di trasformazione batch SageMaker smart sifting.

   Casi d’uso diversi per l’addestramento richiedono formati di dati di addestramento differenti. Data la varietà di formati di dati, l'algoritmo di setacciamento SageMaker intelligente deve identificare come eseguire il setacciamento su un determinato batch. Per risolvere questo problema, SageMaker smart sifting fornisce un modulo di trasformazione in batch che aiuta a convertire i batch in formati standardizzati che possono essere setacciati in modo efficiente. 

   1. SageMaker smart sifting gestisce la trasformazione in batch dei dati di addestramento nei seguenti formati: elenchi Python, dizionari, tuple e tensori. Per questi formati di dati, SageMaker smart sifting gestisce automaticamente la conversione del formato di dati in batch e puoi saltare il resto di questo passaggio. Se salti questa fase, nella fase 4 per la configurazione di `SiftingDataloader`, mantieni il valore predefinito del parametro `batch_transforms` di `SiftingDataloader`, ovvero `None`.

   1. Se il set di dati non è in questi formati, procedi con il resto di questa fase per creare una trasformazione in batch personalizzata mediante `SiftingBatchTransform`. 

      Nei casi in cui il set di dati non sia in uno dei formati supportati da SageMaker smart sifting, è possibile che si verifichino degli errori. Tali errori di formato dei dati possono essere risolti aggiungendo il parametro `batch_format_index` oppure `batch_transforms` alla classe `SiftingDataloader`, configurata nella fase 4. Di seguito sono riportati alcuni esempi di errori dovuti a un formato di dati incompatibile e le relative risoluzioni.    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/train-smart-sifting-apply-to-pytorch-script.html)

      Per risolvere i problemi sopra menzionati, è necessario creare una classe di trasformazione in batch personalizzata utilizzando il modulo `SiftingBatchTransform`. Una classe di trasformazione in batch deve essere costituita da una coppia di funzioni di trasformazione diretta e trasformazione inversa. La coppia di funzioni converte il formato dei dati in un formato elaborabile dall'algoritmo di selezione SageMaker intelligente. Dopo aver creato una classe di trasformazione in batch, questa restituisce un oggetto `SiftingBatch` da passare alla classe `SiftingDataloader` nella fase 4.

      Di seguito sono riportati alcuni esempi di classi di trasformazione in batch personalizzate del modulo `SiftingBatchTransform`.
      + Un esempio di implementazione personalizzata della trasformazione in batch di elenchi con SageMaker smart sifting per i casi in cui il blocco del dataloader contiene input, maschere ed etichette.

        ```
        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
        ```
      + Un esempio di implementazione di trasformazione in batch di elenchi personalizzata con SageMaker smart sifting per i casi in cui non sono necessarie etichette per la trasformazione inversa.

        ```
        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
        ```
      + Un esempio di implementazione tensor batch personalizzata con SageMaker smart sifting per i casi in cui il blocco del caricatore di dati ha input, maschere ed etichette.

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

      Dopo aver creato una classe di trasformazione in batch implementata da `SiftingBatchTransform`, utilizza questa classe nella fase 4 per configurare la classe `SiftingDataloader`. Il resto di questa guida presuppone la creazione di una classe `ListBatchTransform`. Nella fase 4, questa classe viene passata a `batch_transforms`.

1. Crea una classe per implementare l'interfaccia smart sifting. SageMaker `Loss` Questo tutorial presuppone che la classe sia denominata `SiftingImplementedLoss`. Durante la configurazione di questa classe, è consigliabile utilizzare la stessa funzione di perdita nel ciclo di addestramento dei modelli. Segui i seguenti passaggi secondari per creare una classe implementata con lo SageMaker smart `Loss` sifting.

   1. SageMaker smart sifting calcola un valore di perdita per ogni campione di dati di allenamento, anziché calcolare un singolo valore di perdita per un batch. Per garantire che lo SageMaker smart sifting utilizzi la stessa logica di calcolo delle perdite, create una funzione di smart-sifting-implemented perdita utilizzando il `Loss` modulo SageMaker smart sifting che utilizza la funzione di perdita e calcola la perdita per campione di allenamento. 
**Suggerimento**  
SageMaker l'algoritmo smart sifting viene eseguito su ogni campione di dati, non sull'intero batch, pertanto è necessario aggiungere una funzione di inizializzazione per impostare la funzione di perdita senza alcuna strategia di riduzione. PyTorch   

      ```
      class {{SiftingImplementedLoss}}(Loss):  
          def __init__(self):
              self.loss = {{torch.nn.CrossEntropyLoss}}(reduction='none')
      ```
Questo processo viene mostrato anche nell’esempio di codice seguente.

   1. Definite una funzione di perdita che accetti il modello `original_batch` (o `transformed_batch` se avete impostato una trasformazione batch nel passaggio 2) e il modello. PyTorch Utilizzando la funzione di perdita specificata senza alcuna riduzione, SageMaker Smart Sifting esegue un passaggio in avanti per ogni campione di dati per valutarne il valore di perdita. 

   Il codice seguente è un esempio di smart-sifting-implemented `Loss` interfaccia denominata. `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])
   ```

   Prima che il ciclo di addestramento raggiunga l’effettivo passaggio avanti, questo calcolo della perdita di sifting viene eseguito durante la fase di caricamento dei dati di recupero di un batch in ogni iterazione. Il valore di perdita individuale viene quindi confrontato con i valori di perdita precedenti e il relativo percentile relativo viene stimato in base all’oggetto di `RelativeProbabilisticSiftConfig` impostato nella fase 1.

1. Avvolgi il caricatore di PyTroch dati in base alla `SiftingDataloader` classe SageMaker AI.

   Infine, utilizza tutte le classi implementate in SageMaker smart sifting che hai configurato nei passaggi precedenti per la classe di configurazione SageMaker AI`SiftingDataloder`. Questa classe è un wrapper per. PyTorch [https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) Tramite il wrapping PyTorch`DataLoader`, lo SageMaker smart sifting viene registrato per essere eseguito come parte del caricamento dei dati in ogni iterazione di un processo di formazione. PyTorch Il seguente esempio di codice dimostra l'implementazione del setacciamento dei dati SageMaker AI su 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}}
   )
   ```