Applica SageMaker lo smart sifting al tuo script PyTorch

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

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.

I due parametri seguenti sono ciò che è necessario specificare alla RelativeProbabilisticSiftConfig classe per creare un oggetto di configurazione di setacciamento.
- Specificate la proporzione di dati da utilizzare per l'addestramento al beta_value parametro.
- Specificare il numero di campioni utilizzati nel confronto con il loss_history_length parametro.
Il seguente esempio di codice mostra l'impostazione di un oggetto della RelativeProbabilisticSiftConfig classe.
```
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 nella sezione di riferimento SDK Python di SageMaker smart sifting.

L'sift_configoggetto nell'esempio di codice precedente viene utilizzato nel passaggio 4 per configurare la classe. SiftingDataloader

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

Casi d'uso diversi per la formazione richiedono formati di dati di formazione diversi. Data la varietà di formati di dati, l'algoritmo di setacciamento SageMaker intelligente deve identificare come eseguire la setacciatura su un determinato lotto. 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.

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 saltate questo passaggio, nel passaggio 4 per la configurazioneSiftingDataloader, lasciate il batch_transforms parametro di SiftingDataloader al suo valore predefinito, che è. None

Se il set di dati non è in questi formati, dovresti procedere con il resto di questo passaggio per creare una trasformazione batch personalizzata utilizzando. 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 batch_transforms parametro batch_format_index or alla SiftingDataloader classe, impostata nel passaggio 4. Di seguito sono riportati alcuni esempi di errori dovuti a un formato di dati incompatibile e le relative risoluzioni.

Messaggio di errore	Risoluzione
Batch di tipo `{type(batch)}` non sono supportati per impostazione predefinita.	Questo errore indica che il formato batch non è supportato per impostazione predefinita. È necessario implementare una classe di trasformazione batch personalizzata e utilizzarla specificandola nel `batch_transforms` parametro della `SiftingDataloader` classe.
Impossibile indicizzare il tipo di batch `{type(batch)}`	Questo errore indica che l'oggetto batch non può essere indicizzato normalmente. L'utente deve implementare una trasformazione batch personalizzata e passarla utilizzando il `batch_transforms` parametro.
Dimensione batch `{batch_size}` non corrisponde alle dimensioni della dimensione 0 o della dimensione 1	Questo errore si verifica quando la dimensione del batch fornita non corrisponde alla dimensione 0 o alla prima dimensione del batch. L'utente deve implementare una trasformazione batch personalizzata e passarla utilizzando il `batch_transforms` parametro.
Sia la dimensione 0 che la dimensione 1 corrispondono alla dimensione del batch	Questo errore indica che, poiché più dimensioni corrispondono alla dimensione del batch fornita, sono necessarie ulteriori informazioni per setacciare il batch. L'utente può fornire il `batch_format_index` parametro per indicare se il batch è indicizzabile per campione o funzionalità. Gli utenti possono anche implementare una trasformazione batch personalizzata, ma ciò richiede più lavoro del necessario.

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

Di seguito sono riportati alcuni esempi di classi di trasformazione batch personalizzate del SiftingBatchTransform modulo.

Un esempio di implementazione di trasformazione batch di elenchi personalizzati con SageMaker smart sifting per i casi in cui il blocco del dataloader ha 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 batch SiftingBatchTransform -implemted, si utilizza questa classe nel passaggio 4 per configurare la classe. SiftingDataloader Il resto di questa guida presuppone la creazione di una ListBatchTransform classe. Nel passaggio 4, questa classe viene passata a. batch_transforms

Crea una classe per implementare l'interfaccia SageMaker smart sifting. Loss Questo tutorial presuppone che la classe abbia un nome. SiftingImplementedLoss Durante la configurazione di questa classe, si consiglia di utilizzare la stessa funzione di perdita nel ciclo di allenamento del modello. Segui i seguenti passaggi secondari per creare una classe implementata con SageMaker lo smart siftingLoss.
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')
```
  Ciò è illustrato anche nel seguente esempio di codice.
2. 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 PyTorch modello. 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 allenamento raggiunga l'effettivo passaggio in avanti, questo calcolo della perdita di setacciamento 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 impostato nella RelativeProbabilisticSiftConfig fase 1.
Avvolgi il caricatore di PyTroch dati in base alla SageMaker SiftingDataloader classe.

Infine, utilizza tutte le classi implementate in SageMaker smart sifting che hai configurato nei passaggi precedenti per la SageMaker SiftingDataloder classe di configurazione. Questa classe è un wrapper per. PyTorch DataLoader Tramite il wrapping PyTorchDataLoader, 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 SageMaker del setacciamento dei dati 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
)
```

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

SageMaker setacciare in modo intelligente il copione di allenamento

Applica SageMaker lo smart sifting allo script di Hugging Face Transformers

Applica SageMaker lo smart sifting al tuo script PyTorch

Suggerimento